Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "m", "*", "MockSession", ")", "AcceptUniStream", "(", ")", "(", "quic_go", ".", "ReceiveStream", ",", "error", ")", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "quic_go", ".", "ReceiveStream", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "AcceptUniStream", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockSession", ")", "CloseWithError", "(", "arg0", "protocol", ".", "ApplicationErrorCode", ",", "arg1", "error", ")", "error", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "CloseWithError", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockSessionMockRecorder", ")", "CloseWithError", "(", "arg0", ",", "arg1", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "mr", ".", "mock", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockSession", ")", "(", "nil", ")", ".", "CloseWithError", ")", ",", "arg0", ",", "arg1", ")", "\n", "}" ]

[ "CloseWithError", "indicates", "an", "expected", "call", "of", "CloseWithError" ]

[ "func", "(", "mr", "*", "MockSessionMockRecorder", ")", "LocalAddr", "(", ")", "*", "gomock", ".", "Call", "{", "mr", ".", "mock", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockSession", ")", "(", "nil", ")", ".", "LocalAddr", ")", ")", "\n", "}" ]

[ "LocalAddr", "indicates", "an", "expected", "call", "of", "LocalAddr" ]

[ "func", "(", "m", "*", "MockSession", ")", "OpenStream", "(", ")", "(", "quic_go", ".", "Stream", ",", "error", ")", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "quic_go", ".", "Stream", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "OpenStream", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockSession", ")", "OpenUniStream", "(", ")", "(", "quic_go", ".", "SendStream", ",", "error", ")", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "quic_go", ".", "SendStream", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "OpenUniStream", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockSession", ")", "RemoteAddr", "(", ")", "net", ".", "Addr", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "net", ".", "Addr", ")", "\n", "return", "ret0", "\n", "}" ]

[ "RemoteAddr", "mocks", "base", "method" ]

[ "func", "(", "l", "*", "ItemList", ")", "PushFrontList", "(", "other", "*", "ItemList", ")", "{", "l", ".", "lazyInit", "(", ")", "\n", "for", "i", ",", "e", ":=", "other", ".", "Len", "(", ")", ",", "other", ".", "Back", "(", ")", ";", "i", ">", "0", ";", "i", ",", "e", "=", "i", "-", "1", ",", "e", ".", "Prev", "(", ")", "{", "l", ".", "insertValue", "(", "e", ".", "Value", ",", "&", "l", ".", "root", ")", "\n", "}", "\n", "}" ]

[ "PushFrontList", "inserts", "a", "copy", "of", "an", "other", "list", "at", "the", "front", "of", "list", "l", ".", "The", "lists", "l", "and", "other", "may", "be", "the", "same", ".", "They", "must", "not", "be", "nil", "." ]

[ "func", "IsFrameAckEliciting", "(", "f", "wire", ".", "Frame", ")", "bool", "{", "switch", "f", ".", "(", "type", ")", "{", "case", "*", "wire", ".", "AckFrame", ":", "return", "false", "\n", "default", ":", "return", "true", "\n", "}", "\n", "}" ]

[ "IsFrameAckEliciting", "returns", "true", "if", "the", "frame", "is", "ack", "-", "eliciting", "." ]

[ "func", "HasAckElicitingFrames", "(", "fs", "[", "]", "wire", ".", "Frame", ")", "bool", "{", "for", "_", ",", "f", ":=", "range", "fs", "{", "if", "IsFrameAckEliciting", "(", "f", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "HasAckElicitingFrames", "returns", "true", "if", "at", "least", "one", "frame", "is", "ack", "-", "eliciting", "." ]

[ "func", "IsSupportedVersion", "(", "supported", "[", "]", "VersionNumber", ",", "v", "VersionNumber", ")", "bool", "{", "for", "_", ",", "t", ":=", "range", "supported", "{", "if", "t", "==", "v", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "IsSupportedVersion", "returns", "true", "if", "the", "server", "supports", "this", "version" ]

[ "func", "GetGreasedVersions", "(", "supported", "[", "]", "VersionNumber", ")", "[", "]", "VersionNumber", "{", "b", ":=", "make", "(", "[", "]", "byte", ",", "1", ")", "\n", "_", ",", "_", "=", "rand", ".", "Read", "(", "b", ")", "// ignore the error here. Failure to read random data doesn't break anything", "\n", "randPos", ":=", "int", "(", "b", "[", "0", "]", ")", "%", "(", "len", "(", "supported", ")", "+", "1", ")", "\n", "greased", ":=", "make", "(", "[", "]", "VersionNumber", ",", "len", "(", "supported", ")", "+", "1", ")", "\n", "copy", "(", "greased", ",", "supported", "[", ":", "randPos", "]", ")", "\n", "greased", "[", "randPos", "]", "=", "generateReservedVersion", "(", ")", "\n", "copy", "(", "greased", "[", "randPos", "+", "1", ":", "]", ",", "supported", "[", "randPos", ":", "]", ")", "\n", "return", "greased", "\n", "}" ]

[ "GetGreasedVersions", "adds", "one", "reserved", "version", "number", "to", "a", "slice", "of", "version", "numbers", "at", "a", "random", "position" ]

[ "func", "StripGreasedVersions", "(", "versions", "[", "]", "VersionNumber", ")", "[", "]", "VersionNumber", "{", "realVersions", ":=", "make", "(", "[", "]", "VersionNumber", ",", "0", ",", "len", "(", "versions", ")", ")", "\n", "for", "_", ",", "v", ":=", "range", "versions", "{", "if", "v", "&", "0x0f0f0f0f", "!=", "0x0a0a0a0a", "{", "realVersions", "=", "append", "(", "realVersions", ",", "v", ")", "\n", "}", "\n", "}", "\n", "return", "realVersions", "\n", "}" ]

[ "StripGreasedVersions", "strips", "all", "greased", "versions", "from", "a", "slice", "of", "versions" ]

[ "func", "(", "h", "*", "sentPacketHistory", ")", "Iterate", "(", "cb", "func", "(", "*", "Packet", ")", "(", "cont", "bool", ",", "err", "error", ")", ")", "error", "{", "cont", ":=", "true", "\n", "for", "el", ":=", "h", ".", "packetList", ".", "Front", "(", ")", ";", "cont", "&&", "el", "!=", "nil", ";", "el", "=", "el", ".", "Next", "(", ")", "{", "var", "err", "error", "\n", "cont", ",", "err", "=", "cb", "(", "&", "el", ".", "Value", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Iterate", "iterates", "through", "all", "packets", ".", "The", "callback", "must", "not", "modify", "the", "history", "." ]

[ "func", "(", "h", "*", "sentPacketHistory", ")", "MarkCannotBeRetransmitted", "(", "pn", "protocol", ".", "PacketNumber", ")", "error", "{", "el", ",", "ok", ":=", "h", ".", "packetMap", "[", "pn", "]", "\n", "if", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "pn", ")", "\n", "}", "\n", "if", "el", ".", "Value", ".", "canBeRetransmitted", "{", "h", ".", "numOutstandingPackets", "--", "\n", "if", "h", ".", "numOutstandingPackets", "<", "0", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "el", ".", "Value", ".", "canBeRetransmitted", "=", "false", "\n", "if", "el", "==", "h", ".", "firstOutstanding", "{", "h", ".", "readjustFirstOutstanding", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "QueuePacketForRetransmission", "marks", "a", "packet", "for", "retransmission", ".", "A", "packet", "can", "only", "be", "queued", "once", "." ]

[ "func", "(", "h", "*", "sentPacketHistory", ")", "readjustFirstOutstanding", "(", ")", "{", "el", ":=", "h", ".", "firstOutstanding", ".", "Next", "(", ")", "\n", "for", "el", "!=", "nil", "&&", "!", "el", ".", "Value", ".", "canBeRetransmitted", "{", "el", "=", "el", ".", "Next", "(", ")", "\n", "}", "\n", "h", ".", "firstOutstanding", "=", "el", "\n", "}" ]

[ "readjustFirstOutstanding", "readjusts", "the", "pointer", "to", "the", "first", "outstanding", "packet", ".", "This", "is", "necessary", "every", "time", "the", "first", "outstanding", "packet", "is", "deleted", "or", "retransmitted", "." ]

[ "func", "NewReceivedPacketHandler", "(", "rttStats", "*", "congestion", ".", "RTTStats", ",", "logger", "utils", ".", "Logger", ",", "version", "protocol", ".", "VersionNumber", ",", ")", "ReceivedPacketHandler", "{", "return", "&", "receivedPacketHandler", "{", "initialPackets", ":", "newReceivedPacketTracker", "(", "rttStats", ",", "logger", ",", "version", ")", ",", "handshakePackets", ":", "newReceivedPacketTracker", "(", "rttStats", ",", "logger", ",", "version", ")", ",", "oneRTTPackets", ":", "newReceivedPacketTracker", "(", "rttStats", ",", "logger", ",", "version", ")", ",", "}", "\n", "}" ]

[ "NewReceivedPacketHandler", "creates", "a", "new", "receivedPacketHandler" ]

[ "func", "(", "h", "*", "receivedPacketHandler", ")", "IgnoreBelow", "(", "pn", "protocol", ".", "PacketNumber", ")", "{", "h", ".", "oneRTTPackets", ".", "IgnoreBelow", "(", "pn", ")", "\n", "}" ]

[ "only", "to", "be", "used", "with", "1", "-", "RTT", "packets" ]

[ "func", "NewMockStreamFlowController", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockStreamFlowController", "{", "mock", ":=", "&", "MockStreamFlowController", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockStreamFlowControllerMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

[ "NewMockStreamFlowController", "creates", "a", "new", "mock", "instance" ]

[ "func", "(", "m", "*", "MockStreamFlowController", ")", "Abandon", "(", ")", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "}" ]

[ "Abandon", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockStreamFlowControllerMockRecorder", ")", "Abandon", "(", ")", "*", "gomock", ".", "Call", "{", "mr", ".", "mock", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockStreamFlowController", ")", "(", "nil", ")", ".", "Abandon", ")", ")", "\n", "}" ]

[ "Abandon", "indicates", "an", "expected", "call", "of", "Abandon" ]

[ "func", "(", "m", "*", "MockStreamFlowController", ")", "IsNewlyBlocked", "(", ")", "(", "bool", ",", "protocol", ".", "ByteCount", ")", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "bool", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "protocol", ".", "ByteCount", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "IsNewlyBlocked", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockStreamFlowController", ")", "UpdateHighestReceived", "(", "arg0", "protocol", ".", "ByteCount", ",", "arg1", "bool", ")", "error", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "UpdateHighestReceived", "mocks", "base", "method" ]

[ "func", "(", "bigEndian", ")", "ReadUintN", "(", "b", "io", ".", "ByteReader", ",", "length", "uint8", ")", "(", "uint64", ",", "error", ")", "{", "var", "res", "uint64", "\n", "for", "i", ":=", "uint8", "(", "0", ")", ";", "i", "<", "length", ";", "i", "++", "{", "bt", ",", "err", ":=", "b", ".", "ReadByte", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "res", "^=", "uint64", "(", "bt", ")", "<<", "(", "(", "length", "-", "1", "-", "i", ")", "*", "8", ")", "\n", "}", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "ReadUintN", "reads", "N", "bytes" ]

[ "func", "(", "bigEndian", ")", "ReadUint32", "(", "b", "io", ".", "ByteReader", ")", "(", "uint32", ",", "error", ")", "{", "var", "b1", ",", "b2", ",", "b3", ",", "b4", "uint8", "\n", "var", "err", "error", "\n", "if", "b4", ",", "err", "=", "b", ".", "ReadByte", "(", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "if", "b3", ",", "err", "=", "b", ".", "ReadByte", "(", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "if", "b2", ",", "err", "=", "b", ".", "ReadByte", "(", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "if", "b1", ",", "err", "=", "b", ".", "ReadByte", "(", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "uint32", "(", "b1", ")", "+", "uint32", "(", "b2", ")", "<<", "8", "+", "uint32", "(", "b3", ")", "<<", "16", "+", "uint32", "(", "b4", ")", "<<", "24", ",", "nil", "\n", "}" ]

[ "ReadUint32", "reads", "a", "uint32" ]

[ "func", "(", "bigEndian", ")", "ReadUint16", "(", "b", "io", ".", "ByteReader", ")", "(", "uint16", ",", "error", ")", "{", "var", "b1", ",", "b2", "uint8", "\n", "var", "err", "error", "\n", "if", "b2", ",", "err", "=", "b", ".", "ReadByte", "(", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "if", "b1", ",", "err", "=", "b", ".", "ReadByte", "(", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "uint16", "(", "b1", ")", "+", "uint16", "(", "b2", ")", "<<", "8", ",", "nil", "\n", "}" ]

[ "ReadUint16", "reads", "a", "uint16" ]

[ "func", "(", "bigEndian", ")", "WriteUint32", "(", "b", "*", "bytes", ".", "Buffer", ",", "i", "uint32", ")", "{", "b", ".", "Write", "(", "[", "]", "byte", "{", "uint8", "(", "i", ">>", "24", ")", ",", "uint8", "(", "i", ">>", "16", ")", ",", "uint8", "(", "i", ">>", "8", ")", ",", "uint8", "(", "i", ")", "}", ")", "\n", "}" ]

[ "WriteUint32", "writes", "a", "uint32" ]

[ "func", "(", "bigEndian", ")", "WriteUint16", "(", "b", "*", "bytes", ".", "Buffer", ",", "i", "uint16", ")", "{", "b", ".", "Write", "(", "[", "]", "byte", "{", "uint8", "(", "i", ">>", "8", ")", ",", "uint8", "(", "i", ")", "}", ")", "\n", "}" ]

[ "WriteUint16", "writes", "a", "uint16" ]

[ "func", "LogFrame", "(", "logger", "utils", ".", "Logger", ",", "frame", "Frame", ",", "sent", "bool", ")", "{", "if", "!", "logger", ".", "Debug", "(", ")", "{", "return", "\n", "}", "\n", "dir", ":=", "\"", "\"", "\n", "if", "sent", "{", "dir", "=", "\"", "\"", "\n", "}", "\n", "switch", "f", ":=", "frame", ".", "(", "type", ")", "{", "case", "*", "CryptoFrame", ":", "dataLen", ":=", "protocol", ".", "ByteCount", "(", "len", "(", "f", ".", "Data", ")", ")", "\n", "logger", ".", "Debugf", "(", "\"", "\\t", "\"", ",", "dir", ",", "f", ".", "Offset", ",", "dataLen", ",", "f", ".", "Offset", "+", "dataLen", ")", "\n", "case", "*", "StreamFrame", ":", "logger", ".", "Debugf", "(", "\"", "\\t", "\"", ",", "dir", ",", "f", ".", "StreamID", ",", "f", ".", "FinBit", ",", "f", ".", "Offset", ",", "f", ".", "DataLen", "(", ")", ",", "f", ".", "Offset", "+", "f", ".", "DataLen", "(", ")", ")", "\n", "case", "*", "AckFrame", ":", "if", "len", "(", "f", ".", "AckRanges", ")", ">", "1", "{", "ackRanges", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "f", ".", "AckRanges", ")", ")", "\n", "for", "i", ",", "r", ":=", "range", "f", ".", "AckRanges", "{", "ackRanges", "[", "i", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "r", ".", "Largest", ",", "r", ".", "Smallest", ")", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\\t", "\"", ",", "dir", ",", "f", ".", "LargestAcked", "(", ")", ",", "f", ".", "LowestAcked", "(", ")", ",", "strings", ".", "Join", "(", "ackRanges", ",", "\"", "\"", ")", ",", "f", ".", "DelayTime", ".", "String", "(", ")", ")", "\n", "}", "else", "{", "logger", ".", "Debugf", "(", "\"", "\\t", "\"", ",", "dir", ",", "f", ".", "LargestAcked", "(", ")", ",", "f", ".", "LowestAcked", "(", ")", ",", "f", ".", "DelayTime", ".", "String", "(", ")", ")", "\n", "}", "\n", "case", "*", "NewConnectionIDFrame", ":", "logger", ".", "Debugf", "(", "\"", "\\t", "\"", ",", "dir", ",", "f", ".", "SequenceNumber", ",", "f", ".", "ConnectionID", ",", "f", ".", "StatelessResetToken", ")", "\n", "case", "*", "NewTokenFrame", ":", "logger", ".", "Debugf", "(", "\"", "\\t", "\"", ",", "dir", ",", "f", ".", "Token", ")", "\n", "default", ":", "logger", ".", "Debugf", "(", "\"", "\\t", "\"", ",", "dir", ",", "frame", ")", "\n", "}", "\n", "}" ]

[ "LogFrame", "logs", "a", "frame", "either", "sent", "or", "received" ]

[ "func", "DialAddr", "(", "addr", "string", ",", "tlsConf", "*", "tls", ".", "Config", ",", "config", "*", "Config", ",", ")", "(", "Session", ",", "error", ")", "{", "return", "DialAddrContext", "(", "context", ".", "Background", "(", ")", ",", "addr", ",", "tlsConf", ",", "config", ")", "\n", "}" ]

[ "DialAddr", "establishes", "a", "new", "QUIC", "connection", "to", "a", "server", ".", "It", "uses", "a", "new", "UDP", "connection", "and", "closes", "this", "connection", "when", "the", "QUIC", "session", "is", "closed", ".", "The", "hostname", "for", "SNI", "is", "taken", "from", "the", "given", "address", "." ]

[ "func", "DialAddrContext", "(", "ctx", "context", ".", "Context", ",", "addr", "string", ",", "tlsConf", "*", "tls", ".", "Config", ",", "config", "*", "Config", ",", ")", "(", "Session", ",", "error", ")", "{", "udpAddr", ",", "err", ":=", "net", ".", "ResolveUDPAddr", "(", "\"", "\"", ",", "addr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "udpConn", ",", "err", ":=", "net", ".", "ListenUDP", "(", "\"", "\"", ",", "&", "net", ".", "UDPAddr", "{", "IP", ":", "net", ".", "IPv4zero", ",", "Port", ":", "0", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "dialContext", "(", "ctx", ",", "udpConn", ",", "udpAddr", ",", "addr", ",", "tlsConf", ",", "config", ",", "true", ")", "\n", "}" ]

[ "DialAddrContext", "establishes", "a", "new", "QUIC", "connection", "to", "a", "server", "using", "the", "provided", "context", ".", "See", "DialAddr", "for", "details", "." ]

[ "func", "Dial", "(", "pconn", "net", ".", "PacketConn", ",", "remoteAddr", "net", ".", "Addr", ",", "host", "string", ",", "tlsConf", "*", "tls", ".", "Config", ",", "config", "*", "Config", ",", ")", "(", "Session", ",", "error", ")", "{", "return", "DialContext", "(", "context", ".", "Background", "(", ")", ",", "pconn", ",", "remoteAddr", ",", "host", ",", "tlsConf", ",", "config", ")", "\n", "}" ]

[ "Dial", "establishes", "a", "new", "QUIC", "connection", "to", "a", "server", "using", "a", "net", ".", "PacketConn", ".", "The", "same", "PacketConn", "can", "be", "used", "for", "multiple", "calls", "to", "Dial", "and", "Listen", "QUIC", "connection", "IDs", "are", "used", "for", "demultiplexing", "the", "different", "connections", ".", "The", "host", "parameter", "is", "used", "for", "SNI", "." ]

[ "func", "DialContext", "(", "ctx", "context", ".", "Context", ",", "pconn", "net", ".", "PacketConn", ",", "remoteAddr", "net", ".", "Addr", ",", "host", "string", ",", "tlsConf", "*", "tls", ".", "Config", ",", "config", "*", "Config", ",", ")", "(", "Session", ",", "error", ")", "{", "return", "dialContext", "(", "ctx", ",", "pconn", ",", "remoteAddr", ",", "host", ",", "tlsConf", ",", "config", ",", "false", ")", "\n", "}" ]

[ "DialContext", "establishes", "a", "new", "QUIC", "connection", "to", "a", "server", "using", "a", "net", ".", "PacketConn", "using", "the", "provided", "context", ".", "See", "Dial", "for", "details", "." ]

[ "func", "populateClientConfig", "(", "config", "*", "Config", ",", "createdPacketConn", "bool", ")", "*", "Config", "{", "if", "config", "==", "nil", "{", "config", "=", "&", "Config", "{", "}", "\n", "}", "\n", "versions", ":=", "config", ".", "Versions", "\n", "if", "len", "(", "versions", ")", "==", "0", "{", "versions", "=", "protocol", ".", "SupportedVersions", "\n", "}", "\n\n", "handshakeTimeout", ":=", "protocol", ".", "DefaultHandshakeTimeout", "\n", "if", "config", ".", "HandshakeTimeout", "!=", "0", "{", "handshakeTimeout", "=", "config", ".", "HandshakeTimeout", "\n", "}", "\n", "idleTimeout", ":=", "protocol", ".", "DefaultIdleTimeout", "\n", "if", "config", ".", "IdleTimeout", "!=", "0", "{", "idleTimeout", "=", "config", ".", "IdleTimeout", "\n", "}", "\n\n", "maxReceiveStreamFlowControlWindow", ":=", "config", ".", "MaxReceiveStreamFlowControlWindow", "\n", "if", "maxReceiveStreamFlowControlWindow", "==", "0", "{", "maxReceiveStreamFlowControlWindow", "=", "protocol", ".", "DefaultMaxReceiveStreamFlowControlWindow", "\n", "}", "\n", "maxReceiveConnectionFlowControlWindow", ":=", "config", ".", "MaxReceiveConnectionFlowControlWindow", "\n", "if", "maxReceiveConnectionFlowControlWindow", "==", "0", "{", "maxReceiveConnectionFlowControlWindow", "=", "protocol", ".", "DefaultMaxReceiveConnectionFlowControlWindow", "\n", "}", "\n", "maxIncomingStreams", ":=", "config", ".", "MaxIncomingStreams", "\n", "if", "maxIncomingStreams", "==", "0", "{", "maxIncomingStreams", "=", "protocol", ".", "DefaultMaxIncomingStreams", "\n", "}", "else", "if", "maxIncomingStreams", "<", "0", "{", "maxIncomingStreams", "=", "0", "\n", "}", "\n", "maxIncomingUniStreams", ":=", "config", ".", "MaxIncomingUniStreams", "\n", "if", "maxIncomingUniStreams", "==", "0", "{", "maxIncomingUniStreams", "=", "protocol", ".", "DefaultMaxIncomingUniStreams", "\n", "}", "else", "if", "maxIncomingUniStreams", "<", "0", "{", "maxIncomingUniStreams", "=", "0", "\n", "}", "\n", "connIDLen", ":=", "config", ".", "ConnectionIDLength", "\n", "if", "connIDLen", "==", "0", "&&", "!", "createdPacketConn", "{", "connIDLen", "=", "protocol", ".", "DefaultConnectionIDLength", "\n", "}", "\n\n", "return", "&", "Config", "{", "Versions", ":", "versions", ",", "HandshakeTimeout", ":", "handshakeTimeout", ",", "IdleTimeout", ":", "idleTimeout", ",", "ConnectionIDLength", ":", "connIDLen", ",", "MaxReceiveStreamFlowControlWindow", ":", "maxReceiveStreamFlowControlWindow", ",", "MaxReceiveConnectionFlowControlWindow", ":", "maxReceiveConnectionFlowControlWindow", ",", "MaxIncomingStreams", ":", "maxIncomingStreams", ",", "MaxIncomingUniStreams", ":", "maxIncomingUniStreams", ",", "KeepAlive", ":", "config", ".", "KeepAlive", ",", "StatelessResetKey", ":", "config", ".", "StatelessResetKey", ",", "}", "\n", "}" ]

[ "populateClientConfig", "populates", "fields", "in", "the", "quic", ".", "Config", "with", "their", "default", "values", "if", "none", "are", "set", "it", "may", "be", "called", "with", "nil" ]

[ "func", "MinByteCount", "(", "a", ",", "b", "protocol", ".", "ByteCount", ")", "protocol", ".", "ByteCount", "{", "if", "a", "<", "b", "{", "return", "a", "\n", "}", "\n", "return", "b", "\n", "}" ]

[ "MinByteCount", "returns", "the", "minimum", "of", "two", "ByteCounts" ]

[ "func", "MaxByteCount", "(", "a", ",", "b", "protocol", ".", "ByteCount", ")", "protocol", ".", "ByteCount", "{", "if", "a", "<", "b", "{", "return", "b", "\n", "}", "\n", "return", "a", "\n", "}" ]

[ "MaxByteCount", "returns", "the", "maximum", "of", "two", "ByteCounts" ]

[ "func", "MaxDuration", "(", "a", ",", "b", "time", ".", "Duration", ")", "time", ".", "Duration", "{", "if", "a", ">", "b", "{", "return", "a", "\n", "}", "\n", "return", "b", "\n", "}" ]

[ "MaxDuration", "returns", "the", "max", "duration" ]

[ "func", "MinTime", "(", "a", ",", "b", "time", ".", "Time", ")", "time", ".", "Time", "{", "if", "a", ".", "After", "(", "b", ")", "{", "return", "b", "\n", "}", "\n", "return", "a", "\n", "}" ]

[ "MinTime", "returns", "the", "earlier", "time" ]

[ "func", "MaxTime", "(", "a", ",", "b", "time", ".", "Time", ")", "time", ".", "Time", "{", "if", "a", ".", "After", "(", "b", ")", "{", "return", "a", "\n", "}", "\n", "return", "b", "\n", "}" ]

[ "MaxTime", "returns", "the", "later", "time" ]

[ "func", "MaxPacketNumber", "(", "a", ",", "b", "protocol", ".", "PacketNumber", ")", "protocol", ".", "PacketNumber", "{", "if", "a", ">", "b", "{", "return", "a", "\n", "}", "\n", "return", "b", "\n", "}" ]

[ "MaxPacketNumber", "returns", "the", "max", "packet", "number" ]

[ "func", "MinPacketNumber", "(", "a", ",", "b", "protocol", ".", "PacketNumber", ")", "protocol", ".", "PacketNumber", "{", "if", "a", "<", "b", "{", "return", "a", "\n", "}", "\n", "return", "b", "\n", "}" ]

[ "MinPacketNumber", "returns", "the", "min", "packet", "number" ]

[ "func", "(", "p", "*", "TransportParameters", ")", "String", "(", ")", "string", "{", "logString", ":=", "\"", "\"", "\n", "logParams", ":=", "[", "]", "interface", "{", "}", "{", "p", ".", "OriginalConnectionID", ",", "p", ".", "InitialMaxStreamDataBidiLocal", ",", "p", ".", "InitialMaxStreamDataBidiRemote", ",", "p", ".", "InitialMaxStreamDataUni", ",", "p", ".", "InitialMaxData", ",", "p", ".", "MaxBidiStreams", ",", "p", ".", "MaxUniStreams", ",", "p", ".", "IdleTimeout", ",", "p", ".", "AckDelayExponent", "}", "\n", "if", "p", ".", "StatelessResetToken", "!=", "nil", "{", "// the client never sends a stateless reset token", "logString", "+=", "\"", "\"", "\n", "logParams", "=", "append", "(", "logParams", ",", "*", "p", ".", "StatelessResetToken", ")", "\n", "}", "\n", "logString", "+=", "\"", "\"", "\n", "return", "fmt", ".", "Sprintf", "(", "logString", ",", "logParams", "...", ")", "\n", "}" ]

[ "String", "returns", "a", "string", "representation", "intended", "for", "logging", "." ]

[ "func", "NewCryptoSetupClient", "(", "initialStream", "io", ".", "Writer", ",", "handshakeStream", "io", ".", "Writer", ",", "oneRTTStream", "io", ".", "Writer", ",", "connID", "protocol", ".", "ConnectionID", ",", "remoteAddr", "net", ".", "Addr", ",", "tp", "*", "TransportParameters", ",", "handleParams", "func", "(", "[", "]", "byte", ")", ",", "tlsConf", "*", "tls", ".", "Config", ",", "logger", "utils", ".", "Logger", ",", ")", "(", "CryptoSetup", ",", "<-", "chan", "struct", "{", "}", "/* ClientHello written */", ",", "error", ")", "{", "cs", ",", "clientHelloWritten", ",", "err", ":=", "newCryptoSetup", "(", "initialStream", ",", "handshakeStream", ",", "oneRTTStream", ",", "connID", ",", "tp", ",", "handleParams", ",", "tlsConf", ",", "logger", ",", "protocol", ".", "PerspectiveClient", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "cs", ".", "conn", "=", "qtls", ".", "Client", "(", "newConn", "(", "remoteAddr", ")", ",", "cs", ".", "tlsConf", ")", "\n", "return", "cs", ",", "clientHelloWritten", ",", "nil", "\n", "}" ]

[ "NewCryptoSetupClient", "creates", "a", "new", "crypto", "setup", "for", "the", "client" ]

[ "func", "NewCryptoSetupServer", "(", "initialStream", "io", ".", "Writer", ",", "handshakeStream", "io", ".", "Writer", ",", "oneRTTStream", "io", ".", "Writer", ",", "connID", "protocol", ".", "ConnectionID", ",", "remoteAddr", "net", ".", "Addr", ",", "tp", "*", "TransportParameters", ",", "handleParams", "func", "(", "[", "]", "byte", ")", ",", "tlsConf", "*", "tls", ".", "Config", ",", "logger", "utils", ".", "Logger", ",", ")", "(", "CryptoSetup", ",", "error", ")", "{", "cs", ",", "_", ",", "err", ":=", "newCryptoSetup", "(", "initialStream", ",", "handshakeStream", ",", "oneRTTStream", ",", "connID", ",", "tp", ",", "handleParams", ",", "tlsConf", ",", "logger", ",", "protocol", ".", "PerspectiveServer", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "cs", ".", "conn", "=", "qtls", ".", "Server", "(", "newConn", "(", "remoteAddr", ")", ",", "cs", ".", "tlsConf", ")", "\n", "return", "cs", ",", "nil", "\n", "}" ]

[ "NewCryptoSetupServer", "creates", "a", "new", "crypto", "setup", "for", "the", "server" ]

[ "func", "(", "h", "*", "cryptoSetup", ")", "HandleMessage", "(", "data", "[", "]", "byte", ",", "encLevel", "protocol", ".", "EncryptionLevel", ")", "bool", "/* stream finished */", "{", "msgType", ":=", "messageType", "(", "data", "[", "0", "]", ")", "\n", "h", ".", "logger", ".", "Debugf", "(", "\"", "\"", ",", "msgType", ",", "len", "(", "data", ")", ",", "encLevel", ")", "\n", "if", "err", ":=", "h", ".", "checkEncryptionLevel", "(", "msgType", ",", "encLevel", ")", ";", "err", "!=", "nil", "{", "h", ".", "messageErrChan", "<-", "err", "\n", "return", "false", "\n", "}", "\n", "h", ".", "messageChan", "<-", "data", "\n", "switch", "h", ".", "perspective", "{", "case", "protocol", ".", "PerspectiveClient", ":", "return", "h", ".", "handleMessageForClient", "(", "msgType", ")", "\n", "case", "protocol", ".", "PerspectiveServer", ":", "return", "h", ".", "handleMessageForServer", "(", "msgType", ")", "\n", "default", ":", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "handleMessage", "handles", "a", "TLS", "handshake", "message", ".", "It", "is", "called", "by", "the", "crypto", "streams", "when", "a", "new", "message", "is", "available", ".", "It", "returns", "if", "it", "is", "done", "with", "messages", "on", "the", "same", "encryption", "level", "." ]

[ "func", "(", "h", "*", "cryptoSetup", ")", "ReadHandshakeMessage", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "msg", ",", "ok", ":=", "<-", "h", ".", "messageChan", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "msg", ",", "nil", "\n", "}" ]

[ "ReadHandshakeMessage", "is", "called", "by", "TLS", ".", "It", "blocks", "until", "a", "new", "handshake", "message", "is", "available", "." ]

[ "func", "(", "h", "*", "cryptoSetup", ")", "WriteRecord", "(", "p", "[", "]", "byte", ")", "(", "int", ",", "error", ")", "{", "defer", "func", "(", ")", "{", "select", "{", "case", "h", ".", "writeRecord", "<-", "struct", "{", "}", "{", "}", ":", "default", ":", "}", "\n", "}", "(", ")", "\n\n", "h", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "h", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "switch", "h", ".", "writeEncLevel", "{", "case", "protocol", ".", "EncryptionInitial", ":", "// assume that the first WriteRecord call contains the ClientHello", "n", ",", "err", ":=", "h", ".", "initialStream", ".", "Write", "(", "p", ")", "\n", "if", "!", "h", ".", "clientHelloWritten", "&&", "h", ".", "perspective", "==", "protocol", ".", "PerspectiveClient", "{", "h", ".", "clientHelloWritten", "=", "true", "\n", "close", "(", "h", ".", "clientHelloWrittenChan", ")", "\n", "}", "\n", "return", "n", ",", "err", "\n", "case", "protocol", ".", "EncryptionHandshake", ":", "return", "h", ".", "handshakeStream", ".", "Write", "(", "p", ")", "\n", "case", "protocol", ".", "Encryption1RTT", ":", "return", "h", ".", "oneRTTStream", ".", "Write", "(", "p", ")", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "h", ".", "writeEncLevel", ")", ")", "\n", "}", "\n", "}" ]

[ "WriteRecord", "is", "called", "when", "TLS", "writes", "data" ]

[ "func", "NewMockOpener", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockOpener", "{", "mock", ":=", "&", "MockOpener", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockOpenerMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

[ "NewMockOpener", "creates", "a", "new", "mock", "instance" ]

[ "func", "(", "m", "*", "MockOpener", ")", "DecryptHeader", "(", "arg0", "[", "]", "byte", ",", "arg1", "*", "byte", ",", "arg2", "[", "]", "byte", ")", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ",", "arg2", ")", "\n", "}" ]

[ "DecryptHeader", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockOpenerMockRecorder", ")", "DecryptHeader", "(", "arg0", ",", "arg1", ",", "arg2", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "mr", ".", "mock", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockOpener", ")", "(", "nil", ")", ".", "DecryptHeader", ")", ",", "arg0", ",", "arg1", ",", "arg2", ")", "\n", "}" ]

[ "DecryptHeader", "indicates", "an", "expected", "call", "of", "DecryptHeader" ]

[ "func", "(", "m", "*", "MockOpener", ")", "Open", "(", "arg0", ",", "arg1", "[", "]", "byte", ",", "arg2", "protocol", ".", "PacketNumber", ",", "arg3", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ",", "arg2", ",", "arg3", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "[", "]", "byte", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "Open", "mocks", "base", "method" ]

[ "func", "NewTimer", "(", ")", "*", "Timer", "{", "return", "&", "Timer", "{", "t", ":", "time", ".", "NewTimer", "(", "time", ".", "Duration", "(", "math", ".", "MaxInt64", ")", ")", "}", "\n", "}" ]

[ "NewTimer", "creates", "a", "new", "timer", "that", "is", "not", "set" ]

[ "func", "(", "t", "*", "Timer", ")", "Reset", "(", "deadline", "time", ".", "Time", ")", "{", "if", "deadline", ".", "Equal", "(", "t", ".", "deadline", ")", "&&", "!", "t", ".", "read", "{", "// No need to reset the timer", "return", "\n", "}", "\n\n", "// We need to drain the timer if the value from its channel was not read yet.", "// See https://groups.google.com/forum/#!topic/golang-dev/c9UUfASVPoU", "if", "!", "t", ".", "t", ".", "Stop", "(", ")", "&&", "!", "t", ".", "read", "{", "<-", "t", ".", "t", ".", "C", "\n", "}", "\n", "if", "!", "deadline", ".", "IsZero", "(", ")", "{", "t", ".", "t", ".", "Reset", "(", "time", ".", "Until", "(", "deadline", ")", ")", "\n", "}", "\n\n", "t", ".", "read", "=", "false", "\n", "t", ".", "deadline", "=", "deadline", "\n", "}" ]

[ "Reset", "the", "timer", "no", "matter", "whether", "the", "value", "was", "read", "or", "not" ]

[ "func", "NewMockCryptoSetup", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockCryptoSetup", "{", "mock", ":=", "&", "MockCryptoSetup", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockCryptoSetupMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

[ "NewMockCryptoSetup", "creates", "a", "new", "mock", "instance" ]

[ "func", "(", "m", "*", "MockCryptoSetup", ")", "ChangeConnectionID", "(", "arg0", "protocol", ".", "ConnectionID", ")", "error", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "ChangeConnectionID", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockCryptoSetupMockRecorder", ")", "ChangeConnectionID", "(", "arg0", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "mr", ".", "mock", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockCryptoSetup", ")", "(", "nil", ")", ".", "ChangeConnectionID", ")", ",", "arg0", ")", "\n", "}" ]

[ "ChangeConnectionID", "indicates", "an", "expected", "call", "of", "ChangeConnectionID" ]

[ "func", "(", "m", "*", "MockCryptoSetup", ")", "ConnectionState", "(", ")", "tls", ".", "ConnectionState", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "tls", ".", "ConnectionState", ")", "\n", "return", "ret0", "\n", "}" ]

[ "ConnectionState", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockCryptoSetup", ")", "GetOpener", "(", "arg0", "protocol", ".", "EncryptionLevel", ")", "(", "handshake", ".", "Opener", ",", "error", ")", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "handshake", ".", "Opener", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "GetOpener", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockCryptoSetup", ")", "GetSealer", "(", ")", "(", "protocol", ".", "EncryptionLevel", ",", "handshake", ".", "Sealer", ")", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "protocol", ".", "EncryptionLevel", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "handshake", ".", "Sealer", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "GetSealer", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockCryptoSetup", ")", "GetSealerWithEncryptionLevel", "(", "arg0", "protocol", ".", "EncryptionLevel", ")", "(", "handshake", ".", "Sealer", ",", "error", ")", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "handshake", ".", "Sealer", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "GetSealerWithEncryptionLevel", "mocks", "base", "method" ]

[ "func", "parseAckFrame", "(", "r", "*", "bytes", ".", "Reader", ",", "ackDelayExponent", "uint8", ",", "version", "protocol", ".", "VersionNumber", ")", "(", "*", "AckFrame", ",", "error", ")", "{", "typeByte", ",", "err", ":=", "r", ".", "ReadByte", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "ecn", ":=", "typeByte", "&", "0x1", ">", "0", "\n\n", "frame", ":=", "&", "AckFrame", "{", "}", "\n\n", "la", ",", "err", ":=", "utils", ".", "ReadVarInt", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "largestAcked", ":=", "protocol", ".", "PacketNumber", "(", "la", ")", "\n", "delay", ",", "err", ":=", "utils", ".", "ReadVarInt", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "frame", ".", "DelayTime", "=", "time", ".", "Duration", "(", "delay", "*", "1", "<<", "ackDelayExponent", ")", "*", "time", ".", "Microsecond", "\n\n", "numBlocks", ",", "err", ":=", "utils", ".", "ReadVarInt", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// read the first ACK range", "ab", ",", "err", ":=", "utils", ".", "ReadVarInt", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "ackBlock", ":=", "protocol", ".", "PacketNumber", "(", "ab", ")", "\n", "if", "ackBlock", ">", "largestAcked", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "smallest", ":=", "largestAcked", "-", "ackBlock", "\n\n", "// read all the other ACK ranges", "frame", ".", "AckRanges", "=", "append", "(", "frame", ".", "AckRanges", ",", "AckRange", "{", "Smallest", ":", "smallest", ",", "Largest", ":", "largestAcked", "}", ")", "\n", "for", "i", ":=", "uint64", "(", "0", ")", ";", "i", "<", "numBlocks", ";", "i", "++", "{", "g", ",", "err", ":=", "utils", ".", "ReadVarInt", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "gap", ":=", "protocol", ".", "PacketNumber", "(", "g", ")", "\n", "if", "smallest", "<", "gap", "+", "2", "{", "return", "nil", ",", "errInvalidAckRanges", "\n", "}", "\n", "largest", ":=", "smallest", "-", "gap", "-", "2", "\n\n", "ab", ",", "err", ":=", "utils", ".", "ReadVarInt", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "ackBlock", ":=", "protocol", ".", "PacketNumber", "(", "ab", ")", "\n\n", "if", "ackBlock", ">", "largest", "{", "return", "nil", ",", "errInvalidAckRanges", "\n", "}", "\n", "smallest", "=", "largest", "-", "ackBlock", "\n", "frame", ".", "AckRanges", "=", "append", "(", "frame", ".", "AckRanges", ",", "AckRange", "{", "Smallest", ":", "smallest", ",", "Largest", ":", "largest", "}", ")", "\n", "}", "\n\n", "if", "!", "frame", ".", "validateAckRanges", "(", ")", "{", "return", "nil", ",", "errInvalidAckRanges", "\n", "}", "\n\n", "// parse (and skip) the ECN section", "if", "ecn", "{", "for", "i", ":=", "0", ";", "i", "<", "3", ";", "i", "++", "{", "if", "_", ",", "err", ":=", "utils", ".", "ReadVarInt", "(", "r", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "frame", ",", "nil", "\n", "}" ]

[ "parseAckFrame", "reads", "an", "ACK", "frame" ]

[ "func", "(", "f", "*", "AckFrame", ")", "Write", "(", "b", "*", "bytes", ".", "Buffer", ",", "version", "protocol", ".", "VersionNumber", ")", "error", "{", "b", ".", "WriteByte", "(", "0x2", ")", "\n", "utils", ".", "WriteVarInt", "(", "b", ",", "uint64", "(", "f", ".", "LargestAcked", "(", ")", ")", ")", "\n", "utils", ".", "WriteVarInt", "(", "b", ",", "encodeAckDelay", "(", "f", ".", "DelayTime", ")", ")", "\n\n", "numRanges", ":=", "f", ".", "numEncodableAckRanges", "(", ")", "\n", "utils", ".", "WriteVarInt", "(", "b", ",", "uint64", "(", "numRanges", "-", "1", ")", ")", "\n\n", "// write the first range", "_", ",", "firstRange", ":=", "f", ".", "encodeAckRange", "(", "0", ")", "\n", "utils", ".", "WriteVarInt", "(", "b", ",", "firstRange", ")", "\n\n", "// write all the other range", "for", "i", ":=", "1", ";", "i", "<", "numRanges", ";", "i", "++", "{", "gap", ",", "len", ":=", "f", ".", "encodeAckRange", "(", "i", ")", "\n", "utils", ".", "WriteVarInt", "(", "b", ",", "gap", ")", "\n", "utils", ".", "WriteVarInt", "(", "b", ",", "len", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Write", "writes", "an", "ACK", "frame", "." ]

[ "func", "(", "f", "*", "AckFrame", ")", "numEncodableAckRanges", "(", ")", "int", "{", "length", ":=", "1", "+", "utils", ".", "VarIntLen", "(", "uint64", "(", "f", ".", "LargestAcked", "(", ")", ")", ")", "+", "utils", ".", "VarIntLen", "(", "encodeAckDelay", "(", "f", ".", "DelayTime", ")", ")", "\n", "length", "+=", "2", "// assume that the number of ranges will consume 2 bytes", "\n", "for", "i", ":=", "1", ";", "i", "<", "len", "(", "f", ".", "AckRanges", ")", ";", "i", "++", "{", "gap", ",", "len", ":=", "f", ".", "encodeAckRange", "(", "i", ")", "\n", "rangeLen", ":=", "utils", ".", "VarIntLen", "(", "gap", ")", "+", "utils", ".", "VarIntLen", "(", "len", ")", "\n", "if", "length", "+", "rangeLen", ">", "protocol", ".", "MaxAckFrameSize", "{", "// Writing range i would exceed the MaxAckFrameSize.", "// So encode one range less than that.", "return", "i", "-", "1", "\n", "}", "\n", "length", "+=", "rangeLen", "\n", "}", "\n", "return", "len", "(", "f", ".", "AckRanges", ")", "\n", "}" ]

[ "gets", "the", "number", "of", "ACK", "ranges", "that", "can", "be", "encoded", "such", "that", "the", "resulting", "frame", "is", "smaller", "than", "the", "maximum", "ACK", "frame", "size" ]

[ "func", "(", "f", "*", "AckFrame", ")", "LowestAcked", "(", ")", "protocol", ".", "PacketNumber", "{", "return", "f", ".", "AckRanges", "[", "len", "(", "f", ".", "AckRanges", ")", "-", "1", "]", ".", "Smallest", "\n", "}" ]

[ "LowestAcked", "is", "the", "lowest", "acked", "packet", "number" ]

[ "func", "(", "f", "*", "AckFrame", ")", "AcksPacket", "(", "p", "protocol", ".", "PacketNumber", ")", "bool", "{", "if", "p", "<", "f", ".", "LowestAcked", "(", ")", "||", "p", ">", "f", ".", "LargestAcked", "(", ")", "{", "return", "false", "\n", "}", "\n\n", "i", ":=", "sort", ".", "Search", "(", "len", "(", "f", ".", "AckRanges", ")", ",", "func", "(", "i", "int", ")", "bool", "{", "return", "p", ">=", "f", ".", "AckRanges", "[", "i", "]", ".", "Smallest", "\n", "}", ")", "\n", "// i will always be < len(f.AckRanges), since we checked above that p is not bigger than the largest acked", "return", "p", "<=", "f", ".", "AckRanges", "[", "i", "]", ".", "Largest", "\n", "}" ]

[ "AcksPacket", "determines", "if", "this", "ACK", "frame", "acks", "a", "certain", "packet", "number" ]

[ "func", "ParseConnectionID", "(", "data", "[", "]", "byte", ",", "shortHeaderConnIDLen", "int", ")", "(", "protocol", ".", "ConnectionID", ",", "error", ")", "{", "if", "len", "(", "data", ")", "==", "0", "{", "return", "nil", ",", "io", ".", "EOF", "\n", "}", "\n", "isLongHeader", ":=", "data", "[", "0", "]", "&", "0x80", ">", "0", "\n", "if", "!", "isLongHeader", "{", "if", "len", "(", "data", ")", "<", "shortHeaderConnIDLen", "+", "1", "{", "return", "nil", ",", "io", ".", "EOF", "\n", "}", "\n", "return", "protocol", ".", "ConnectionID", "(", "data", "[", "1", ":", "1", "+", "shortHeaderConnIDLen", "]", ")", ",", "nil", "\n", "}", "\n", "if", "len", "(", "data", ")", "<", "6", "{", "return", "nil", ",", "io", ".", "EOF", "\n", "}", "\n", "destConnIDLen", ",", "_", ":=", "decodeConnIDLen", "(", "data", "[", "5", "]", ")", "\n", "if", "len", "(", "data", ")", "<", "6", "+", "destConnIDLen", "{", "return", "nil", ",", "io", ".", "EOF", "\n", "}", "\n", "return", "protocol", ".", "ConnectionID", "(", "data", "[", "6", ":", "6", "+", "destConnIDLen", "]", ")", ",", "nil", "\n", "}" ]

[ "ParseConnectionID", "parses", "the", "destination", "connection", "ID", "of", "a", "packet", ".", "It", "uses", "the", "data", "slice", "for", "the", "connection", "ID", ".", "That", "means", "that", "the", "connection", "ID", "must", "not", "be", "used", "after", "the", "packet", "buffer", "is", "released", "." ]

[ "func", "IsVersionNegotiationPacket", "(", "b", "[", "]", "byte", ")", "bool", "{", "if", "len", "(", "b", ")", "<", "5", "{", "return", "false", "\n", "}", "\n", "return", "b", "[", "0", "]", "&", "0x80", ">", "0", "&&", "b", "[", "1", "]", "==", "0", "&&", "b", "[", "2", "]", "==", "0", "&&", "b", "[", "3", "]", "==", "0", "&&", "b", "[", "4", "]", "==", "0", "\n", "}" ]

[ "IsVersionNegotiationPacket", "says", "if", "this", "is", "a", "version", "negotiation", "packet" ]

[ "func", "ParsePacket", "(", "data", "[", "]", "byte", ",", "shortHeaderConnIDLen", "int", ")", "(", "*", "Header", ",", "[", "]", "byte", "/* packet data */", ",", "[", "]", "byte", "/* rest */", ",", "error", ")", "{", "hdr", ",", "err", ":=", "parseHeader", "(", "bytes", ".", "NewReader", "(", "data", ")", ",", "shortHeaderConnIDLen", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "==", "errUnsupportedVersion", "{", "return", "hdr", ",", "nil", ",", "nil", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "var", "rest", "[", "]", "byte", "\n", "if", "hdr", ".", "IsLongHeader", "{", "if", "protocol", ".", "ByteCount", "(", "len", "(", "data", ")", ")", "<", "hdr", ".", "ParsedLen", "(", ")", "+", "hdr", ".", "Length", "{", "return", "nil", ",", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "data", ")", "-", "int", "(", "hdr", ".", "ParsedLen", "(", ")", ")", ",", "hdr", ".", "Length", ")", "\n", "}", "\n", "packetLen", ":=", "int", "(", "hdr", ".", "ParsedLen", "(", ")", "+", "hdr", ".", "Length", ")", "\n", "rest", "=", "data", "[", "packetLen", ":", "]", "\n", "data", "=", "data", "[", ":", "packetLen", "]", "\n", "}", "\n", "return", "hdr", ",", "data", ",", "rest", ",", "nil", "\n", "}" ]

[ "ParsePacket", "parses", "a", "packet", ".", "If", "the", "packet", "has", "a", "long", "header", "the", "packet", "is", "cut", "according", "to", "the", "length", "field", ".", "If", "we", "understand", "the", "version", "the", "packet", "is", "header", "up", "unto", "the", "packet", "number", ".", "Otherwise", "only", "the", "invariant", "part", "of", "the", "header", "is", "parsed", "." ]

[ "func", "(", "h", "*", "Header", ")", "ParseExtended", "(", "b", "*", "bytes", ".", "Reader", ",", "ver", "protocol", ".", "VersionNumber", ")", "(", "*", "ExtendedHeader", ",", "error", ")", "{", "return", "h", ".", "toExtendedHeader", "(", ")", ".", "parse", "(", "b", ",", "ver", ")", "\n", "}" ]

[ "ParseExtended", "parses", "the", "version", "dependent", "part", "of", "the", "header", ".", "The", "Reader", "has", "to", "be", "set", "such", "that", "it", "points", "to", "the", "first", "byte", "of", "the", "header", "." ]

[ "func", "(", "b", "*", "packetBuffer", ")", "Release", "(", ")", "{", "b", ".", "Decrement", "(", ")", "\n", "if", "b", ".", "refCount", "!=", "0", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "b", ".", "putBack", "(", ")", "\n", "}" ]

[ "Release", "puts", "back", "the", "packet", "buffer", "into", "the", "pool", ".", "It", "should", "be", "called", "when", "processing", "is", "definitely", "finished", "." ]

[ "func", "NewMockSealer", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockSealer", "{", "mock", ":=", "&", "MockSealer", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockSealerMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

[ "NewMockSealer", "creates", "a", "new", "mock", "instance" ]

[ "func", "(", "m", "*", "MockSealer", ")", "EncryptHeader", "(", "arg0", "[", "]", "byte", ",", "arg1", "*", "byte", ",", "arg2", "[", "]", "byte", ")", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ",", "arg2", ")", "\n", "}" ]

[ "EncryptHeader", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockSealer", ")", "Overhead", "(", ")", "int", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "int", ")", "\n", "return", "ret0", "\n", "}" ]

[ "Overhead", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockSealerMockRecorder", ")", "Overhead", "(", ")", "*", "gomock", ".", "Call", "{", "mr", ".", "mock", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockSealer", ")", "(", "nil", ")", ".", "Overhead", ")", ")", "\n", "}" ]

[ "Overhead", "indicates", "an", "expected", "call", "of", "Overhead" ]

[ "func", "(", "m", "*", "MockSealer", ")", "Seal", "(", "arg0", ",", "arg1", "[", "]", "byte", ",", "arg2", "protocol", ".", "PacketNumber", ",", "arg3", "[", "]", "byte", ")", "[", "]", "byte", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ",", "arg2", ",", "arg3", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "[", "]", "byte", ")", "\n", "return", "ret0", "\n", "}" ]

[ "Seal", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockSealerMockRecorder", ")", "Seal", "(", "arg0", ",", "arg1", ",", "arg2", ",", "arg3", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "mr", ".", "mock", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockSealer", ")", "(", "nil", ")", ".", "Seal", ")", ",", "arg0", ",", "arg1", ",", "arg2", ",", "arg3", ")", "\n", "}" ]

[ "Seal", "indicates", "an", "expected", "call", "of", "Seal" ]

[ "func", "(", "l", "*", "defaultLogger", ")", "SetLogTimeFormat", "(", "format", "string", ")", "{", "log", ".", "SetFlags", "(", "0", ")", "// disable timestamp logging done by the log package", "\n", "l", ".", "timeFormat", "=", "format", "\n", "}" ]

[ "SetLogTimeFormat", "sets", "the", "format", "of", "the", "timestamp", "an", "empty", "string", "disables", "the", "logging", "of", "timestamps" ]

[ "func", "(", "l", "*", "defaultLogger", ")", "Debugf", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "if", "l", ".", "logLevel", "==", "LogLevelDebug", "{", "l", ".", "logMessage", "(", "format", ",", "args", "...", ")", "\n", "}", "\n", "}" ]

[ "Debugf", "logs", "something" ]

[ "func", "(", "l", "*", "defaultLogger", ")", "Infof", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "if", "l", ".", "logLevel", ">=", "LogLevelInfo", "{", "l", ".", "logMessage", "(", "format", ",", "args", "...", ")", "\n", "}", "\n", "}" ]

[ "Infof", "logs", "something" ]

[ "func", "(", "l", "*", "defaultLogger", ")", "Errorf", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "if", "l", ".", "logLevel", ">=", "LogLevelError", "{", "l", ".", "logMessage", "(", "format", ",", "args", "...", ")", "\n", "}", "\n", "}" ]

[ "Errorf", "logs", "something" ]

[ "func", "NewMockConnectionFlowController", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockConnectionFlowController", "{", "mock", ":=", "&", "MockConnectionFlowController", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockConnectionFlowControllerMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

[ "NewMockConnectionFlowController", "creates", "a", "new", "mock", "instance" ]

[ "func", "(", "m", "*", "MockConnectionFlowController", ")", "SendWindowSize", "(", ")", "protocol", ".", "ByteCount", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "protocol", ".", "ByteCount", ")", "\n", "return", "ret0", "\n", "}" ]

[ "SendWindowSize", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockConnectionFlowControllerMockRecorder", ")", "SendWindowSize", "(", ")", "*", "gomock", ".", "Call", "{", "mr", ".", "mock", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockConnectionFlowController", ")", "(", "nil", ")", ".", "SendWindowSize", ")", ")", "\n", "}" ]

[ "SendWindowSize", "indicates", "an", "expected", "call", "of", "SendWindowSize" ]

[ "func", "(", "m", "*", "MockConnectionFlowController", ")", "UpdateSendWindow", "(", "arg0", "protocol", ".", "ByteCount", ")", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "}" ]

[ "UpdateSendWindow", "mocks", "base", "method" ]

[ "func", "(", "s", "*", "HybridSlowStart", ")", "IsEndOfRound", "(", "ack", "protocol", ".", "PacketNumber", ")", "bool", "{", "return", "s", ".", "endPacketNumber", "<", "ack", "\n", "}" ]

[ "IsEndOfRound", "returns", "true", "if", "this", "ack", "is", "the", "last", "packet", "number", "of", "our", "current", "slow", "start", "round", "." ]

[ "func", "(", "s", "*", "HybridSlowStart", ")", "OnPacketAcked", "(", "ackedPacketNumber", "protocol", ".", "PacketNumber", ")", "{", "if", "s", ".", "IsEndOfRound", "(", "ackedPacketNumber", ")", "{", "s", ".", "started", "=", "false", "\n", "}", "\n", "}" ]

[ "OnPacketAcked", "gets", "invoked", "after", "ShouldExitSlowStart", "so", "it", "s", "best", "to", "end", "the", "round", "when", "the", "final", "packet", "of", "the", "burst", "is", "received", "and", "start", "it", "on", "the", "next", "incoming", "ack", "." ]

[ "func", "(", "f", "*", "StreamFrame", ")", "Write", "(", "b", "*", "bytes", ".", "Buffer", ",", "version", "protocol", ".", "VersionNumber", ")", "error", "{", "if", "len", "(", "f", ".", "Data", ")", "==", "0", "&&", "!", "f", ".", "FinBit", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "typeByte", ":=", "byte", "(", "0x8", ")", "\n", "if", "f", ".", "FinBit", "{", "typeByte", "^=", "0x1", "\n", "}", "\n", "hasOffset", ":=", "f", ".", "Offset", "!=", "0", "\n", "if", "f", ".", "DataLenPresent", "{", "typeByte", "^=", "0x2", "\n", "}", "\n", "if", "hasOffset", "{", "typeByte", "^=", "0x4", "\n", "}", "\n", "b", ".", "WriteByte", "(", "typeByte", ")", "\n", "utils", ".", "WriteVarInt", "(", "b", ",", "uint64", "(", "f", ".", "StreamID", ")", ")", "\n", "if", "hasOffset", "{", "utils", ".", "WriteVarInt", "(", "b", ",", "uint64", "(", "f", ".", "Offset", ")", ")", "\n", "}", "\n", "if", "f", ".", "DataLenPresent", "{", "utils", ".", "WriteVarInt", "(", "b", ",", "uint64", "(", "f", ".", "DataLen", "(", ")", ")", ")", "\n", "}", "\n", "b", ".", "Write", "(", "f", ".", "Data", ")", "\n", "return", "nil", "\n", "}" ]

[ "Write", "writes", "a", "STREAM", "frame" ]

[ "func", "(", "f", "*", "StreamFrame", ")", "Length", "(", "version", "protocol", ".", "VersionNumber", ")", "protocol", ".", "ByteCount", "{", "length", ":=", "1", "+", "utils", ".", "VarIntLen", "(", "uint64", "(", "f", ".", "StreamID", ")", ")", "\n", "if", "f", ".", "Offset", "!=", "0", "{", "length", "+=", "utils", ".", "VarIntLen", "(", "uint64", "(", "f", ".", "Offset", ")", ")", "\n", "}", "\n", "if", "f", ".", "DataLenPresent", "{", "length", "+=", "utils", ".", "VarIntLen", "(", "uint64", "(", "f", ".", "DataLen", "(", ")", ")", ")", "\n", "}", "\n", "return", "length", "+", "f", ".", "DataLen", "(", ")", "\n", "}" ]

[ "Length", "returns", "the", "total", "length", "of", "the", "STREAM", "frame" ]

[ "func", "(", "f", "*", "StreamFrame", ")", "DataLen", "(", ")", "protocol", ".", "ByteCount", "{", "return", "protocol", ".", "ByteCount", "(", "len", "(", "f", ".", "Data", ")", ")", "\n", "}" ]

[ "DataLen", "gives", "the", "length", "of", "data", "in", "bytes" ]

[ "func", "BandwidthFromDelta", "(", "bytes", "protocol", ".", "ByteCount", ",", "delta", "time", ".", "Duration", ")", "Bandwidth", "{", "return", "Bandwidth", "(", "bytes", ")", "*", "Bandwidth", "(", "time", ".", "Second", ")", "/", "Bandwidth", "(", "delta", ")", "*", "BytesPerSecond", "\n", "}" ]

[ "BandwidthFromDelta", "calculates", "the", "bandwidth", "from", "a", "number", "of", "bytes", "and", "a", "time", "delta" ]

[ "func", "ReadVarInt", "(", "b", "io", ".", "ByteReader", ")", "(", "uint64", ",", "error", ")", "{", "firstByte", ",", "err", ":=", "b", ".", "ReadByte", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "// the first two bits of the first byte encode the length", "len", ":=", "1", "<<", "(", "(", "firstByte", "&", "0xc0", ")", ">>", "6", ")", "\n", "b1", ":=", "firstByte", "&", "(", "0xff", "-", "0xc0", ")", "\n", "if", "len", "==", "1", "{", "return", "uint64", "(", "b1", ")", ",", "nil", "\n", "}", "\n", "b2", ",", "err", ":=", "b", ".", "ReadByte", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "if", "len", "==", "2", "{", "return", "uint64", "(", "b2", ")", "+", "uint64", "(", "b1", ")", "<<", "8", ",", "nil", "\n", "}", "\n", "b3", ",", "err", ":=", "b", ".", "ReadByte", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "b4", ",", "err", ":=", "b", ".", "ReadByte", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "if", "len", "==", "4", "{", "return", "uint64", "(", "b4", ")", "+", "uint64", "(", "b3", ")", "<<", "8", "+", "uint64", "(", "b2", ")", "<<", "16", "+", "uint64", "(", "b1", ")", "<<", "24", ",", "nil", "\n", "}", "\n", "b5", ",", "err", ":=", "b", ".", "ReadByte", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "b6", ",", "err", ":=", "b", ".", "ReadByte", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "b7", ",", "err", ":=", "b", ".", "ReadByte", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "b8", ",", "err", ":=", "b", ".", "ReadByte", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "uint64", "(", "b8", ")", "+", "uint64", "(", "b7", ")", "<<", "8", "+", "uint64", "(", "b6", ")", "<<", "16", "+", "uint64", "(", "b5", ")", "<<", "24", "+", "uint64", "(", "b4", ")", "<<", "32", "+", "uint64", "(", "b3", ")", "<<", "40", "+", "uint64", "(", "b2", ")", "<<", "48", "+", "uint64", "(", "b1", ")", "<<", "56", ",", "nil", "\n", "}" ]

[ "ReadVarInt", "reads", "a", "number", "in", "the", "QUIC", "varint", "format" ]

[ "func", "WriteVarInt", "(", "b", "*", "bytes", ".", "Buffer", ",", "i", "uint64", ")", "{", "if", "i", "<=", "maxVarInt1", "{", "b", ".", "WriteByte", "(", "uint8", "(", "i", ")", ")", "\n", "}", "else", "if", "i", "<=", "maxVarInt2", "{", "b", ".", "Write", "(", "[", "]", "byte", "{", "uint8", "(", "i", ">>", "8", ")", "|", "0x40", ",", "uint8", "(", "i", ")", "}", ")", "\n", "}", "else", "if", "i", "<=", "maxVarInt4", "{", "b", ".", "Write", "(", "[", "]", "byte", "{", "uint8", "(", "i", ">>", "24", ")", "|", "0x80", ",", "uint8", "(", "i", ">>", "16", ")", ",", "uint8", "(", "i", ">>", "8", ")", ",", "uint8", "(", "i", ")", "}", ")", "\n", "}", "else", "if", "i", "<=", "maxVarInt8", "{", "b", ".", "Write", "(", "[", "]", "byte", "{", "uint8", "(", "i", ">>", "56", ")", "|", "0xc0", ",", "uint8", "(", "i", ">>", "48", ")", ",", "uint8", "(", "i", ">>", "40", ")", ",", "uint8", "(", "i", ">>", "32", ")", ",", "uint8", "(", "i", ">>", "24", ")", ",", "uint8", "(", "i", ">>", "16", ")", ",", "uint8", "(", "i", ">>", "8", ")", ",", "uint8", "(", "i", ")", ",", "}", ")", "\n", "}", "else", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "i", ")", ")", "\n", "}", "\n", "}" ]

[ "WriteVarInt", "writes", "a", "number", "in", "the", "QUIC", "varint", "format" ]

[ "func", "VarIntLen", "(", "i", "uint64", ")", "protocol", ".", "ByteCount", "{", "if", "i", "<=", "maxVarInt1", "{", "return", "1", "\n", "}", "\n", "if", "i", "<=", "maxVarInt2", "{", "return", "2", "\n", "}", "\n", "if", "i", "<=", "maxVarInt4", "{", "return", "4", "\n", "}", "\n", "if", "i", "<=", "maxVarInt8", "{", "return", "8", "\n", "}", "\n", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "i", ")", ")", "\n", "}" ]

[ "VarIntLen", "determines", "the", "number", "of", "bytes", "that", "will", "be", "needed", "to", "write", "a", "number" ]

[ "func", "MaxStreamID", "(", "stype", "StreamType", ",", "numStreams", "uint64", ",", "pers", "Perspective", ")", "StreamID", "{", "if", "numStreams", "==", "0", "{", "return", "0", "\n", "}", "\n", "var", "first", "StreamID", "\n", "switch", "stype", "{", "case", "StreamTypeBidi", ":", "switch", "pers", "{", "case", "PerspectiveClient", ":", "first", "=", "0", "\n", "case", "PerspectiveServer", ":", "first", "=", "1", "\n", "}", "\n", "case", "StreamTypeUni", ":", "switch", "pers", "{", "case", "PerspectiveClient", ":", "first", "=", "2", "\n", "case", "PerspectiveServer", ":", "first", "=", "3", "\n", "}", "\n", "}", "\n", "return", "first", "+", "4", "*", "StreamID", "(", "numStreams", "-", "1", ")", "\n", "}" ]

[ "MaxStreamID", "is", "the", "highest", "stream", "ID", "that", "a", "peer", "is", "allowed", "to", "open", "when", "it", "is", "allowed", "to", "open", "numStreams", "." ]

[ "func", "NewMockStream", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockStream", "{", "mock", ":=", "&", "MockStream", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockStreamMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

[ "NewMockStream", "creates", "a", "new", "mock", "instance" ]

[ "func", "(", "m", "*", "MockStream", ")", "CancelRead", "(", "arg0", "protocol", ".", "ApplicationErrorCode", ")", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "}" ]

[ "CancelRead", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockStream", ")", "SetDeadline", "(", "arg0", "time", ".", "Time", ")", "error", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "SetDeadline", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockStreamMockRecorder", ")", "SetWriteDeadline", "(", "arg0", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "mr", ".", "mock", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockStream", ")", "(", "nil", ")", ".", "SetWriteDeadline", ")", ",", "arg0", ")", "\n", "}" ]

[ "SetWriteDeadline", "indicates", "an", "expected", "call", "of", "SetWriteDeadline" ]

[ "func", "(", "m", "*", "MockStream", ")", "StreamID", "(", ")", "protocol", ".", "StreamID", "{", "m", ".", "ctrl", ".", "T", ".", "Helper", "(", ")", "\n", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "protocol", ".", "StreamID", ")", "\n", "return", "ret0", "\n", "}" ]

[ "StreamID", "mocks", "base", "method" ]

[ "func", "(", "h", "*", "ExtendedHeader", ")", "Write", "(", "b", "*", "bytes", ".", "Buffer", ",", "ver", "protocol", ".", "VersionNumber", ")", "error", "{", "if", "h", ".", "IsLongHeader", "{", "return", "h", ".", "writeLongHeader", "(", "b", ",", "ver", ")", "\n", "}", "\n", "return", "h", ".", "writeShortHeader", "(", "b", ",", "ver", ")", "\n", "}" ]

[ "Write", "writes", "the", "Header", "." ]