Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "b", "Ethernet", ")", "DestinationAddress", "(", ")", "tcpip", ".", "LinkAddress", "{", "return", "tcpip", ".", "LinkAddress", "(", "b", "[", "dstMAC", ":", "]", "[", ":", "EthernetAddressSize", "]", ")", "\n", "}" ]

[ "DestinationAddress", "returns", "the", "MAC", "destination", "field", "of", "the", "ethernet", "frame", "header", "." ]

[ "func", "(", "b", "Ethernet", ")", "Type", "(", ")", "tcpip", ".", "NetworkProtocolNumber", "{", "return", "tcpip", ".", "NetworkProtocolNumber", "(", "binary", ".", "BigEndian", ".", "Uint16", "(", "b", "[", "ethType", ":", "]", ")", ")", "\n", "}" ]

[ "Type", "returns", "the", "ethertype", "field", "of", "the", "ethernet", "frame", "header", "." ]

[ "func", "(", "b", "Ethernet", ")", "Encode", "(", "e", "*", "EthernetFields", ")", "{", "binary", ".", "BigEndian", ".", "PutUint16", "(", "b", "[", "ethType", ":", "]", ",", "uint16", "(", "e", ".", "Type", ")", ")", "\n", "copy", "(", "b", "[", "srcMAC", ":", "]", "[", ":", "EthernetAddressSize", "]", ",", "e", ".", "SrcAddr", ")", "\n", "copy", "(", "b", "[", "dstMAC", ":", "]", "[", ":", "EthernetAddressSize", "]", ",", "e", ".", "DstAddr", ")", "\n", "}" ]

[ "Encode", "encodes", "all", "the", "fields", "of", "the", "ethernet", "frame", "header", "." ]

[ "func", "(", "v", "Value", ")", "LessThanEq", "(", "w", "Value", ")", "bool", "{", "if", "v", "==", "w", "{", "return", "true", "\n", "}", "\n", "return", "v", ".", "LessThan", "(", "w", ")", "\n", "}" ]

[ "LessThanEq", "returns", "true", "if", "v", "==", "w", "or", "v", "is", "before", "i", ".", "e", ".", "v", "<", "w", "." ]

[ "func", "(", "v", "Value", ")", "InRange", "(", "a", ",", "b", "Value", ")", "bool", "{", "return", "v", "-", "a", "<", "b", "-", "a", "\n", "}" ]

[ "InRange", "checks", "if", "v", "is", "in", "the", "range", "[", "a", "b", ")", "i", ".", "e", ".", "a", "<", "=", "v", "<", "b", "." ]

[ "func", "(", "v", "Value", ")", "InWindow", "(", "first", "Value", ",", "size", "Size", ")", "bool", "{", "return", "v", ".", "InRange", "(", "first", ",", "first", ".", "Add", "(", "size", ")", ")", "\n", "}" ]

[ "InWindow", "checks", "if", "v", "is", "in", "the", "window", "that", "starts", "at", "first", "and", "spans", "size", "sequence", "numbers", "." ]

[ "func", "Overlap", "(", "a", "Value", ",", "b", "Size", ",", "x", "Value", ",", "y", "Size", ")", "bool", "{", "return", "a", ".", "LessThan", "(", "x", ".", "Add", "(", "y", ")", ")", "&&", "x", ".", "LessThan", "(", "a", ".", "Add", "(", "b", ")", ")", "\n", "}" ]

[ "Overlap", "checks", "if", "the", "window", "[", "a", "a", "+", "b", ")", "overlaps", "with", "the", "window", "[", "x", "x", "+", "y", ")", "." ]

[ "func", "(", "r", "*", "renoState", ")", "updateSlowStart", "(", "packetsAcked", "int", ")", "int", "{", "// Don't let the congestion window cross into the congestion", "// avoidance range.", "newcwnd", ":=", "r", ".", "s", ".", "sndCwnd", "+", "packetsAcked", "\n", "if", "newcwnd", ">=", "r", ".", "s", ".", "sndSsthresh", "{", "newcwnd", "=", "r", ".", "s", ".", "sndSsthresh", "\n", "r", ".", "s", ".", "sndCAAckCount", "=", "0", "\n", "}", "\n\n", "packetsAcked", "-=", "newcwnd", "-", "r", ".", "s", ".", "sndCwnd", "\n", "r", ".", "s", ".", "sndCwnd", "=", "newcwnd", "\n", "return", "packetsAcked", "\n", "}" ]

[ "updateSlowStart", "will", "update", "the", "congestion", "window", "as", "per", "the", "slow", "-", "start", "algorithm", "used", "by", "NewReno", ".", "If", "after", "adjusting", "the", "congestion", "window", "we", "cross", "the", "SSthreshold", "then", "it", "will", "return", "the", "number", "of", "packets", "that", "must", "be", "consumed", "in", "congestion", "avoidance", "mode", "." ]

[ "func", "(", "r", "*", "renoState", ")", "updateCongestionAvoidance", "(", "packetsAcked", "int", ")", "{", "// Consume the packets in congestion avoidance mode.", "r", ".", "s", ".", "sndCAAckCount", "+=", "packetsAcked", "\n", "if", "r", ".", "s", ".", "sndCAAckCount", ">=", "r", ".", "s", ".", "sndCwnd", "{", "r", ".", "s", ".", "sndCwnd", "+=", "r", ".", "s", ".", "sndCAAckCount", "/", "r", ".", "s", ".", "sndCwnd", "\n", "r", ".", "s", ".", "sndCAAckCount", "=", "r", ".", "s", ".", "sndCAAckCount", "%", "r", ".", "s", ".", "sndCwnd", "\n", "}", "\n", "}" ]

[ "updateCongestionAvoidance", "will", "update", "congestion", "window", "in", "congestion", "avoidance", "mode", "as", "described", "in", "RFC5681", "section", "3", ".", "1" ]

[ "func", "(", "r", "*", "renoState", ")", "reduceSlowStartThreshold", "(", ")", "{", "r", ".", "s", ".", "sndSsthresh", "=", "r", ".", "s", ".", "outstanding", "/", "2", "\n", "if", "r", ".", "s", ".", "sndSsthresh", "<", "2", "{", "r", ".", "s", ".", "sndSsthresh", "=", "2", "\n", "}", "\n\n", "}" ]

[ "reduceSlowStartThreshold", "reduces", "the", "slow", "-", "start", "threshold", "per", "RFC", "5681", "page", "6", "eq", ".", "4", ".", "It", "is", "called", "when", "we", "detect", "congestion", "in", "the", "network", "." ]

[ "func", "(", "r", "*", "renoState", ")", "Update", "(", "packetsAcked", "int", ")", "{", "if", "r", ".", "s", ".", "sndCwnd", "<", "r", ".", "s", ".", "sndSsthresh", "{", "packetsAcked", "=", "r", ".", "updateSlowStart", "(", "packetsAcked", ")", "\n", "if", "packetsAcked", "==", "0", "{", "return", "\n", "}", "\n", "}", "\n", "r", ".", "updateCongestionAvoidance", "(", "packetsAcked", ")", "\n", "}" ]

[ "Update", "updates", "the", "congestion", "state", "based", "on", "the", "number", "of", "packets", "that", "were", "acknowledged", ".", "Update", "implements", "congestionControl", ".", "Update", "." ]

[ "func", "(", "s", "*", "Sum32", ")", "Sum32", "(", ")", "uint32", "{", "hash", ":=", "*", "s", "\n\n", "hash", "+=", "(", "hash", "<<", "3", ")", "\n", "hash", "^=", "hash", ">>", "11", "\n", "hash", "+=", "hash", "<<", "15", "\n\n", "return", "uint32", "(", "hash", ")", "\n", "}" ]

[ "Sum32", "returns", "the", "hash", "value" ]

[ "func", "(", "s", "*", "Sum32", ")", "Write", "(", "data", "[", "]", "byte", ")", "(", "int", ",", "error", ")", "{", "hash", ":=", "*", "s", "\n", "for", "_", ",", "b", ":=", "range", "data", "{", "hash", "+=", "Sum32", "(", "b", ")", "\n", "hash", "+=", "hash", "<<", "10", "\n", "hash", "^=", "hash", ">>", "6", "\n", "}", "\n", "*", "s", "=", "hash", "\n", "return", "len", "(", "data", ")", ",", "nil", "\n", "}" ]

[ "Write", "adds", "more", "data", "to", "the", "running", "hash", ".", "It", "never", "returns", "an", "error", "." ]

[ "func", "(", "s", "*", "Sum32", ")", "Sum", "(", "in", "[", "]", "byte", ")", "[", "]", "byte", "{", "v", ":=", "s", ".", "Sum32", "(", ")", "\n", "return", "append", "(", "in", ",", "byte", "(", "v", ">>", "24", ")", ",", "byte", "(", "v", ">>", "16", ")", ",", "byte", "(", "v", ">>", "8", ")", ",", "byte", "(", "v", ")", ")", "\n", "}" ]

[ "Sum", "appends", "the", "current", "hash", "to", "in", "and", "returns", "the", "resulting", "slice", ".", "It", "does", "not", "change", "the", "underlying", "hash", "state", "." ]

[ "func", "writer", "(", "ch", "chan", "struct", "{", "}", ",", "ep", "tcpip", ".", "Endpoint", ")", "{", "defer", "func", "(", ")", "{", "ep", ".", "Shutdown", "(", "tcpip", ".", "ShutdownWrite", ")", "\n", "close", "(", "ch", ")", "\n", "}", "(", ")", "\n\n", "r", ":=", "bufio", ".", "NewReader", "(", "os", ".", "Stdin", ")", "\n", "for", "{", "v", ":=", "buffer", ".", "NewView", "(", "1024", ")", "\n", "n", ",", "err", ":=", "r", ".", "Read", "(", "v", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "v", ".", "CapLength", "(", "n", ")", "\n", "for", "len", "(", "v", ")", ">", "0", "{", "n", ",", "_", ",", "err", ":=", "ep", ".", "Write", "(", "tcpip", ".", "SlicePayload", "(", "v", ")", ",", "tcpip", ".", "WriteOptions", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Println", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "v", ".", "TrimFront", "(", "int", "(", "n", ")", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "writer", "reads", "from", "standard", "input", "and", "writes", "to", "the", "endpoint", "until", "standard", "input", "is", "closed", ".", "It", "signals", "that", "it", "s", "done", "by", "closing", "the", "provided", "channel", "." ]

[ "func", "commitSleep", "(", "g", "uintptr", ",", "waitingG", "*", "uintptr", ")", "bool", "{", "for", "{", "// Check if the wait was aborted.", "if", "atomic", ".", "LoadUintptr", "(", "waitingG", ")", "==", "0", "{", "return", "false", "\n", "}", "\n\n", "// Try to store the G so that wakers know who to wake.", "if", "atomic", ".", "CompareAndSwapUintptr", "(", "waitingG", ",", "preparingG", ",", "g", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "}" ]

[ "commitSleep", "signals", "to", "wakers", "that", "the", "given", "g", "is", "now", "sleeping", ".", "Wakers", "can", "then", "fetch", "it", "and", "wake", "it", ".", "The", "commit", "may", "fail", "if", "wakers", "have", "been", "asserted", "after", "our", "last", "check", "in", "which", "case", "they", "will", "have", "set", "s", ".", "waitingG", "to", "zero", ".", "It", "is", "written", "in", "assembly", "because", "it", "is", "called", "from", "g0", "so", "it", "doesn", "t", "have", "a", "race", "context", "." ]

[ "func", "makeRoute", "(", "netProto", "tcpip", ".", "NetworkProtocolNumber", ",", "localAddr", ",", "remoteAddr", "tcpip", ".", "Address", ",", "localLinkAddr", "tcpip", ".", "LinkAddress", ",", "ref", "*", "referencedNetworkEndpoint", ",", "handleLocal", ",", "multicastLoop", "bool", ")", "Route", "{", "loop", ":=", "PacketOut", "\n", "if", "handleLocal", "&&", "localAddr", "!=", "\"", "\"", "&&", "remoteAddr", "==", "localAddr", "{", "loop", "=", "PacketLoop", "\n", "}", "else", "if", "multicastLoop", "&&", "(", "header", ".", "IsV4MulticastAddress", "(", "remoteAddr", ")", "||", "header", ".", "IsV6MulticastAddress", "(", "remoteAddr", ")", ")", "{", "loop", "|=", "PacketLoop", "\n", "}", "\n\n", "return", "Route", "{", "NetProto", ":", "netProto", ",", "LocalAddress", ":", "localAddr", ",", "LocalLinkAddress", ":", "localLinkAddr", ",", "RemoteAddress", ":", "remoteAddr", ",", "ref", ":", "ref", ",", "loop", ":", "loop", ",", "}", "\n", "}" ]

[ "makeRoute", "initializes", "a", "new", "route", ".", "It", "takes", "ownership", "of", "the", "provided", "reference", "to", "a", "network", "endpoint", "." ]

[ "func", "(", "r", "*", "Route", ")", "Stats", "(", ")", "tcpip", ".", "Stats", "{", "return", "r", ".", "ref", ".", "nic", ".", "stack", ".", "Stats", "(", ")", "\n", "}" ]

[ "Stats", "returns", "a", "mutable", "copy", "of", "current", "stats", "." ]

[ "func", "(", "r", "*", "Route", ")", "PseudoHeaderChecksum", "(", "protocol", "tcpip", ".", "TransportProtocolNumber", ",", "totalLen", "uint16", ")", "uint16", "{", "return", "header", ".", "PseudoHeaderChecksum", "(", "protocol", ",", "r", ".", "LocalAddress", ",", "r", ".", "RemoteAddress", ",", "totalLen", ")", "\n", "}" ]

[ "PseudoHeaderChecksum", "forwards", "the", "call", "to", "the", "network", "endpoint", "s", "implementation", "." ]

[ "func", "(", "r", "*", "Route", ")", "WritePacket", "(", "gso", "*", "GSO", ",", "hdr", "buffer", ".", "Prependable", ",", "payload", "buffer", ".", "VectorisedView", ",", "protocol", "tcpip", ".", "TransportProtocolNumber", ",", "ttl", "uint8", ")", "*", "tcpip", ".", "Error", "{", "err", ":=", "r", ".", "ref", ".", "ep", ".", "WritePacket", "(", "r", ",", "gso", ",", "hdr", ",", "payload", ",", "protocol", ",", "ttl", ",", "r", ".", "loop", ")", "\n", "if", "err", "!=", "nil", "{", "r", ".", "Stats", "(", ")", ".", "IP", ".", "OutgoingPacketErrors", ".", "Increment", "(", ")", "\n", "}", "else", "{", "r", ".", "ref", ".", "nic", ".", "stats", ".", "Tx", ".", "Packets", ".", "Increment", "(", ")", "\n", "r", ".", "ref", ".", "nic", ".", "stats", ".", "Tx", ".", "Bytes", ".", "IncrementBy", "(", "uint64", "(", "hdr", ".", "UsedLength", "(", ")", "+", "payload", ".", "Size", "(", ")", ")", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "WritePacket", "writes", "the", "packet", "through", "the", "given", "route", "." ]

[ "func", "(", "r", "*", "Route", ")", "Release", "(", ")", "{", "if", "r", ".", "ref", "!=", "nil", "{", "r", ".", "ref", ".", "decRef", "(", ")", "\n", "r", ".", "ref", "=", "nil", "\n", "}", "\n", "}" ]

[ "Release", "frees", "all", "resources", "associated", "with", "the", "route", "." ]

[ "func", "(", "b", "UDP", ")", "SetSourcePort", "(", "port", "uint16", ")", "{", "binary", ".", "BigEndian", ".", "PutUint16", "(", "b", "[", "udpSrcPort", ":", "]", ",", "port", ")", "\n", "}" ]

[ "SetSourcePort", "sets", "the", "source", "port", "field", "of", "the", "udp", "header", "." ]

[ "func", "(", "b", "UDP", ")", "SetDestinationPort", "(", "port", "uint16", ")", "{", "binary", ".", "BigEndian", ".", "PutUint16", "(", "b", "[", "udpDstPort", ":", "]", ",", "port", ")", "\n", "}" ]

[ "SetDestinationPort", "sets", "the", "destination", "port", "field", "of", "the", "udp", "header", "." ]

[ "func", "(", "b", "UDP", ")", "SetChecksum", "(", "checksum", "uint16", ")", "{", "binary", ".", "BigEndian", ".", "PutUint16", "(", "b", "[", "udpChecksum", ":", "]", ",", "checksum", ")", "\n", "}" ]

[ "SetChecksum", "sets", "the", "checksum", "field", "of", "the", "udp", "header", "." ]

[ "func", "(", "b", "UDP", ")", "CalculateChecksum", "(", "partialChecksum", "uint16", ")", "uint16", "{", "// Calculate the rest of the checksum.", "return", "Checksum", "(", "b", "[", ":", "UDPMinimumSize", "]", ",", "partialChecksum", ")", "\n", "}" ]

[ "CalculateChecksum", "calculates", "the", "checksum", "of", "the", "udp", "packet", "given", "the", "checksum", "of", "the", "network", "-", "layer", "pseudo", "-", "header", "and", "the", "checksum", "of", "the", "payload", "." ]

[ "func", "(", "b", "UDP", ")", "Encode", "(", "u", "*", "UDPFields", ")", "{", "binary", ".", "BigEndian", ".", "PutUint16", "(", "b", "[", "udpSrcPort", ":", "]", ",", "u", ".", "SrcPort", ")", "\n", "binary", ".", "BigEndian", ".", "PutUint16", "(", "b", "[", "udpDstPort", ":", "]", ",", "u", ".", "DstPort", ")", "\n", "binary", ".", "BigEndian", ".", "PutUint16", "(", "b", "[", "udpLength", ":", "]", ",", "u", ".", "Length", ")", "\n", "binary", ".", "BigEndian", ".", "PutUint16", "(", "b", "[", "udpChecksum", ":", "]", ",", "u", ".", "Checksum", ")", "\n", "}" ]

[ "Encode", "encodes", "all", "the", "fields", "of", "the", "udp", "header", "." ]

[ "func", "New", "(", "mtu", ",", "bufferSize", "uint32", ",", "addr", "tcpip", ".", "LinkAddress", ",", "tx", ",", "rx", "QueueConfig", ")", "(", "tcpip", ".", "LinkEndpointID", ",", "error", ")", "{", "e", ":=", "&", "endpoint", "{", "mtu", ":", "mtu", ",", "bufferSize", ":", "bufferSize", ",", "addr", ":", "addr", ",", "}", "\n\n", "if", "err", ":=", "e", ".", "tx", ".", "init", "(", "bufferSize", ",", "&", "tx", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "if", "err", ":=", "e", ".", "rx", ".", "init", "(", "bufferSize", ",", "&", "rx", ")", ";", "err", "!=", "nil", "{", "e", ".", "tx", ".", "cleanup", "(", ")", "\n", "return", "0", ",", "err", "\n", "}", "\n\n", "return", "stack", ".", "RegisterLinkEndpoint", "(", "e", ")", ",", "nil", "\n", "}" ]

[ "New", "creates", "a", "new", "shared", "-", "memory", "-", "based", "endpoint", ".", "Buffers", "will", "be", "broken", "up", "into", "buffers", "of", "bufferSize", "bytes", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "Close", "(", ")", "{", "// Tell dispatch goroutine to stop, then write to the eventfd so that", "// it wakes up in case it's sleeping.", "atomic", ".", "StoreUint32", "(", "&", "e", ".", "stopRequested", ",", "1", ")", "\n", "syscall", ".", "Write", "(", "e", ".", "rx", ".", "eventFD", ",", "[", "]", "byte", "{", "1", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", "}", ")", "\n\n", "// Cleanup the queues inline if the worker hasn't started yet; we also", "// know it won't start from now on because stopRequested is set to 1.", "e", ".", "mu", ".", "Lock", "(", ")", "\n", "workerPresent", ":=", "e", ".", "workerStarted", "\n", "e", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "if", "!", "workerPresent", "{", "e", ".", "tx", ".", "cleanup", "(", ")", "\n", "e", ".", "rx", ".", "cleanup", "(", ")", "\n", "}", "\n", "}" ]

[ "Close", "frees", "all", "resources", "associated", "with", "the", "endpoint", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "Attach", "(", "dispatcher", "stack", ".", "NetworkDispatcher", ")", "{", "e", ".", "mu", ".", "Lock", "(", ")", "\n", "if", "!", "e", ".", "workerStarted", "&&", "atomic", ".", "LoadUint32", "(", "&", "e", ".", "stopRequested", ")", "==", "0", "{", "e", ".", "workerStarted", "=", "true", "\n", "e", ".", "completed", ".", "Add", "(", "1", ")", "\n", "// Link endpoints are not savable. When transportation endpoints", "// are saved, they stop sending outgoing packets and all", "// incoming packets are rejected.", "go", "e", ".", "dispatchLoop", "(", "dispatcher", ")", "\n", "}", "\n", "e", ".", "mu", ".", "Unlock", "(", ")", "\n", "}" ]

[ "Attach", "implements", "stack", ".", "LinkEndpoint", ".", "Attach", ".", "It", "launches", "the", "goroutine", "that", "reads", "packets", "from", "the", "rx", "queue", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "IsAttached", "(", ")", "bool", "{", "e", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "e", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "e", ".", "workerStarted", "\n", "}" ]

[ "IsAttached", "implements", "stack", ".", "LinkEndpoint", ".", "IsAttached", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "dispatchLoop", "(", "d", "stack", ".", "NetworkDispatcher", ")", "{", "// Post initial set of buffers.", "limit", ":=", "e", ".", "rx", ".", "q", ".", "PostedBuffersLimit", "(", ")", "\n", "if", "l", ":=", "uint64", "(", "len", "(", "e", ".", "rx", ".", "data", ")", ")", "/", "uint64", "(", "e", ".", "bufferSize", ")", ";", "limit", ">", "l", "{", "limit", "=", "l", "\n", "}", "\n", "for", "i", ":=", "uint64", "(", "0", ")", ";", "i", "<", "limit", ";", "i", "++", "{", "b", ":=", "queue", ".", "RxBuffer", "{", "Offset", ":", "i", "*", "uint64", "(", "e", ".", "bufferSize", ")", ",", "Size", ":", "e", ".", "bufferSize", ",", "ID", ":", "i", ",", "}", "\n", "if", "!", "e", ".", "rx", ".", "q", ".", "PostBuffers", "(", "[", "]", "queue", ".", "RxBuffer", "{", "b", "}", ")", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "i", ")", "\n", "}", "\n", "}", "\n\n", "// Read in a loop until a stop is requested.", "var", "rxb", "[", "]", "queue", ".", "RxBuffer", "\n", "for", "atomic", ".", "LoadUint32", "(", "&", "e", ".", "stopRequested", ")", "==", "0", "{", "var", "n", "uint32", "\n", "rxb", ",", "n", "=", "e", ".", "rx", ".", "postAndReceive", "(", "rxb", ",", "&", "e", ".", "stopRequested", ")", "\n\n", "// Copy data from the shared area to its own buffer, then", "// prepare to repost the buffer.", "b", ":=", "make", "(", "[", "]", "byte", ",", "n", ")", "\n", "offset", ":=", "uint32", "(", "0", ")", "\n", "for", "i", ":=", "range", "rxb", "{", "copy", "(", "b", "[", "offset", ":", "]", ",", "e", ".", "rx", ".", "data", "[", "rxb", "[", "i", "]", ".", "Offset", ":", "]", "[", ":", "rxb", "[", "i", "]", ".", "Size", "]", ")", "\n", "offset", "+=", "rxb", "[", "i", "]", ".", "Size", "\n\n", "rxb", "[", "i", "]", ".", "Size", "=", "e", ".", "bufferSize", "\n", "}", "\n\n", "if", "n", "<", "header", ".", "EthernetMinimumSize", "{", "continue", "\n", "}", "\n\n", "// Send packet up the stack.", "eth", ":=", "header", ".", "Ethernet", "(", "b", ")", "\n", "d", ".", "DeliverNetworkPacket", "(", "e", ",", "eth", ".", "SourceAddress", "(", ")", ",", "eth", ".", "DestinationAddress", "(", ")", ",", "eth", ".", "Type", "(", ")", ",", "buffer", ".", "View", "(", "b", "[", "header", ".", "EthernetMinimumSize", ":", "]", ")", ".", "ToVectorisedView", "(", ")", ")", "\n", "}", "\n\n", "// Clean state.", "e", ".", "tx", ".", "cleanup", "(", ")", "\n", "e", ".", "rx", ".", "cleanup", "(", ")", "\n\n", "e", ".", "completed", ".", "Done", "(", ")", "\n", "}" ]

[ "dispatchLoop", "reads", "packets", "from", "the", "rx", "queue", "in", "a", "loop", "and", "dispatches", "them", "to", "the", "network", "stack", "." ]

[ "func", "(", "ep", "*", "endpoint", ")", "Close", "(", ")", "{", "ep", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "ep", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "if", "ep", ".", "closed", "{", "return", "\n", "}", "\n\n", "ep", ".", "stack", ".", "UnregisterRawTransportEndpoint", "(", "ep", ".", "registeredNIC", ",", "ep", ".", "netProto", ",", "ep", ".", "transProto", ",", "ep", ")", "\n\n", "ep", ".", "rcvMu", ".", "Lock", "(", ")", "\n", "defer", "ep", ".", "rcvMu", ".", "Unlock", "(", ")", "\n\n", "// Clear the receive list.", "ep", ".", "rcvClosed", "=", "true", "\n", "ep", ".", "rcvBufSize", "=", "0", "\n", "for", "!", "ep", ".", "rcvList", ".", "Empty", "(", ")", "{", "ep", ".", "rcvList", ".", "Remove", "(", "ep", ".", "rcvList", ".", "Front", "(", ")", ")", "\n", "}", "\n\n", "if", "ep", ".", "connected", "{", "ep", ".", "route", ".", "Release", "(", ")", "\n", "}", "\n\n", "ep", ".", "waiterQueue", ".", "Notify", "(", "waiter", ".", "EventHUp", "|", "waiter", ".", "EventErr", "|", "waiter", ".", "EventIn", "|", "waiter", ".", "EventOut", ")", "\n", "}" ]

[ "Close", "implements", "tcpip", ".", "Endpoint", ".", "Close", "." ]

[ "func", "(", "ep", "*", "endpoint", ")", "Read", "(", "addr", "*", "tcpip", ".", "FullAddress", ")", "(", "buffer", ".", "View", ",", "tcpip", ".", "ControlMessages", ",", "*", "tcpip", ".", "Error", ")", "{", "ep", ".", "rcvMu", ".", "Lock", "(", ")", "\n\n", "// If there's no data to read, return that read would block or that the", "// endpoint is closed.", "if", "ep", ".", "rcvList", ".", "Empty", "(", ")", "{", "err", ":=", "tcpip", ".", "ErrWouldBlock", "\n", "if", "ep", ".", "rcvClosed", "{", "err", "=", "tcpip", ".", "ErrClosedForReceive", "\n", "}", "\n", "ep", ".", "rcvMu", ".", "Unlock", "(", ")", "\n", "return", "buffer", ".", "View", "{", "}", ",", "tcpip", ".", "ControlMessages", "{", "}", ",", "err", "\n", "}", "\n\n", "packet", ":=", "ep", ".", "rcvList", ".", "Front", "(", ")", "\n", "ep", ".", "rcvList", ".", "Remove", "(", "packet", ")", "\n", "ep", ".", "rcvBufSize", "-=", "packet", ".", "data", ".", "Size", "(", ")", "\n\n", "ep", ".", "rcvMu", ".", "Unlock", "(", ")", "\n\n", "if", "addr", "!=", "nil", "{", "*", "addr", "=", "packet", ".", "senderAddr", "\n", "}", "\n\n", "return", "packet", ".", "data", ".", "ToView", "(", ")", ",", "tcpip", ".", "ControlMessages", "{", "HasTimestamp", ":", "true", ",", "Timestamp", ":", "packet", ".", "timestampNS", "}", ",", "nil", "\n", "}" ]

[ "Read", "implements", "tcpip", ".", "Endpoint", ".", "Read", "." ]

[ "func", "(", "ep", "*", "endpoint", ")", "Write", "(", "payload", "tcpip", ".", "Payload", ",", "opts", "tcpip", ".", "WriteOptions", ")", "(", "uintptr", ",", "<-", "chan", "struct", "{", "}", ",", "*", "tcpip", ".", "Error", ")", "{", "// MSG_MORE is unimplemented. This also means that MSG_EOR is a no-op.", "if", "opts", ".", "More", "{", "return", "0", ",", "nil", ",", "tcpip", ".", "ErrInvalidOptionValue", "\n", "}", "\n\n", "ep", ".", "mu", ".", "RLock", "(", ")", "\n\n", "if", "ep", ".", "closed", "{", "ep", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "0", ",", "nil", ",", "tcpip", ".", "ErrInvalidEndpointState", "\n", "}", "\n\n", "// Check whether we've shutdown writing.", "if", "ep", ".", "shutdownFlags", "&", "tcpip", ".", "ShutdownWrite", "!=", "0", "{", "ep", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "0", ",", "nil", ",", "tcpip", ".", "ErrClosedForSend", "\n", "}", "\n\n", "// Did the user caller provide a destination? If not, use the connected", "// destination.", "if", "opts", ".", "To", "==", "nil", "{", "// If the user doesn't specify a destination, they should have", "// connected to another address.", "if", "!", "ep", ".", "connected", "{", "ep", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "0", ",", "nil", ",", "tcpip", ".", "ErrNotConnected", "\n", "}", "\n\n", "if", "ep", ".", "route", ".", "IsResolutionRequired", "(", ")", "{", "savedRoute", ":=", "&", "ep", ".", "route", "\n", "// Promote lock to exclusive if using a shared route,", "// given that it may need to change in finishWrite.", "ep", ".", "mu", ".", "RUnlock", "(", ")", "\n", "ep", ".", "mu", ".", "Lock", "(", ")", "\n\n", "// Make sure that the route didn't change during the", "// time we didn't hold the lock.", "if", "!", "ep", ".", "connected", "||", "savedRoute", "!=", "&", "ep", ".", "route", "{", "ep", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "0", ",", "nil", ",", "tcpip", ".", "ErrInvalidEndpointState", "\n", "}", "\n\n", "n", ",", "ch", ",", "err", ":=", "ep", ".", "finishWrite", "(", "payload", ",", "savedRoute", ")", "\n", "ep", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "n", ",", "ch", ",", "err", "\n", "}", "\n\n", "n", ",", "ch", ",", "err", ":=", "ep", ".", "finishWrite", "(", "payload", ",", "&", "ep", ".", "route", ")", "\n", "ep", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "n", ",", "ch", ",", "err", "\n", "}", "\n\n", "// The caller provided a destination. Reject destination address if it", "// goes through a different NIC than the endpoint was bound to.", "nic", ":=", "opts", ".", "To", ".", "NIC", "\n", "if", "ep", ".", "bound", "&&", "nic", "!=", "0", "&&", "nic", "!=", "ep", ".", "boundNIC", "{", "ep", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "0", ",", "nil", ",", "tcpip", ".", "ErrNoRoute", "\n", "}", "\n\n", "// We don't support IPv6 yet, so this has to be an IPv4 address.", "if", "len", "(", "opts", ".", "To", ".", "Addr", ")", "!=", "header", ".", "IPv4AddressSize", "{", "ep", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "0", ",", "nil", ",", "tcpip", ".", "ErrInvalidEndpointState", "\n", "}", "\n\n", "// Find the route to the destination. If boundAddress is 0,", "// FindRoute will choose an appropriate source address.", "route", ",", "err", ":=", "ep", ".", "stack", ".", "FindRoute", "(", "nic", ",", "ep", ".", "boundAddr", ",", "opts", ".", "To", ".", "Addr", ",", "ep", ".", "netProto", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "ep", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "0", ",", "nil", ",", "err", "\n", "}", "\n\n", "n", ",", "ch", ",", "err", ":=", "ep", ".", "finishWrite", "(", "payload", ",", "&", "route", ")", "\n", "route", ".", "Release", "(", ")", "\n", "ep", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "n", ",", "ch", ",", "err", "\n", "}" ]

[ "Write", "implements", "tcpip", ".", "Endpoint", ".", "Write", "." ]

[ "func", "(", "ep", "*", "endpoint", ")", "finishWrite", "(", "payload", "tcpip", ".", "Payload", ",", "route", "*", "stack", ".", "Route", ")", "(", "uintptr", ",", "<-", "chan", "struct", "{", "}", ",", "*", "tcpip", ".", "Error", ")", "{", "// We may need to resolve the route (match a link layer address to the", "// network address). If that requires blocking (e.g. to use ARP),", "// return a channel on which the caller can wait.", "if", "route", ".", "IsResolutionRequired", "(", ")", "{", "waker", ":=", "&", "sleep", ".", "Waker", "{", "}", "\n", "if", "ch", ",", "err", ":=", "route", ".", "Resolve", "(", "waker", ")", ";", "err", "!=", "nil", "{", "if", "err", "==", "tcpip", ".", "ErrWouldBlock", "{", "// Link address needs to be resolved.", "// Resolution was triggered the background.", "// Better luck next time.", "route", ".", "RemoveWaker", "(", "waker", ")", "\n", "return", "0", ",", "ch", ",", "tcpip", ".", "ErrNoLinkAddress", "\n", "}", "\n", "return", "0", ",", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "payloadBytes", ",", "err", ":=", "payload", ".", "Get", "(", "payload", ".", "Size", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "nil", ",", "err", "\n", "}", "\n\n", "switch", "ep", ".", "netProto", "{", "case", "header", ".", "IPv4ProtocolNumber", ":", "hdr", ":=", "buffer", ".", "NewPrependable", "(", "len", "(", "payloadBytes", ")", "+", "int", "(", "route", ".", "MaxHeaderLength", "(", ")", ")", ")", "\n", "if", "err", ":=", "route", ".", "WritePacket", "(", "nil", "/* gso */", ",", "hdr", ",", "buffer", ".", "View", "(", "payloadBytes", ")", ".", "ToVectorisedView", "(", ")", ",", "header", ".", "ICMPv4ProtocolNumber", ",", "route", ".", "DefaultTTL", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "nil", ",", "err", "\n", "}", "\n\n", "default", ":", "return", "0", ",", "nil", ",", "tcpip", ".", "ErrUnknownProtocol", "\n", "}", "\n\n", "return", "uintptr", "(", "len", "(", "payloadBytes", ")", ")", ",", "nil", ",", "nil", "\n", "}" ]

[ "finishWrite", "writes", "the", "payload", "to", "a", "route", ".", "It", "resolves", "the", "route", "if", "necessary", ".", "It", "s", "really", "just", "a", "helper", "to", "make", "defer", "unnecessary", "in", "Write", "." ]

[ "func", "(", "ep", "*", "endpoint", ")", "Connect", "(", "addr", "tcpip", ".", "FullAddress", ")", "*", "tcpip", ".", "Error", "{", "ep", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "ep", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "if", "ep", ".", "closed", "{", "return", "tcpip", ".", "ErrInvalidEndpointState", "\n", "}", "\n\n", "// We don't support IPv6 yet.", "if", "len", "(", "addr", ".", "Addr", ")", "!=", "header", ".", "IPv4AddressSize", "{", "return", "tcpip", ".", "ErrInvalidEndpointState", "\n", "}", "\n\n", "nic", ":=", "addr", ".", "NIC", "\n", "if", "ep", ".", "bound", "{", "if", "ep", ".", "boundNIC", "==", "0", "{", "// If we're bound, but not to a specific NIC, the NIC", "// in addr will be used. Nothing to do here.", "}", "else", "if", "addr", ".", "NIC", "==", "0", "{", "// If we're bound to a specific NIC, but addr doesn't", "// specify a NIC, use the bound NIC.", "nic", "=", "ep", ".", "boundNIC", "\n", "}", "else", "if", "addr", ".", "NIC", "!=", "ep", ".", "boundNIC", "{", "// We're bound and addr specifies a NIC. They must be", "// the same.", "return", "tcpip", ".", "ErrInvalidEndpointState", "\n", "}", "\n", "}", "\n\n", "// Find a route to the destination.", "route", ",", "err", ":=", "ep", ".", "stack", ".", "FindRoute", "(", "nic", ",", "tcpip", ".", "Address", "(", "\"", "\"", ")", ",", "addr", ".", "Addr", ",", "ep", ".", "netProto", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "route", ".", "Release", "(", ")", "\n\n", "// Re-register the endpoint with the appropriate NIC.", "if", "err", ":=", "ep", ".", "stack", ".", "RegisterRawTransportEndpoint", "(", "addr", ".", "NIC", ",", "ep", ".", "netProto", ",", "ep", ".", "transProto", ",", "ep", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "ep", ".", "stack", ".", "UnregisterRawTransportEndpoint", "(", "ep", ".", "registeredNIC", ",", "ep", ".", "netProto", ",", "ep", ".", "transProto", ",", "ep", ")", "\n\n", "// Save the route and NIC we've connected via.", "ep", ".", "route", "=", "route", ".", "Clone", "(", ")", "\n", "ep", ".", "registeredNIC", "=", "nic", "\n", "ep", ".", "connected", "=", "true", "\n\n", "return", "nil", "\n", "}" ]

[ "Connect", "implements", "tcpip", ".", "Endpoint", ".", "Connect", "." ]

[ "func", "(", "ep", "*", "endpoint", ")", "Shutdown", "(", "flags", "tcpip", ".", "ShutdownFlags", ")", "*", "tcpip", ".", "Error", "{", "ep", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "ep", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "if", "!", "ep", ".", "connected", "{", "return", "tcpip", ".", "ErrNotConnected", "\n", "}", "\n\n", "ep", ".", "shutdownFlags", "|=", "flags", "\n\n", "if", "flags", "&", "tcpip", ".", "ShutdownRead", "!=", "0", "{", "ep", ".", "rcvMu", ".", "Lock", "(", ")", "\n", "wasClosed", ":=", "ep", ".", "rcvClosed", "\n", "ep", ".", "rcvClosed", "=", "true", "\n", "ep", ".", "rcvMu", ".", "Unlock", "(", ")", "\n\n", "if", "!", "wasClosed", "{", "ep", ".", "waiterQueue", ".", "Notify", "(", "waiter", ".", "EventIn", ")", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Shutdown", "implements", "tcpip", ".", "Endpoint", ".", "Shutdown", "." ]

[ "func", "(", "ep", "*", "endpoint", ")", "Accept", "(", ")", "(", "tcpip", ".", "Endpoint", ",", "*", "waiter", ".", "Queue", ",", "*", "tcpip", ".", "Error", ")", "{", "return", "nil", ",", "nil", ",", "tcpip", ".", "ErrNotSupported", "\n", "}" ]

[ "Accept", "implements", "tcpip", ".", "Endpoint", ".", "Accept", "." ]

[ "func", "(", "ep", "*", "endpoint", ")", "Bind", "(", "addr", "tcpip", ".", "FullAddress", ")", "*", "tcpip", ".", "Error", "{", "ep", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "ep", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "// Callers must provide an IPv4 address or no network address (for", "// binding to a NIC, but not an address).", "if", "len", "(", "addr", ".", "Addr", ")", "!=", "0", "&&", "len", "(", "addr", ".", "Addr", ")", "!=", "4", "{", "return", "tcpip", ".", "ErrInvalidEndpointState", "\n", "}", "\n\n", "// If a local address was specified, verify that it's valid.", "if", "len", "(", "addr", ".", "Addr", ")", "==", "header", ".", "IPv4AddressSize", "&&", "ep", ".", "stack", ".", "CheckLocalAddress", "(", "addr", ".", "NIC", ",", "ep", ".", "netProto", ",", "addr", ".", "Addr", ")", "==", "0", "{", "return", "tcpip", ".", "ErrBadLocalAddress", "\n", "}", "\n\n", "// Re-register the endpoint with the appropriate NIC.", "if", "err", ":=", "ep", ".", "stack", ".", "RegisterRawTransportEndpoint", "(", "addr", ".", "NIC", ",", "ep", ".", "netProto", ",", "ep", ".", "transProto", ",", "ep", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "ep", ".", "stack", ".", "UnregisterRawTransportEndpoint", "(", "ep", ".", "registeredNIC", ",", "ep", ".", "netProto", ",", "ep", ".", "transProto", ",", "ep", ")", "\n\n", "ep", ".", "registeredNIC", "=", "addr", ".", "NIC", "\n", "ep", ".", "boundNIC", "=", "addr", ".", "NIC", "\n", "ep", ".", "boundAddr", "=", "addr", ".", "Addr", "\n", "ep", ".", "bound", "=", "true", "\n\n", "return", "nil", "\n", "}" ]

[ "Bind", "implements", "tcpip", ".", "Endpoint", ".", "Bind", "." ]

[ "func", "(", "ep", "*", "endpoint", ")", "GetLocalAddress", "(", ")", "(", "tcpip", ".", "FullAddress", ",", "*", "tcpip", ".", "Error", ")", "{", "return", "tcpip", ".", "FullAddress", "{", "}", ",", "tcpip", ".", "ErrNotSupported", "\n", "}" ]

[ "GetLocalAddress", "implements", "tcpip", ".", "Endpoint", ".", "GetLocalAddress", "." ]

[ "func", "(", "ep", "*", "endpoint", ")", "GetRemoteAddress", "(", ")", "(", "tcpip", ".", "FullAddress", ",", "*", "tcpip", ".", "Error", ")", "{", "ep", ".", "mu", ".", "RLock", "(", ")", "\n", "defer", "ep", ".", "mu", ".", "RUnlock", "(", ")", "\n\n", "if", "!", "ep", ".", "connected", "{", "return", "tcpip", ".", "FullAddress", "{", "}", ",", "tcpip", ".", "ErrNotConnected", "\n", "}", "\n\n", "return", "tcpip", ".", "FullAddress", "{", "NIC", ":", "ep", ".", "registeredNIC", ",", "Addr", ":", "ep", ".", "route", ".", "RemoteAddress", ",", "}", ",", "nil", "\n", "}" ]

[ "GetRemoteAddress", "implements", "tcpip", ".", "Endpoint", ".", "GetRemoteAddress", "." ]

[ "func", "(", "ep", "*", "endpoint", ")", "HandlePacket", "(", "route", "*", "stack", ".", "Route", ",", "netHeader", "buffer", ".", "View", ",", "vv", "buffer", ".", "VectorisedView", ")", "{", "ep", ".", "rcvMu", ".", "Lock", "(", ")", "\n\n", "// Drop the packet if our buffer is currently full.", "if", "ep", ".", "rcvClosed", "||", "ep", ".", "rcvBufSize", ">=", "ep", ".", "rcvBufSizeMax", "{", "ep", ".", "stack", ".", "Stats", "(", ")", ".", "DroppedPackets", ".", "Increment", "(", ")", "\n", "ep", ".", "rcvMu", ".", "Unlock", "(", ")", "\n", "return", "\n", "}", "\n\n", "if", "ep", ".", "bound", "{", "// If bound to a NIC, only accept data for that NIC.", "if", "ep", ".", "boundNIC", "!=", "0", "&&", "ep", ".", "boundNIC", "!=", "route", ".", "NICID", "(", ")", "{", "ep", ".", "rcvMu", ".", "Unlock", "(", ")", "\n", "return", "\n", "}", "\n", "// If bound to an address, only accept data for that address.", "if", "ep", ".", "boundAddr", "!=", "\"", "\"", "&&", "ep", ".", "boundAddr", "!=", "route", ".", "RemoteAddress", "{", "ep", ".", "rcvMu", ".", "Unlock", "(", ")", "\n", "return", "\n", "}", "\n", "}", "\n\n", "// If connected, only accept packets from the remote address we", "// connected to.", "if", "ep", ".", "connected", "&&", "ep", ".", "route", ".", "RemoteAddress", "!=", "route", ".", "RemoteAddress", "{", "ep", ".", "rcvMu", ".", "Unlock", "(", ")", "\n", "return", "\n", "}", "\n\n", "wasEmpty", ":=", "ep", ".", "rcvBufSize", "==", "0", "\n\n", "// Push new packet into receive list and increment the buffer size.", "packet", ":=", "&", "packet", "{", "senderAddr", ":", "tcpip", ".", "FullAddress", "{", "NIC", ":", "route", ".", "NICID", "(", ")", ",", "Addr", ":", "route", ".", "RemoteAddress", ",", "}", ",", "}", "\n\n", "combinedVV", ":=", "netHeader", ".", "ToVectorisedView", "(", ")", "\n", "combinedVV", ".", "Append", "(", "vv", ")", "\n", "packet", ".", "data", "=", "combinedVV", ".", "Clone", "(", "packet", ".", "views", "[", ":", "]", ")", "\n", "packet", ".", "timestampNS", "=", "ep", ".", "stack", ".", "NowNanoseconds", "(", ")", "\n\n", "ep", ".", "rcvList", ".", "PushBack", "(", "packet", ")", "\n", "ep", ".", "rcvBufSize", "+=", "packet", ".", "data", ".", "Size", "(", ")", "\n\n", "ep", ".", "rcvMu", ".", "Unlock", "(", ")", "\n\n", "// Notify waiters that there's data to be read.", "if", "wasEmpty", "{", "ep", ".", "waiterQueue", ".", "Notify", "(", "waiter", ".", "EventIn", ")", "\n", "}", "\n", "}" ]

[ "HandlePacket", "implements", "stack", ".", "RawTransportEndpoint", ".", "HandlePacket", "." ]

[ "func", "New", "(", "lower", "tcpip", ".", "LinkEndpointID", ")", "tcpip", ".", "LinkEndpointID", "{", "return", "stack", ".", "RegisterLinkEndpoint", "(", "&", "endpoint", "{", "lower", ":", "stack", ".", "FindLinkEndpoint", "(", "lower", ")", ",", "}", ")", "\n", "}" ]

[ "New", "creates", "a", "new", "sniffer", "link", "-", "layer", "endpoint", ".", "It", "wraps", "around", "another", "endpoint", "and", "logs", "packets", "and", "they", "traverse", "the", "endpoint", "." ]

[ "func", "NewWithFile", "(", "lower", "tcpip", ".", "LinkEndpointID", ",", "file", "*", "os", ".", "File", ",", "snapLen", "uint32", ")", "(", "tcpip", ".", "LinkEndpointID", ",", "error", ")", "{", "if", "err", ":=", "writePCAPHeader", "(", "file", ",", "snapLen", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "stack", ".", "RegisterLinkEndpoint", "(", "&", "endpoint", "{", "lower", ":", "stack", ".", "FindLinkEndpoint", "(", "lower", ")", ",", "file", ":", "file", ",", "maxPCAPLen", ":", "snapLen", ",", "}", ")", ",", "nil", "\n", "}" ]

[ "NewWithFile", "creates", "a", "new", "sniffer", "link", "-", "layer", "endpoint", ".", "It", "wraps", "around", "another", "endpoint", "and", "logs", "packets", "and", "they", "traverse", "the", "endpoint", ".", "Packets", "can", "be", "logged", "to", "file", "in", "the", "pcap", "format", ".", "A", "sniffer", "created", "with", "this", "function", "will", "not", "emit", "packets", "using", "the", "standard", "log", "package", ".", "snapLen", "is", "the", "maximum", "amount", "of", "a", "packet", "to", "be", "saved", ".", "Packets", "with", "a", "length", "less", "than", "or", "equal", "too", "snapLen", "will", "be", "saved", "in", "their", "entirety", ".", "Longer", "packets", "will", "be", "truncated", "to", "snapLen", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "DeliverNetworkPacket", "(", "linkEP", "stack", ".", "LinkEndpoint", ",", "remote", ",", "local", "tcpip", ".", "LinkAddress", ",", "protocol", "tcpip", ".", "NetworkProtocolNumber", ",", "vv", "buffer", ".", "VectorisedView", ")", "{", "if", "atomic", ".", "LoadUint32", "(", "&", "LogPackets", ")", "==", "1", "&&", "e", ".", "file", "==", "nil", "{", "logPacket", "(", "\"", "\"", ",", "protocol", ",", "vv", ".", "First", "(", ")", ")", "\n", "}", "\n", "if", "e", ".", "file", "!=", "nil", "&&", "atomic", ".", "LoadUint32", "(", "&", "LogPacketsToFile", ")", "==", "1", "{", "vs", ":=", "vv", ".", "Views", "(", ")", "\n", "length", ":=", "vv", ".", "Size", "(", ")", "\n", "if", "length", ">", "int", "(", "e", ".", "maxPCAPLen", ")", "{", "length", "=", "int", "(", "e", ".", "maxPCAPLen", ")", "\n", "}", "\n\n", "buf", ":=", "bytes", ".", "NewBuffer", "(", "make", "(", "[", "]", "byte", ",", "0", ",", "pcapPacketHeaderLen", "+", "length", ")", ")", "\n", "if", "err", ":=", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "BigEndian", ",", "newPCAPPacketHeader", "(", "uint32", "(", "length", ")", ",", "uint32", "(", "vv", ".", "Size", "(", ")", ")", ")", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "for", "_", ",", "v", ":=", "range", "vs", "{", "if", "length", "==", "0", "{", "break", "\n", "}", "\n", "if", "len", "(", "v", ")", ">", "length", "{", "v", "=", "v", "[", ":", "length", "]", "\n", "}", "\n", "if", "_", ",", "err", ":=", "buf", ".", "Write", "(", "[", "]", "byte", "(", "v", ")", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "length", "-=", "len", "(", "v", ")", "\n", "}", "\n", "if", "_", ",", "err", ":=", "e", ".", "file", ".", "Write", "(", "buf", ".", "Bytes", "(", ")", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "}", "\n", "e", ".", "dispatcher", ".", "DeliverNetworkPacket", "(", "e", ",", "remote", ",", "local", ",", "protocol", ",", "vv", ")", "\n", "}" ]

[ "DeliverNetworkPacket", "implements", "the", "stack", ".", "NetworkDispatcher", "interface", ".", "It", "is", "called", "by", "the", "link", "-", "layer", "endpoint", "being", "wrapped", "when", "a", "packet", "arrives", "and", "logs", "the", "packet", "before", "forwarding", "to", "the", "actual", "dispatcher", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "Attach", "(", "dispatcher", "stack", ".", "NetworkDispatcher", ")", "{", "e", ".", "dispatcher", "=", "dispatcher", "\n", "e", ".", "lower", ".", "Attach", "(", "e", ")", "\n", "}" ]

[ "Attach", "implements", "the", "stack", ".", "LinkEndpoint", "interface", ".", "It", "saves", "the", "dispatcher", "and", "registers", "with", "the", "lower", "endpoint", "as", "its", "dispatcher", "so", "that", "e", "is", "called", "for", "inbound", "packets", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "WritePacket", "(", "r", "*", "stack", ".", "Route", ",", "gso", "*", "stack", ".", "GSO", ",", "hdr", "buffer", ".", "Prependable", ",", "payload", "buffer", ".", "VectorisedView", ",", "protocol", "tcpip", ".", "NetworkProtocolNumber", ")", "*", "tcpip", ".", "Error", "{", "if", "atomic", ".", "LoadUint32", "(", "&", "LogPackets", ")", "==", "1", "&&", "e", ".", "file", "==", "nil", "{", "logPacket", "(", "\"", "\"", ",", "protocol", ",", "hdr", ".", "View", "(", ")", ")", "\n", "}", "\n", "if", "e", ".", "file", "!=", "nil", "&&", "atomic", ".", "LoadUint32", "(", "&", "LogPacketsToFile", ")", "==", "1", "{", "hdrBuf", ":=", "hdr", ".", "View", "(", ")", "\n", "length", ":=", "len", "(", "hdrBuf", ")", "+", "payload", ".", "Size", "(", ")", "\n", "if", "length", ">", "int", "(", "e", ".", "maxPCAPLen", ")", "{", "length", "=", "int", "(", "e", ".", "maxPCAPLen", ")", "\n", "}", "\n\n", "buf", ":=", "bytes", ".", "NewBuffer", "(", "make", "(", "[", "]", "byte", ",", "0", ",", "pcapPacketHeaderLen", "+", "length", ")", ")", "\n", "if", "err", ":=", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "BigEndian", ",", "newPCAPPacketHeader", "(", "uint32", "(", "length", ")", ",", "uint32", "(", "len", "(", "hdrBuf", ")", "+", "payload", ".", "Size", "(", ")", ")", ")", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "if", "len", "(", "hdrBuf", ")", ">", "length", "{", "hdrBuf", "=", "hdrBuf", "[", ":", "length", "]", "\n", "}", "\n", "if", "_", ",", "err", ":=", "buf", ".", "Write", "(", "hdrBuf", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "length", "-=", "len", "(", "hdrBuf", ")", "\n", "if", "length", ">", "0", "{", "for", "_", ",", "v", ":=", "range", "payload", ".", "Views", "(", ")", "{", "if", "len", "(", "v", ")", ">", "length", "{", "v", "=", "v", "[", ":", "length", "]", "\n", "}", "\n", "n", ",", "err", ":=", "buf", ".", "Write", "(", "v", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "length", "-=", "n", "\n", "if", "length", "==", "0", "{", "break", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "_", ",", "err", ":=", "e", ".", "file", ".", "Write", "(", "buf", ".", "Bytes", "(", ")", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "e", ".", "lower", ".", "WritePacket", "(", "r", ",", "gso", ",", "hdr", ",", "payload", ",", "protocol", ")", "\n", "}" ]

[ "WritePacket", "implements", "the", "stack", ".", "LinkEndpoint", "interface", ".", "It", "is", "called", "by", "higher", "-", "level", "protocols", "to", "write", "packets", ";", "it", "just", "logs", "the", "packet", "and", "forwards", "the", "request", "to", "the", "lower", "endpoint", "." ]

[ "func", "NewForwarder", "(", "s", "*", "stack", ".", "Stack", ",", "rcvWnd", ",", "maxInFlight", "int", ",", "handler", "func", "(", "*", "ForwarderRequest", ")", ")", "*", "Forwarder", "{", "if", "rcvWnd", "==", "0", "{", "rcvWnd", "=", "DefaultBufferSize", "\n", "}", "\n", "return", "&", "Forwarder", "{", "maxInFlight", ":", "maxInFlight", ",", "handler", ":", "handler", ",", "inFlight", ":", "make", "(", "map", "[", "stack", ".", "TransportEndpointID", "]", "struct", "{", "}", ")", ",", "listen", ":", "newListenContext", "(", "s", ",", "seqnum", ".", "Size", "(", "rcvWnd", ")", ",", "true", ",", "0", ")", ",", "}", "\n", "}" ]

[ "NewForwarder", "allocates", "and", "initializes", "a", "new", "forwarder", "with", "the", "given", "maximum", "number", "of", "in", "-", "flight", "connection", "attempts", ".", "Once", "the", "maximum", "is", "reached", "new", "incoming", "connection", "requests", "will", "be", "ignored", ".", "If", "rcvWnd", "is", "set", "to", "zero", "the", "default", "buffer", "size", "is", "used", "instead", "." ]

[ "func", "(", "r", "*", "ForwarderRequest", ")", "Complete", "(", "sendReset", "bool", ")", "{", "r", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "r", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "if", "r", ".", "segment", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Remove request from the forwarder.", "r", ".", "forwarder", ".", "mu", ".", "Lock", "(", ")", "\n", "delete", "(", "r", ".", "forwarder", ".", "inFlight", ",", "r", ".", "segment", ".", "id", ")", "\n", "r", ".", "forwarder", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "// If the caller requested, send a reset.", "if", "sendReset", "{", "replyWithReset", "(", "r", ".", "segment", ")", "\n", "}", "\n\n", "// Release all resources.", "r", ".", "segment", ".", "decRef", "(", ")", "\n", "r", ".", "segment", "=", "nil", "\n", "r", ".", "forwarder", "=", "nil", "\n", "}" ]

[ "Complete", "completes", "the", "request", "and", "optionally", "sends", "a", "RST", "segment", "back", "to", "the", "sender", "." ]

[ "func", "(", "r", "*", "ForwarderRequest", ")", "CreateEndpoint", "(", "queue", "*", "waiter", ".", "Queue", ")", "(", "tcpip", ".", "Endpoint", ",", "*", "tcpip", ".", "Error", ")", "{", "r", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "r", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "if", "r", ".", "segment", "==", "nil", "{", "return", "nil", ",", "tcpip", ".", "ErrInvalidEndpointState", "\n", "}", "\n\n", "f", ":=", "r", ".", "forwarder", "\n", "ep", ",", "err", ":=", "f", ".", "listen", ".", "createEndpointAndPerformHandshake", "(", "r", ".", "segment", ",", "&", "header", ".", "TCPSynOptions", "{", "MSS", ":", "r", ".", "synOptions", ".", "MSS", ",", "WS", ":", "r", ".", "synOptions", ".", "WS", ",", "TS", ":", "r", ".", "synOptions", ".", "TS", ",", "TSVal", ":", "r", ".", "synOptions", ".", "TSVal", ",", "TSEcr", ":", "r", ".", "synOptions", ".", "TSEcr", ",", "SACKPermitted", ":", "r", ".", "synOptions", ".", "SACKPermitted", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Start the protocol goroutine.", "ep", ".", "startAcceptedLoop", "(", "queue", ")", "\n\n", "return", "ep", ",", "nil", "\n", "}" ]

[ "CreateEndpoint", "creates", "a", "TCP", "endpoint", "for", "the", "connection", "request", "performing", "the", "3", "-", "way", "handshake", "in", "the", "process", "." ]

[ "func", "(", "s", "*", "sender", ")", "sendAck", "(", ")", "{", "s", ".", "sendSegment", "(", "buffer", ".", "VectorisedView", "{", "}", ",", "header", ".", "TCPFlagAck", ",", "s", ".", "sndNxt", ")", "\n", "}" ]

[ "sendAck", "sends", "an", "ACK", "segment", "." ]

[ "func", "(", "s", "*", "sender", ")", "updateRTO", "(", "rtt", "time", ".", "Duration", ")", "{", "s", ".", "rtt", ".", "Lock", "(", ")", "\n", "if", "!", "s", ".", "srttInited", "{", "s", ".", "rtt", ".", "rttvar", "=", "rtt", "/", "2", "\n", "s", ".", "rtt", ".", "srtt", "=", "rtt", "\n", "s", ".", "srttInited", "=", "true", "\n", "}", "else", "{", "diff", ":=", "s", ".", "rtt", ".", "srtt", "-", "rtt", "\n", "if", "diff", "<", "0", "{", "diff", "=", "-", "diff", "\n", "}", "\n", "// Use RFC6298 standard algorithm to update rttvar and srtt when", "// no timestamps are available.", "if", "!", "s", ".", "ep", ".", "sendTSOk", "{", "s", ".", "rtt", ".", "rttvar", "=", "(", "3", "*", "s", ".", "rtt", ".", "rttvar", "+", "diff", ")", "/", "4", "\n", "s", ".", "rtt", ".", "srtt", "=", "(", "7", "*", "s", ".", "rtt", ".", "srtt", "+", "rtt", ")", "/", "8", "\n", "}", "else", "{", "// When we are taking RTT measurements of every ACK then", "// we need to use a modified method as specified in", "// https://tools.ietf.org/html/rfc7323#appendix-G", "if", "s", ".", "outstanding", "==", "0", "{", "s", ".", "rtt", ".", "Unlock", "(", ")", "\n", "return", "\n", "}", "\n", "// Netstack measures congestion window/inflight all in", "// terms of packets and not bytes. This is similar to", "// how linux also does cwnd and inflight. In practice", "// this approximation works as expected.", "expectedSamples", ":=", "math", ".", "Ceil", "(", "float64", "(", "s", ".", "outstanding", ")", "/", "2", ")", "\n\n", "// alpha & beta values are the original values as recommended in", "// https://tools.ietf.org/html/rfc6298#section-2.3.", "const", "alpha", "=", "0.125", "\n", "const", "beta", "=", "0.25", "\n\n", "alphaPrime", ":=", "alpha", "/", "expectedSamples", "\n", "betaPrime", ":=", "beta", "/", "expectedSamples", "\n", "rttVar", ":=", "(", "1", "-", "betaPrime", ")", "*", "s", ".", "rtt", ".", "rttvar", ".", "Seconds", "(", ")", "+", "betaPrime", "*", "diff", ".", "Seconds", "(", ")", "\n", "srtt", ":=", "(", "1", "-", "alphaPrime", ")", "*", "s", ".", "rtt", ".", "srtt", ".", "Seconds", "(", ")", "+", "alphaPrime", "*", "rtt", ".", "Seconds", "(", ")", "\n", "s", ".", "rtt", ".", "rttvar", "=", "time", ".", "Duration", "(", "rttVar", "*", "float64", "(", "time", ".", "Second", ")", ")", "\n", "s", ".", "rtt", ".", "srtt", "=", "time", ".", "Duration", "(", "srtt", "*", "float64", "(", "time", ".", "Second", ")", ")", "\n", "}", "\n", "}", "\n\n", "s", ".", "rto", "=", "s", ".", "rtt", ".", "srtt", "+", "4", "*", "s", ".", "rtt", ".", "rttvar", "\n", "s", ".", "rtt", ".", "Unlock", "(", ")", "\n", "if", "s", ".", "rto", "<", "minRTO", "{", "s", ".", "rto", "=", "minRTO", "\n", "}", "\n", "}" ]

[ "updateRTO", "updates", "the", "retransmit", "timeout", "when", "a", "new", "roud", "-", "trip", "time", "is", "available", ".", "This", "is", "done", "in", "accordance", "with", "section", "2", "of", "RFC", "6298", "." ]

[ "func", "(", "s", "*", "sender", ")", "resendSegment", "(", ")", "{", "// Don't use any segments we already sent to measure RTT as they may", "// have been affected by packets being lost.", "s", ".", "rttMeasureSeqNum", "=", "s", ".", "sndNxt", "\n\n", "// Resend the segment.", "if", "seg", ":=", "s", ".", "writeList", ".", "Front", "(", ")", ";", "seg", "!=", "nil", "{", "if", "seg", ".", "data", ".", "Size", "(", ")", ">", "s", ".", "maxPayloadSize", "{", "available", ":=", "s", ".", "maxPayloadSize", "\n", "// Split this segment up.", "nSeg", ":=", "seg", ".", "clone", "(", ")", "\n", "nSeg", ".", "data", ".", "TrimFront", "(", "available", ")", "\n", "nSeg", ".", "sequenceNumber", ".", "UpdateForward", "(", "seqnum", ".", "Size", "(", "available", ")", ")", "\n", "s", ".", "writeList", ".", "InsertAfter", "(", "seg", ",", "nSeg", ")", "\n", "seg", ".", "data", ".", "CapLength", "(", "available", ")", "\n", "}", "\n", "s", ".", "sendSegment", "(", "seg", ".", "data", ",", "seg", ".", "flags", ",", "seg", ".", "sequenceNumber", ")", "\n", "s", ".", "ep", ".", "stack", ".", "Stats", "(", ")", ".", "TCP", ".", "FastRetransmit", ".", "Increment", "(", ")", "\n", "s", ".", "ep", ".", "stack", ".", "Stats", "(", ")", ".", "TCP", ".", "Retransmits", ".", "Increment", "(", ")", "\n", "}", "\n", "}" ]

[ "resendSegment", "resends", "the", "first", "unacknowledged", "segment", "." ]

[ "func", "(", "s", "*", "sender", ")", "retransmitTimerExpired", "(", ")", "bool", "{", "// Check if the timer actually expired or if it's a spurious wake due", "// to a previously orphaned runtime timer.", "if", "!", "s", ".", "resendTimer", ".", "checkExpiration", "(", ")", "{", "return", "true", "\n", "}", "\n\n", "s", ".", "ep", ".", "stack", ".", "Stats", "(", ")", ".", "TCP", ".", "Timeouts", ".", "Increment", "(", ")", "\n\n", "// Give up if we've waited more than a minute since the last resend.", "if", "s", ".", "rto", ">=", "60", "*", "time", ".", "Second", "{", "return", "false", "\n", "}", "\n\n", "// Set new timeout. The timer will be restarted by the call to sendData", "// below.", "s", ".", "rto", "*=", "2", "\n\n", "if", "s", ".", "fr", ".", "active", "{", "// We were attempting fast recovery but were not successful.", "// Leave the state. We don't need to update ssthresh because it", "// has already been updated when entered fast-recovery.", "s", ".", "leaveFastRecovery", "(", ")", "\n", "}", "\n\n", "// See: https://tools.ietf.org/html/rfc6582#section-3.2 Step 4.", "// We store the highest sequence number transmitted in cases where", "// we were not in fast recovery.", "s", ".", "fr", ".", "last", "=", "s", ".", "sndNxt", "-", "1", "\n\n", "s", ".", "cc", ".", "HandleRTOExpired", "(", ")", "\n\n", "// Mark the next segment to be sent as the first unacknowledged one and", "// start sending again. Set the number of outstanding packets to 0 so", "// that we'll be able to retransmit.", "//", "// We'll keep on transmitting (or retransmitting) as we get acks for", "// the data we transmit.", "s", ".", "outstanding", "=", "0", "\n\n", "// Expunge all SACK information as per https://tools.ietf.org/html/rfc6675#section-5.1", "//", "// In order to avoid memory deadlocks, the TCP receiver is allowed to", "// discard data that has already been selectively acknowledged. As a", "// result, [RFC2018] suggests that a TCP sender SHOULD expunge the SACK", "// information gathered from a receiver upon a retransmission timeout", "// (RTO) \"since the timeout might indicate that the data receiver has", "// reneged.\" Additionally, a TCP sender MUST \"ignore prior SACK", "// information in determining which data to retransmit.\"", "//", "// NOTE: We take the stricter interpretation and just expunge all", "// information as we lack more rigorous checks to validate if the SACK", "// information is usable after an RTO.", "s", ".", "ep", ".", "scoreboard", ".", "Reset", "(", ")", "\n", "s", ".", "writeNext", "=", "s", ".", "writeList", ".", "Front", "(", ")", "\n", "s", ".", "sendData", "(", ")", "\n\n", "return", "true", "\n", "}" ]

[ "retransmitTimerExpired", "is", "called", "when", "the", "retransmit", "timer", "expires", "and", "unacknowledged", "segments", "are", "assumed", "lost", "and", "thus", "need", "to", "be", "resent", ".", "Returns", "true", "if", "the", "connection", "is", "still", "usable", "or", "false", "if", "the", "connection", "is", "deemed", "lost", "." ]

[ "func", "(", "s", "*", "sender", ")", "pCount", "(", "seg", "*", "segment", ")", "int", "{", "size", ":=", "seg", ".", "data", ".", "Size", "(", ")", "\n", "if", "size", "==", "0", "{", "return", "1", "\n", "}", "\n\n", "return", "(", "size", "-", "1", ")", "/", "s", ".", "maxPayloadSize", "+", "1", "\n", "}" ]

[ "pCount", "returns", "the", "number", "of", "packets", "in", "the", "segment", ".", "Due", "to", "GSO", "a", "segment", "can", "be", "composed", "of", "multiple", "packets", "." ]

[ "func", "(", "s", "*", "sender", ")", "sendSegment", "(", "data", "buffer", ".", "VectorisedView", ",", "flags", "byte", ",", "seq", "seqnum", ".", "Value", ")", "*", "tcpip", ".", "Error", "{", "s", ".", "lastSendTime", "=", "time", ".", "Now", "(", ")", "\n", "if", "seq", "==", "s", ".", "rttMeasureSeqNum", "{", "s", ".", "rttMeasureTime", "=", "s", ".", "lastSendTime", "\n", "}", "\n\n", "rcvNxt", ",", "rcvWnd", ":=", "s", ".", "ep", ".", "rcv", ".", "getSendParams", "(", ")", "\n\n", "// Remember the max sent ack.", "s", ".", "maxSentAck", "=", "rcvNxt", "\n\n", "return", "s", ".", "ep", ".", "sendRaw", "(", "data", ",", "flags", ",", "seq", ",", "rcvNxt", ",", "rcvWnd", ")", "\n", "}" ]

[ "sendSegment", "sends", "a", "new", "segment", "containing", "the", "given", "payload", "flags", "and", "sequence", "number", "." ]

[ "func", "(", "m", "*", "InjectableEndpoint", ")", "MTU", "(", ")", "uint32", "{", "minMTU", ":=", "^", "uint32", "(", "0", ")", "\n", "for", "_", ",", "endpoint", ":=", "range", "m", ".", "routes", "{", "if", "endpointMTU", ":=", "endpoint", ".", "MTU", "(", ")", ";", "endpointMTU", "<", "minMTU", "{", "minMTU", "=", "endpointMTU", "\n", "}", "\n", "}", "\n", "return", "minMTU", "\n", "}" ]

[ "MTU", "implements", "stack", ".", "LinkEndpoint", "." ]

[ "func", "(", "m", "*", "InjectableEndpoint", ")", "Capabilities", "(", ")", "stack", ".", "LinkEndpointCapabilities", "{", "minCapabilities", ":=", "stack", ".", "LinkEndpointCapabilities", "(", "^", "uint", "(", "0", ")", ")", "\n", "for", "_", ",", "endpoint", ":=", "range", "m", ".", "routes", "{", "minCapabilities", "&=", "endpoint", ".", "Capabilities", "(", ")", "\n", "}", "\n", "return", "minCapabilities", "\n", "}" ]

[ "Capabilities", "implements", "stack", ".", "LinkEndpoint", "." ]

[ "func", "(", "m", "*", "InjectableEndpoint", ")", "MaxHeaderLength", "(", ")", "uint16", "{", "minHeaderLen", ":=", "^", "uint16", "(", "0", ")", "\n", "for", "_", ",", "endpoint", ":=", "range", "m", ".", "routes", "{", "if", "headerLen", ":=", "endpoint", ".", "MaxHeaderLength", "(", ")", ";", "headerLen", "<", "minHeaderLen", "{", "minHeaderLen", "=", "headerLen", "\n", "}", "\n", "}", "\n", "return", "minHeaderLen", "\n", "}" ]

[ "MaxHeaderLength", "implements", "stack", ".", "LinkEndpoint", "." ]

[ "func", "(", "m", "*", "InjectableEndpoint", ")", "Attach", "(", "dispatcher", "stack", ".", "NetworkDispatcher", ")", "{", "for", "_", ",", "endpoint", ":=", "range", "m", ".", "routes", "{", "endpoint", ".", "Attach", "(", "dispatcher", ")", "\n", "}", "\n", "m", ".", "dispatcher", "=", "dispatcher", "\n", "}" ]

[ "Attach", "implements", "stack", ".", "LinkEndpoint", "." ]

[ "func", "(", "m", "*", "InjectableEndpoint", ")", "Inject", "(", "protocol", "tcpip", ".", "NetworkProtocolNumber", ",", "vv", "buffer", ".", "VectorisedView", ")", "{", "m", ".", "dispatcher", ".", "DeliverNetworkPacket", "(", "m", ",", "\"", "\"", "/* remote */", ",", "\"", "\"", "/* local */", ",", "protocol", ",", "vv", ")", "\n", "}" ]

[ "Inject", "implements", "stack", ".", "InjectableLinkEndpoint", "." ]

[ "func", "(", "m", "*", "InjectableEndpoint", ")", "WritePacket", "(", "r", "*", "stack", ".", "Route", ",", "_", "*", "stack", ".", "GSO", ",", "hdr", "buffer", ".", "Prependable", ",", "payload", "buffer", ".", "VectorisedView", ",", "protocol", "tcpip", ".", "NetworkProtocolNumber", ")", "*", "tcpip", ".", "Error", "{", "if", "endpoint", ",", "ok", ":=", "m", ".", "routes", "[", "r", ".", "RemoteAddress", "]", ";", "ok", "{", "return", "endpoint", ".", "WritePacket", "(", "r", ",", "nil", "/* gso */", ",", "hdr", ",", "payload", ",", "protocol", ")", "\n", "}", "\n", "return", "tcpip", ".", "ErrNoRoute", "\n", "}" ]

[ "WritePacket", "writes", "outbound", "packets", "to", "the", "appropriate", "LinkInjectableEndpoint", "based", "on", "the", "RemoteAddress", ".", "HandleLocal", "only", "works", "if", "r", ".", "RemoteAddress", "has", "a", "route", "registered", "in", "this", "endpoint", "." ]

[ "func", "(", "m", "*", "InjectableEndpoint", ")", "WriteRawPacket", "(", "dest", "tcpip", ".", "Address", ",", "packet", "[", "]", "byte", ")", "*", "tcpip", ".", "Error", "{", "endpoint", ",", "ok", ":=", "m", ".", "routes", "[", "dest", "]", "\n", "if", "!", "ok", "{", "return", "tcpip", ".", "ErrNoRoute", "\n", "}", "\n", "return", "endpoint", ".", "WriteRawPacket", "(", "dest", ",", "packet", ")", "\n", "}" ]

[ "WriteRawPacket", "writes", "outbound", "packets", "to", "the", "appropriate", "LinkInjectableEndpoint", "based", "on", "the", "dest", "address", "." ]

[ "func", "NewInjectableEndpoint", "(", "routes", "map", "[", "tcpip", ".", "Address", "]", "stack", ".", "InjectableLinkEndpoint", ")", "(", "tcpip", ".", "LinkEndpointID", ",", "*", "InjectableEndpoint", ")", "{", "e", ":=", "&", "InjectableEndpoint", "{", "routes", ":", "routes", ",", "}", "\n", "return", "stack", ".", "RegisterLinkEndpoint", "(", "e", ")", ",", "e", "\n", "}" ]

[ "NewInjectableEndpoint", "creates", "a", "new", "multi", "-", "endpoint", "injectable", "endpoint", "." ]

[ "func", "GetMTU", "(", "name", "string", ")", "(", "uint32", ",", "error", ")", "{", "fd", ",", "err", ":=", "syscall", ".", "Socket", "(", "syscall", ".", "AF_UNIX", ",", "syscall", ".", "SOCK_DGRAM", ",", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "defer", "syscall", ".", "Close", "(", "fd", ")", "\n\n", "var", "ifreq", "struct", "{", "name", "[", "16", "]", "byte", "\n", "mtu", "int32", "\n", "_", "[", "20", "]", "byte", "\n", "}", "\n\n", "copy", "(", "ifreq", ".", "name", "[", ":", "]", ",", "name", ")", "\n", "_", ",", "_", ",", "errno", ":=", "syscall", ".", "Syscall", "(", "syscall", ".", "SYS_IOCTL", ",", "uintptr", "(", "fd", ")", ",", "syscall", ".", "SIOCGIFMTU", ",", "uintptr", "(", "unsafe", ".", "Pointer", "(", "&", "ifreq", ")", ")", ")", "\n", "if", "errno", "!=", "0", "{", "return", "0", ",", "errno", "\n", "}", "\n\n", "return", "uint32", "(", "ifreq", ".", "mtu", ")", ",", "nil", "\n", "}" ]

[ "GetMTU", "determines", "the", "MTU", "of", "a", "network", "interface", "device", "." ]

[ "func", "NonBlockingWrite", "(", "fd", "int", ",", "buf", "[", "]", "byte", ")", "*", "tcpip", ".", "Error", "{", "var", "ptr", "unsafe", ".", "Pointer", "\n", "if", "len", "(", "buf", ")", ">", "0", "{", "ptr", "=", "unsafe", ".", "Pointer", "(", "&", "buf", "[", "0", "]", ")", "\n", "}", "\n\n", "_", ",", "_", ",", "e", ":=", "syscall", ".", "RawSyscall", "(", "syscall", ".", "SYS_WRITE", ",", "uintptr", "(", "fd", ")", ",", "uintptr", "(", "ptr", ")", ",", "uintptr", "(", "len", "(", "buf", ")", ")", ")", "\n", "if", "e", "!=", "0", "{", "return", "TranslateErrno", "(", "e", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "NonBlockingWrite", "writes", "the", "given", "buffer", "to", "a", "file", "descriptor", ".", "It", "fails", "if", "partial", "data", "is", "written", "." ]

[ "func", "NonBlockingWrite3", "(", "fd", "int", ",", "b1", ",", "b2", ",", "b3", "[", "]", "byte", ")", "*", "tcpip", ".", "Error", "{", "// If the is no second buffer, issue a regular write.", "if", "len", "(", "b2", ")", "==", "0", "{", "return", "NonBlockingWrite", "(", "fd", ",", "b1", ")", "\n", "}", "\n\n", "// We have two buffers. Build the iovec that represents them and issue", "// a writev syscall.", "iovec", ":=", "[", "3", "]", "syscall", ".", "Iovec", "{", "{", "Base", ":", "&", "b1", "[", "0", "]", ",", "Len", ":", "uint64", "(", "len", "(", "b1", ")", ")", ",", "}", ",", "{", "Base", ":", "&", "b2", "[", "0", "]", ",", "Len", ":", "uint64", "(", "len", "(", "b2", ")", ")", ",", "}", ",", "}", "\n", "iovecLen", ":=", "uintptr", "(", "2", ")", "\n\n", "if", "len", "(", "b3", ")", ">", "0", "{", "iovecLen", "++", "\n", "iovec", "[", "2", "]", ".", "Base", "=", "&", "b3", "[", "0", "]", "\n", "iovec", "[", "2", "]", ".", "Len", "=", "uint64", "(", "len", "(", "b3", ")", ")", "\n", "}", "\n\n", "_", ",", "_", ",", "e", ":=", "syscall", ".", "RawSyscall", "(", "syscall", ".", "SYS_WRITEV", ",", "uintptr", "(", "fd", ")", ",", "uintptr", "(", "unsafe", ".", "Pointer", "(", "&", "iovec", "[", "0", "]", ")", ")", ",", "iovecLen", ")", "\n", "if", "e", "!=", "0", "{", "return", "TranslateErrno", "(", "e", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "NonBlockingWrite3", "writes", "up", "to", "three", "byte", "slices", "to", "a", "file", "descriptor", "in", "a", "single", "syscall", ".", "It", "fails", "if", "partial", "data", "is", "written", "." ]

[ "func", "(", "q", "*", "segmentQueue", ")", "empty", "(", ")", "bool", "{", "q", ".", "mu", ".", "Lock", "(", ")", "\n", "r", ":=", "q", ".", "used", "==", "0", "\n", "q", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "return", "r", "\n", "}" ]

[ "empty", "determines", "if", "the", "queue", "is", "empty", "." ]

[ "func", "(", "q", "*", "segmentQueue", ")", "setLimit", "(", "limit", "int", ")", "{", "q", ".", "mu", ".", "Lock", "(", ")", "\n", "q", ".", "limit", "=", "limit", "\n", "q", ".", "mu", ".", "Unlock", "(", ")", "\n", "}" ]

[ "setLimit", "updates", "the", "limit", ".", "No", "segments", "are", "immediately", "dropped", "in", "case", "the", "queue", "becomes", "full", "due", "to", "the", "new", "limit", "." ]

[ "func", "(", "q", "*", "segmentQueue", ")", "enqueue", "(", "s", "*", "segment", ")", "bool", "{", "q", ".", "mu", ".", "Lock", "(", ")", "\n", "r", ":=", "q", ".", "used", "<", "q", ".", "limit", "\n", "if", "r", "{", "q", ".", "list", ".", "PushBack", "(", "s", ")", "\n", "q", ".", "used", "+=", "s", ".", "data", ".", "Size", "(", ")", "+", "header", ".", "TCPMinimumSize", "\n", "}", "\n", "q", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "return", "r", "\n", "}" ]

[ "enqueue", "adds", "the", "given", "segment", "to", "the", "queue", ".", "Returns", "true", "when", "the", "segment", "is", "successfully", "added", "to", "the", "queue", "in", "which", "case", "ownership", "of", "the", "reference", "is", "transferred", "to", "the", "queue", ".", "And", "returns", "false", "if", "the", "queue", "is", "full", "in", "which", "case", "ownership", "is", "retained", "by", "the", "caller", "." ]

[ "func", "(", "q", "*", "segmentQueue", ")", "dequeue", "(", ")", "*", "segment", "{", "q", ".", "mu", ".", "Lock", "(", ")", "\n", "s", ":=", "q", ".", "list", ".", "Front", "(", ")", "\n", "if", "s", "!=", "nil", "{", "q", ".", "list", ".", "Remove", "(", "s", ")", "\n", "q", ".", "used", "-=", "s", ".", "data", ".", "Size", "(", ")", "+", "header", ".", "TCPMinimumSize", "\n", "}", "\n", "q", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "return", "s", "\n", "}" ]

[ "dequeue", "removes", "and", "returns", "the", "next", "segment", "from", "queue", "if", "one", "exists", ".", "Ownership", "is", "transferred", "to", "the", "caller", "who", "is", "responsible", "for", "decrementing", "the", "ref", "count", "when", "done", "." ]

[ "func", "FindWndScale", "(", "wnd", "seqnum", ".", "Size", ")", "int", "{", "if", "wnd", "<", "0x10000", "{", "return", "0", "\n", "}", "\n\n", "max", ":=", "seqnum", ".", "Size", "(", "0xffff", ")", "\n", "s", ":=", "0", "\n", "for", "wnd", ">", "max", "&&", "s", "<", "header", ".", "MaxWndScale", "{", "s", "++", "\n", "max", "<<=", "1", "\n", "}", "\n\n", "return", "s", "\n", "}" ]

[ "FindWndScale", "determines", "the", "window", "scale", "to", "use", "for", "the", "given", "maximum", "window", "size", "." ]

[ "func", "(", "h", "*", "handshake", ")", "resetState", "(", ")", "{", "b", ":=", "make", "(", "[", "]", "byte", ",", "4", ")", "\n", "if", "_", ",", "err", ":=", "rand", ".", "Read", "(", "b", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n\n", "h", ".", "state", "=", "handshakeSynSent", "\n", "h", ".", "flags", "=", "header", ".", "TCPFlagSyn", "\n", "h", ".", "ackNum", "=", "0", "\n", "h", ".", "mss", "=", "0", "\n", "h", ".", "iss", "=", "seqnum", ".", "Value", "(", "uint32", "(", "b", "[", "0", "]", ")", "|", "uint32", "(", "b", "[", "1", "]", ")", "<<", "8", "|", "uint32", "(", "b", "[", "2", "]", ")", "<<", "16", "|", "uint32", "(", "b", "[", "3", "]", ")", "<<", "24", ")", "\n", "}" ]

[ "resetState", "resets", "the", "state", "of", "the", "handshake", "object", "such", "that", "it", "becomes", "ready", "for", "a", "new", "3", "-", "way", "handshake", "." ]

[ "func", "(", "h", "*", "handshake", ")", "resetToSynRcvd", "(", "iss", "seqnum", ".", "Value", ",", "irs", "seqnum", ".", "Value", ",", "opts", "*", "header", ".", "TCPSynOptions", ")", "{", "h", ".", "active", "=", "false", "\n", "h", ".", "state", "=", "handshakeSynRcvd", "\n", "h", ".", "flags", "=", "header", ".", "TCPFlagSyn", "|", "header", ".", "TCPFlagAck", "\n", "h", ".", "iss", "=", "iss", "\n", "h", ".", "ackNum", "=", "irs", "+", "1", "\n", "h", ".", "mss", "=", "opts", ".", "MSS", "\n", "h", ".", "sndWndScale", "=", "opts", ".", "WS", "\n", "}" ]

[ "resetToSynRcvd", "resets", "the", "state", "of", "the", "handshake", "object", "to", "the", "SYN", "-", "RCVD", "state", "." ]

[ "func", "(", "h", "*", "handshake", ")", "checkAck", "(", "s", "*", "segment", ")", "bool", "{", "if", "s", ".", "flagIsSet", "(", "header", ".", "TCPFlagAck", ")", "&&", "s", ".", "ackNumber", "!=", "h", ".", "iss", "+", "1", "{", "// RFC 793, page 36, states that a reset must be generated when", "// the connection is in any non-synchronized state and an", "// incoming segment acknowledges something not yet sent. The", "// connection remains in the same state.", "ack", ":=", "s", ".", "sequenceNumber", ".", "Add", "(", "s", ".", "logicalLen", "(", ")", ")", "\n", "h", ".", "ep", ".", "sendRaw", "(", "buffer", ".", "VectorisedView", "{", "}", ",", "header", ".", "TCPFlagRst", "|", "header", ".", "TCPFlagAck", ",", "s", ".", "ackNumber", ",", "ack", ",", "0", ")", "\n", "return", "false", "\n", "}", "\n\n", "return", "true", "\n", "}" ]

[ "checkAck", "checks", "if", "the", "ACK", "number", "if", "present", "of", "a", "segment", "received", "during", "a", "TCP", "3", "-", "way", "handshake", "is", "valid", ".", "If", "it", "s", "not", "a", "RST", "segment", "is", "sent", "back", "in", "response", "." ]

[ "func", "(", "h", "*", "handshake", ")", "synSentState", "(", "s", "*", "segment", ")", "*", "tcpip", ".", "Error", "{", "// RFC 793, page 37, states that in the SYN-SENT state, a reset is", "// acceptable if the ack field acknowledges the SYN.", "if", "s", ".", "flagIsSet", "(", "header", ".", "TCPFlagRst", ")", "{", "if", "s", ".", "flagIsSet", "(", "header", ".", "TCPFlagAck", ")", "&&", "s", ".", "ackNumber", "==", "h", ".", "iss", "+", "1", "{", "return", "tcpip", ".", "ErrConnectionRefused", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "if", "!", "h", ".", "checkAck", "(", "s", ")", "{", "return", "nil", "\n", "}", "\n\n", "// We are in the SYN-SENT state. We only care about segments that have", "// the SYN flag.", "if", "!", "s", ".", "flagIsSet", "(", "header", ".", "TCPFlagSyn", ")", "{", "return", "nil", "\n", "}", "\n\n", "// Parse the SYN options.", "rcvSynOpts", ":=", "parseSynSegmentOptions", "(", "s", ")", "\n\n", "// Remember if the Timestamp option was negotiated.", "h", ".", "ep", ".", "maybeEnableTimestamp", "(", "&", "rcvSynOpts", ")", "\n\n", "// Remember if the SACKPermitted option was negotiated.", "h", ".", "ep", ".", "maybeEnableSACKPermitted", "(", "&", "rcvSynOpts", ")", "\n\n", "// Remember the sequence we'll ack from now on.", "h", ".", "ackNum", "=", "s", ".", "sequenceNumber", "+", "1", "\n", "h", ".", "flags", "|=", "header", ".", "TCPFlagAck", "\n", "h", ".", "mss", "=", "rcvSynOpts", ".", "MSS", "\n", "h", ".", "sndWndScale", "=", "rcvSynOpts", ".", "WS", "\n\n", "// If this is a SYN ACK response, we only need to acknowledge the SYN", "// and the handshake is completed.", "if", "s", ".", "flagIsSet", "(", "header", ".", "TCPFlagAck", ")", "{", "h", ".", "state", "=", "handshakeCompleted", "\n", "h", ".", "ep", ".", "sendRaw", "(", "buffer", ".", "VectorisedView", "{", "}", ",", "header", ".", "TCPFlagAck", ",", "h", ".", "iss", "+", "1", ",", "h", ".", "ackNum", ",", "h", ".", "rcvWnd", ">>", "h", ".", "effectiveRcvWndScale", "(", ")", ")", "\n", "return", "nil", "\n", "}", "\n\n", "// A SYN segment was received, but no ACK in it. We acknowledge the SYN", "// but resend our own SYN and wait for it to be acknowledged in the", "// SYN-RCVD state.", "h", ".", "state", "=", "handshakeSynRcvd", "\n", "synOpts", ":=", "header", ".", "TCPSynOptions", "{", "WS", ":", "h", ".", "rcvWndScale", ",", "TS", ":", "rcvSynOpts", ".", "TS", ",", "TSVal", ":", "h", ".", "ep", ".", "timestamp", "(", ")", ",", "TSEcr", ":", "h", ".", "ep", ".", "recentTS", ",", "// We only send SACKPermitted if the other side indicated it", "// permits SACK. This is not explicitly defined in the RFC but", "// this is the behaviour implemented by Linux.", "SACKPermitted", ":", "rcvSynOpts", ".", "SACKPermitted", ",", "}", "\n", "sendSynTCP", "(", "&", "s", ".", "route", ",", "h", ".", "ep", ".", "id", ",", "h", ".", "flags", ",", "h", ".", "iss", ",", "h", ".", "ackNum", ",", "h", ".", "rcvWnd", ",", "synOpts", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "synSentState", "handles", "a", "segment", "received", "when", "the", "TCP", "3", "-", "way", "handshake", "is", "in", "the", "SYN", "-", "SENT", "state", "." ]

[ "func", "(", "h", "*", "handshake", ")", "synRcvdState", "(", "s", "*", "segment", ")", "*", "tcpip", ".", "Error", "{", "if", "s", ".", "flagIsSet", "(", "header", ".", "TCPFlagRst", ")", "{", "// RFC 793, page 37, states that in the SYN-RCVD state, a reset", "// is acceptable if the sequence number is in the window.", "if", "s", ".", "sequenceNumber", ".", "InWindow", "(", "h", ".", "ackNum", ",", "h", ".", "rcvWnd", ")", "{", "return", "tcpip", ".", "ErrConnectionRefused", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "if", "!", "h", ".", "checkAck", "(", "s", ")", "{", "return", "nil", "\n", "}", "\n\n", "if", "s", ".", "flagIsSet", "(", "header", ".", "TCPFlagSyn", ")", "&&", "s", ".", "sequenceNumber", "!=", "h", ".", "ackNum", "-", "1", "{", "// We received two SYN segments with different sequence", "// numbers, so we reset this and restart the whole", "// process, except that we don't reset the timer.", "ack", ":=", "s", ".", "sequenceNumber", ".", "Add", "(", "s", ".", "logicalLen", "(", ")", ")", "\n", "seq", ":=", "seqnum", ".", "Value", "(", "0", ")", "\n", "if", "s", ".", "flagIsSet", "(", "header", ".", "TCPFlagAck", ")", "{", "seq", "=", "s", ".", "ackNumber", "\n", "}", "\n", "h", ".", "ep", ".", "sendRaw", "(", "buffer", ".", "VectorisedView", "{", "}", ",", "header", ".", "TCPFlagRst", "|", "header", ".", "TCPFlagAck", ",", "seq", ",", "ack", ",", "0", ")", "\n\n", "if", "!", "h", ".", "active", "{", "return", "tcpip", ".", "ErrInvalidEndpointState", "\n", "}", "\n\n", "h", ".", "resetState", "(", ")", "\n", "synOpts", ":=", "header", ".", "TCPSynOptions", "{", "WS", ":", "h", ".", "rcvWndScale", ",", "TS", ":", "h", ".", "ep", ".", "sendTSOk", ",", "TSVal", ":", "h", ".", "ep", ".", "timestamp", "(", ")", ",", "TSEcr", ":", "h", ".", "ep", ".", "recentTS", ",", "SACKPermitted", ":", "h", ".", "ep", ".", "sackPermitted", ",", "}", "\n", "sendSynTCP", "(", "&", "s", ".", "route", ",", "h", ".", "ep", ".", "id", ",", "h", ".", "flags", ",", "h", ".", "iss", ",", "h", ".", "ackNum", ",", "h", ".", "rcvWnd", ",", "synOpts", ")", "\n", "return", "nil", "\n", "}", "\n\n", "// We have previously received (and acknowledged) the peer's SYN. If the", "// peer acknowledges our SYN, the handshake is completed.", "if", "s", ".", "flagIsSet", "(", "header", ".", "TCPFlagAck", ")", "{", "// If the timestamp option is negotiated and the segment does", "// not carry a timestamp option then the segment must be dropped", "// as per https://tools.ietf.org/html/rfc7323#section-3.2.", "if", "h", ".", "ep", ".", "sendTSOk", "&&", "!", "s", ".", "parsedOptions", ".", "TS", "{", "h", ".", "ep", ".", "stack", ".", "Stats", "(", ")", ".", "DroppedPackets", ".", "Increment", "(", ")", "\n", "return", "nil", "\n", "}", "\n\n", "// Update timestamp if required. See RFC7323, section-4.3.", "if", "h", ".", "ep", ".", "sendTSOk", "&&", "s", ".", "parsedOptions", ".", "TS", "{", "h", ".", "ep", ".", "updateRecentTimestamp", "(", "s", ".", "parsedOptions", ".", "TSVal", ",", "h", ".", "ackNum", ",", "s", ".", "sequenceNumber", ")", "\n", "}", "\n", "h", ".", "state", "=", "handshakeCompleted", "\n", "return", "nil", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "synRcvdState", "handles", "a", "segment", "received", "when", "the", "TCP", "3", "-", "way", "handshake", "is", "in", "the", "SYN", "-", "RCVD", "state", "." ]

[ "func", "sendTCP", "(", "r", "*", "stack", ".", "Route", ",", "id", "stack", ".", "TransportEndpointID", ",", "data", "buffer", ".", "VectorisedView", ",", "ttl", "uint8", ",", "flags", "byte", ",", "seq", ",", "ack", "seqnum", ".", "Value", ",", "rcvWnd", "seqnum", ".", "Size", ",", "opts", "[", "]", "byte", ",", "gso", "*", "stack", ".", "GSO", ")", "*", "tcpip", ".", "Error", "{", "optLen", ":=", "len", "(", "opts", ")", "\n", "// Allocate a buffer for the TCP header.", "hdr", ":=", "buffer", ".", "NewPrependable", "(", "header", ".", "TCPMinimumSize", "+", "int", "(", "r", ".", "MaxHeaderLength", "(", ")", ")", "+", "optLen", ")", "\n\n", "if", "rcvWnd", ">", "0xffff", "{", "rcvWnd", "=", "0xffff", "\n", "}", "\n\n", "// Initialize the header.", "tcp", ":=", "header", ".", "TCP", "(", "hdr", ".", "Prepend", "(", "header", ".", "TCPMinimumSize", "+", "optLen", ")", ")", "\n", "tcp", ".", "Encode", "(", "&", "header", ".", "TCPFields", "{", "SrcPort", ":", "id", ".", "LocalPort", ",", "DstPort", ":", "id", ".", "RemotePort", ",", "SeqNum", ":", "uint32", "(", "seq", ")", ",", "AckNum", ":", "uint32", "(", "ack", ")", ",", "DataOffset", ":", "uint8", "(", "header", ".", "TCPMinimumSize", "+", "optLen", ")", ",", "Flags", ":", "flags", ",", "WindowSize", ":", "uint16", "(", "rcvWnd", ")", ",", "}", ")", "\n", "copy", "(", "tcp", "[", "header", ".", "TCPMinimumSize", ":", "]", ",", "opts", ")", "\n\n", "length", ":=", "uint16", "(", "hdr", ".", "UsedLength", "(", ")", "+", "data", ".", "Size", "(", ")", ")", "\n", "xsum", ":=", "r", ".", "PseudoHeaderChecksum", "(", "ProtocolNumber", ",", "length", ")", "\n", "// Only calculate the checksum if offloading isn't supported.", "if", "gso", "!=", "nil", "&&", "gso", ".", "NeedsCsum", "{", "// This is called CHECKSUM_PARTIAL in the Linux kernel. We", "// calculate a checksum of the pseudo-header and save it in the", "// TCP header, then the kernel calculate a checksum of the", "// header and data and get the right sum of the TCP packet.", "tcp", ".", "SetChecksum", "(", "xsum", ")", "\n", "}", "else", "if", "r", ".", "Capabilities", "(", ")", "&", "stack", ".", "CapabilityTXChecksumOffload", "==", "0", "{", "xsum", "=", "header", ".", "ChecksumVV", "(", "data", ",", "xsum", ")", "\n", "tcp", ".", "SetChecksum", "(", "^", "tcp", ".", "CalculateChecksum", "(", "xsum", ")", ")", "\n", "}", "\n\n", "r", ".", "Stats", "(", ")", ".", "TCP", ".", "SegmentsSent", ".", "Increment", "(", ")", "\n", "if", "(", "flags", "&", "header", ".", "TCPFlagRst", ")", "!=", "0", "{", "r", ".", "Stats", "(", ")", ".", "TCP", ".", "ResetsSent", ".", "Increment", "(", ")", "\n", "}", "\n\n", "return", "r", ".", "WritePacket", "(", "gso", ",", "hdr", ",", "data", ",", "ProtocolNumber", ",", "ttl", ")", "\n", "}" ]

[ "sendTCP", "sends", "a", "TCP", "segment", "with", "the", "provided", "options", "via", "the", "provided", "network", "endpoint", "and", "under", "the", "provided", "identity", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "makeOptions", "(", "sackBlocks", "[", "]", "header", ".", "SACKBlock", ")", "[", "]", "byte", "{", "options", ":=", "getOptions", "(", ")", "\n", "offset", ":=", "0", "\n\n", "// N.B. the ordering here matches the ordering used by Linux internally", "// and described in the raw makeOptions function. We don't include", "// unnecessary cases here (post connection.)", "if", "e", ".", "sendTSOk", "{", "// Embed the timestamp if timestamp has been enabled.", "//", "// We only use the lower 32 bits of the unix time in", "// milliseconds. This is similar to what Linux does where it", "// uses the lower 32 bits of the jiffies value in the tsVal", "// field of the timestamp option.", "//", "// Further, RFC7323 section-5.4 recommends millisecond", "// resolution as the lowest recommended resolution for the", "// timestamp clock.", "//", "// Ref: https://tools.ietf.org/html/rfc7323#section-5.4.", "offset", "+=", "header", ".", "EncodeNOP", "(", "options", "[", "offset", ":", "]", ")", "\n", "offset", "+=", "header", ".", "EncodeNOP", "(", "options", "[", "offset", ":", "]", ")", "\n", "offset", "+=", "header", ".", "EncodeTSOption", "(", "e", ".", "timestamp", "(", ")", ",", "uint32", "(", "e", ".", "recentTS", ")", ",", "options", "[", "offset", ":", "]", ")", "\n", "}", "\n", "if", "e", ".", "sackPermitted", "&&", "len", "(", "sackBlocks", ")", ">", "0", "{", "offset", "+=", "header", ".", "EncodeNOP", "(", "options", "[", "offset", ":", "]", ")", "\n", "offset", "+=", "header", ".", "EncodeNOP", "(", "options", "[", "offset", ":", "]", ")", "\n", "offset", "+=", "header", ".", "EncodeSACKBlocks", "(", "sackBlocks", ",", "options", "[", "offset", ":", "]", ")", "\n", "}", "\n\n", "// We expect the above to produce an aligned offset.", "if", "delta", ":=", "header", ".", "AddTCPOptionPadding", "(", "options", ",", "offset", ")", ";", "delta", "!=", "0", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "options", "[", ":", "offset", "]", "\n", "}" ]

[ "makeOptions", "makes", "an", "options", "slice", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "sendRaw", "(", "data", "buffer", ".", "VectorisedView", ",", "flags", "byte", ",", "seq", ",", "ack", "seqnum", ".", "Value", ",", "rcvWnd", "seqnum", ".", "Size", ")", "*", "tcpip", ".", "Error", "{", "var", "sackBlocks", "[", "]", "header", ".", "SACKBlock", "\n", "if", "e", ".", "state", "==", "stateConnected", "&&", "e", ".", "rcv", ".", "pendingBufSize", ">", "0", "&&", "(", "flags", "&", "header", ".", "TCPFlagAck", "!=", "0", ")", "{", "sackBlocks", "=", "e", ".", "sack", ".", "Blocks", "[", ":", "e", ".", "sack", ".", "NumBlocks", "]", "\n", "}", "\n", "options", ":=", "e", ".", "makeOptions", "(", "sackBlocks", ")", "\n", "err", ":=", "sendTCP", "(", "&", "e", ".", "route", ",", "e", ".", "id", ",", "data", ",", "e", ".", "route", ".", "DefaultTTL", "(", ")", ",", "flags", ",", "seq", ",", "ack", ",", "rcvWnd", ",", "options", ",", "e", ".", "gso", ")", "\n", "putOptions", "(", "options", ")", "\n", "return", "err", "\n", "}" ]

[ "sendRaw", "sends", "a", "TCP", "segment", "to", "the", "endpoint", "s", "peer", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "resetConnectionLocked", "(", "err", "*", "tcpip", ".", "Error", ")", "{", "e", ".", "sendRaw", "(", "buffer", ".", "VectorisedView", "{", "}", ",", "header", ".", "TCPFlagAck", "|", "header", ".", "TCPFlagRst", ",", "e", ".", "snd", ".", "sndUna", ",", "e", ".", "rcv", ".", "rcvNxt", ",", "0", ")", "\n\n", "e", ".", "state", "=", "stateError", "\n", "e", ".", "hardError", "=", "err", "\n", "}" ]

[ "resetConnectionLocked", "sends", "a", "RST", "segment", "and", "puts", "the", "endpoint", "in", "an", "error", "state", "with", "the", "given", "error", "code", ".", "This", "method", "must", "only", "be", "called", "from", "the", "protocol", "goroutine", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "handleSegments", "(", ")", "*", "tcpip", ".", "Error", "{", "checkRequeue", ":=", "true", "\n", "for", "i", ":=", "0", ";", "i", "<", "maxSegmentsPerWake", ";", "i", "++", "{", "s", ":=", "e", ".", "segmentQueue", ".", "dequeue", "(", ")", "\n", "if", "s", "==", "nil", "{", "checkRequeue", "=", "false", "\n", "break", "\n", "}", "\n\n", "// Invoke the tcp probe if installed.", "if", "e", ".", "probe", "!=", "nil", "{", "e", ".", "probe", "(", "e", ".", "completeState", "(", ")", ")", "\n", "}", "\n\n", "if", "s", ".", "flagIsSet", "(", "header", ".", "TCPFlagRst", ")", "{", "if", "e", ".", "rcv", ".", "acceptable", "(", "s", ".", "sequenceNumber", ",", "0", ")", "{", "// RFC 793, page 37 states that \"in all states", "// except SYN-SENT, all reset (RST) segments are", "// validated by checking their SEQ-fields.\" So", "// we only process it if it's acceptable.", "s", ".", "decRef", "(", ")", "\n", "return", "tcpip", ".", "ErrConnectionReset", "\n", "}", "\n", "}", "else", "if", "s", ".", "flagIsSet", "(", "header", ".", "TCPFlagAck", ")", "{", "// Patch the window size in the segment according to the", "// send window scale.", "s", ".", "window", "<<=", "e", ".", "snd", ".", "sndWndScale", "\n\n", "// RFC 793, page 41 states that \"once in the ESTABLISHED", "// state all segments must carry current acknowledgment", "// information.\"", "e", ".", "rcv", ".", "handleRcvdSegment", "(", "s", ")", "\n", "e", ".", "snd", ".", "handleRcvdSegment", "(", "s", ")", "\n", "}", "\n", "s", ".", "decRef", "(", ")", "\n", "}", "\n\n", "// If the queue is not empty, make sure we'll wake up in the next", "// iteration.", "if", "checkRequeue", "&&", "!", "e", ".", "segmentQueue", ".", "empty", "(", ")", "{", "e", ".", "newSegmentWaker", ".", "Assert", "(", ")", "\n", "}", "\n\n", "// Send an ACK for all processed packets if needed.", "if", "e", ".", "rcv", ".", "rcvNxt", "!=", "e", ".", "snd", ".", "maxSentAck", "{", "e", ".", "snd", ".", "sendAck", "(", ")", "\n", "}", "\n\n", "e", ".", "resetKeepaliveTimer", "(", "true", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "handleSegments", "pulls", "segments", "from", "the", "queue", "and", "processes", "them", ".", "It", "returns", "no", "error", "if", "the", "protocol", "loop", "should", "continue", "an", "error", "otherwise", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "keepaliveTimerExpired", "(", ")", "*", "tcpip", ".", "Error", "{", "e", ".", "keepalive", ".", "Lock", "(", ")", "\n", "if", "!", "e", ".", "keepalive", ".", "enabled", "||", "!", "e", ".", "keepalive", ".", "timer", ".", "checkExpiration", "(", ")", "{", "e", ".", "keepalive", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n", "}", "\n\n", "if", "e", ".", "keepalive", ".", "unacked", ">=", "e", ".", "keepalive", ".", "count", "{", "e", ".", "keepalive", ".", "Unlock", "(", ")", "\n", "return", "tcpip", ".", "ErrConnectionReset", "\n", "}", "\n\n", "// RFC1122 4.2.3.6: TCP keepalive is a dataless ACK with", "// seg.seq = snd.nxt-1.", "e", ".", "keepalive", ".", "unacked", "++", "\n", "e", ".", "keepalive", ".", "Unlock", "(", ")", "\n", "e", ".", "snd", ".", "sendSegment", "(", "buffer", ".", "VectorisedView", "{", "}", ",", "header", ".", "TCPFlagAck", ",", "e", ".", "snd", ".", "sndNxt", "-", "1", ")", "\n", "e", ".", "resetKeepaliveTimer", "(", "false", ")", "\n", "return", "nil", "\n", "}" ]

[ "keepaliveTimerExpired", "is", "called", "when", "the", "keepaliveTimer", "fires", ".", "We", "send", "TCP", "keepalive", "packets", "periodically", "when", "the", "connection", "is", "idle", ".", "If", "we", "don", "t", "hear", "from", "the", "other", "side", "after", "a", "number", "of", "tries", "we", "terminate", "the", "connection", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "resetKeepaliveTimer", "(", "receivedData", "bool", ")", "{", "e", ".", "keepalive", ".", "Lock", "(", ")", "\n", "defer", "e", ".", "keepalive", ".", "Unlock", "(", ")", "\n", "if", "receivedData", "{", "e", ".", "keepalive", ".", "unacked", "=", "0", "\n", "}", "\n", "// Start the keepalive timer IFF it's enabled and there is no pending", "// data to send.", "if", "!", "e", ".", "keepalive", ".", "enabled", "||", "e", ".", "snd", "==", "nil", "||", "e", ".", "snd", ".", "sndUna", "!=", "e", ".", "snd", ".", "sndNxt", "{", "e", ".", "keepalive", ".", "timer", ".", "disable", "(", ")", "\n", "return", "\n", "}", "\n", "if", "e", ".", "keepalive", ".", "unacked", ">", "0", "{", "e", ".", "keepalive", ".", "timer", ".", "enable", "(", "e", ".", "keepalive", ".", "interval", ")", "\n", "}", "else", "{", "e", ".", "keepalive", ".", "timer", ".", "enable", "(", "e", ".", "keepalive", ".", "idle", ")", "\n", "}", "\n", "}" ]

[ "resetKeepaliveTimer", "restarts", "or", "stops", "the", "keepalive", "timer", "depending", "on", "whether", "it", "is", "enabled", "for", "this", "endpoint", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "disableKeepaliveTimer", "(", ")", "{", "e", ".", "keepalive", ".", "Lock", "(", ")", "\n", "e", ".", "keepalive", ".", "timer", ".", "disable", "(", ")", "\n", "e", ".", "keepalive", ".", "Unlock", "(", ")", "\n", "}" ]

[ "disableKeepaliveTimer", "stops", "the", "keepalive", "timer", "." ]

[ "func", "(", "b", "IPv6Fragment", ")", "Encode", "(", "i", "*", "IPv6FragmentFields", ")", "{", "b", "[", "nextHdrFrag", "]", "=", "i", ".", "NextHeader", "\n", "binary", ".", "BigEndian", ".", "PutUint16", "(", "b", "[", "fragOff", ":", "]", ",", "i", ".", "FragmentOffset", "<<", "3", ")", "\n", "if", "i", ".", "M", "{", "b", "[", "more", "]", "|=", "1", "\n", "}", "\n", "binary", ".", "BigEndian", ".", "PutUint32", "(", "b", "[", "idV6", ":", "]", ",", "i", ".", "Identification", ")", "\n", "}" ]

[ "Encode", "encodes", "all", "the", "fields", "of", "the", "ipv6", "fragment", "." ]

[ "func", "(", "t", "tPacketHdr", ")", "tpStatus", "(", ")", "uint32", "{", "hdr", ":=", "unsafe", ".", "Pointer", "(", "&", "t", "[", "0", "]", ")", "\n", "statusPtr", ":=", "unsafe", ".", "Pointer", "(", "uintptr", "(", "hdr", ")", "+", "uintptr", "(", "tpStatusOffset", ")", ")", "\n", "return", "atomic", ".", "LoadUint32", "(", "(", "*", "uint32", ")", "(", "statusPtr", ")", ")", "\n", "}" ]

[ "tpStatus", "returns", "the", "frame", "status", "field", ".", "The", "status", "is", "concurrently", "updated", "by", "the", "kernel", "as", "a", "result", "we", "must", "use", "atomic", "operations", "to", "prevent", "races", "." ]

[ "func", "(", "t", "tPacketHdr", ")", "setTPStatus", "(", "status", "uint32", ")", "{", "hdr", ":=", "unsafe", ".", "Pointer", "(", "&", "t", "[", "0", "]", ")", "\n", "statusPtr", ":=", "unsafe", ".", "Pointer", "(", "uintptr", "(", "hdr", ")", "+", "uintptr", "(", "tpStatusOffset", ")", ")", "\n", "atomic", ".", "StoreUint32", "(", "(", "*", "uint32", ")", "(", "statusPtr", ")", ",", "status", ")", "\n", "}" ]

[ "setTPStatus", "set", "s", "the", "frame", "status", "to", "the", "provided", "status", ".", "The", "status", "is", "concurrently", "updated", "by", "the", "kernel", "as", "a", "result", "we", "must", "use", "atomic", "operations", "to", "prevent", "races", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "packetMMapDispatch", "(", ")", "(", "bool", ",", "*", "tcpip", ".", "Error", ")", "{", "pkt", ",", "err", ":=", "e", ".", "readMMappedPacket", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "var", "(", "p", "tcpip", ".", "NetworkProtocolNumber", "\n", "remote", ",", "local", "tcpip", ".", "LinkAddress", "\n", ")", "\n", "if", "e", ".", "hdrSize", ">", "0", "{", "eth", ":=", "header", ".", "Ethernet", "(", "pkt", ")", "\n", "p", "=", "eth", ".", "Type", "(", ")", "\n", "remote", "=", "eth", ".", "SourceAddress", "(", ")", "\n", "local", "=", "eth", ".", "DestinationAddress", "(", ")", "\n", "}", "else", "{", "// We don't get any indication of what the packet is, so try to guess", "// if it's an IPv4 or IPv6 packet.", "switch", "header", ".", "IPVersion", "(", "pkt", ")", "{", "case", "header", ".", "IPv4Version", ":", "p", "=", "header", ".", "IPv4ProtocolNumber", "\n", "case", "header", ".", "IPv6Version", ":", "p", "=", "header", ".", "IPv6ProtocolNumber", "\n", "default", ":", "return", "true", ",", "nil", "\n", "}", "\n", "}", "\n\n", "pkt", "=", "pkt", "[", "e", ".", "hdrSize", ":", "]", "\n", "e", ".", "dispatcher", ".", "DeliverNetworkPacket", "(", "e", ",", "remote", ",", "local", ",", "p", ",", "buffer", ".", "NewVectorisedView", "(", "len", "(", "pkt", ")", ",", "[", "]", "buffer", ".", "View", "{", "buffer", ".", "View", "(", "pkt", ")", "}", ")", ")", "\n", "return", "true", ",", "nil", "\n", "}" ]

[ "packetMMapDispatch", "reads", "packets", "from", "an", "mmaped", "ring", "buffer", "and", "dispatches", "them", "to", "the", "network", "stack", "." ]

[ "func", "ChecksumCombine", "(", "a", ",", "b", "uint16", ")", "uint16", "{", "v", ":=", "uint32", "(", "a", ")", "+", "uint32", "(", "b", ")", "\n", "return", "uint16", "(", "v", "+", "v", ">>", "16", ")", "\n", "}" ]

[ "ChecksumCombine", "combines", "the", "two", "uint16", "to", "form", "their", "checksum", ".", "This", "is", "done", "by", "adding", "them", "and", "the", "carry", ".", "Note", "that", "checksum", "a", "must", "have", "been", "computed", "on", "an", "even", "number", "of", "bytes", "." ]

[ "func", "PseudoHeaderChecksum", "(", "protocol", "tcpip", ".", "TransportProtocolNumber", ",", "srcAddr", "tcpip", ".", "Address", ",", "dstAddr", "tcpip", ".", "Address", ",", "totalLen", "uint16", ")", "uint16", "{", "xsum", ":=", "Checksum", "(", "[", "]", "byte", "(", "srcAddr", ")", ",", "0", ")", "\n", "xsum", "=", "Checksum", "(", "[", "]", "byte", "(", "dstAddr", ")", ",", "xsum", ")", "\n\n", "// Add the length portion of the checksum to the pseudo-checksum.", "tmp", ":=", "make", "(", "[", "]", "byte", ",", "2", ")", "\n", "binary", ".", "BigEndian", ".", "PutUint16", "(", "tmp", ",", "totalLen", ")", "\n", "xsum", "=", "Checksum", "(", "tmp", ",", "xsum", ")", "\n\n", "return", "Checksum", "(", "[", "]", "byte", "{", "0", ",", "uint8", "(", "protocol", ")", "}", ",", "xsum", ")", "\n", "}" ]

[ "PseudoHeaderChecksum", "calculates", "the", "pseudo", "-", "header", "checksum", "for", "the", "given", "destination", "protocol", "and", "network", "address", ".", "Pseudo", "-", "headers", "are", "needed", "by", "transport", "layers", "when", "calculating", "their", "own", "checksum", "." ]

[ "func", "(", "r", "*", "Rx", ")", "PostBuffers", "(", "buffers", "[", "]", "RxBuffer", ")", "bool", "{", "for", "i", ":=", "range", "buffers", "{", "b", ":=", "r", ".", "tx", ".", "Push", "(", "sizeOfPostedBuffer", ")", "\n", "if", "b", "==", "nil", "{", "r", ".", "tx", ".", "Abort", "(", ")", "\n", "return", "false", "\n", "}", "\n\n", "pb", ":=", "&", "buffers", "[", "i", "]", "\n", "binary", ".", "LittleEndian", ".", "PutUint64", "(", "b", "[", "postedOffset", ":", "]", ",", "pb", ".", "Offset", ")", "\n", "binary", ".", "LittleEndian", ".", "PutUint32", "(", "b", "[", "postedSize", ":", "]", ",", "pb", ".", "Size", ")", "\n", "binary", ".", "LittleEndian", ".", "PutUint32", "(", "b", "[", "postedRemainingInGroup", ":", "]", ",", "0", ")", "\n", "binary", ".", "LittleEndian", ".", "PutUint64", "(", "b", "[", "postedUserData", ":", "]", ",", "pb", ".", "UserData", ")", "\n", "binary", ".", "LittleEndian", ".", "PutUint64", "(", "b", "[", "postedID", ":", "]", ",", "pb", ".", "ID", ")", "\n", "}", "\n\n", "r", ".", "tx", ".", "Flush", "(", ")", "\n\n", "return", "true", "\n", "}" ]

[ "PostBuffers", "makes", "the", "given", "buffers", "available", "for", "receiving", "data", "from", "the", "peer", ".", "Once", "they", "are", "posted", "the", "peer", "is", "free", "to", "write", "to", "them", "and", "will", "eventually", "post", "them", "back", "for", "consumption", "." ]

[ "func", "DecodeRxBufferHeader", "(", "b", "[", "]", "byte", ")", "RxBuffer", "{", "return", "RxBuffer", "{", "Offset", ":", "binary", ".", "LittleEndian", ".", "Uint64", "(", "b", "[", "postedOffset", ":", "]", ")", ",", "Size", ":", "binary", ".", "LittleEndian", ".", "Uint32", "(", "b", "[", "postedSize", ":", "]", ")", ",", "ID", ":", "binary", ".", "LittleEndian", ".", "Uint64", "(", "b", "[", "postedID", ":", "]", ")", ",", "UserData", ":", "binary", ".", "LittleEndian", ".", "Uint64", "(", "b", "[", "postedUserData", ":", "]", ")", ",", "}", "\n", "}" ]

[ "DecodeRxBufferHeader", "decodes", "the", "header", "of", "a", "buffer", "posted", "on", "an", "rx", "queue", "." ]

[ "func", "EncodeRxCompletion", "(", "b", "[", "]", "byte", ",", "size", ",", "reserved", "uint32", ")", "{", "binary", ".", "LittleEndian", ".", "PutUint32", "(", "b", "[", "consumedPacketSize", ":", "]", ",", "size", ")", "\n", "binary", ".", "LittleEndian", ".", "PutUint32", "(", "b", "[", "consumedPacketReserved", ":", "]", ",", "reserved", ")", "\n", "}" ]

[ "EncodeRxCompletion", "encodes", "an", "rx", "completion", "header", "." ]

[ "func", "EncodeRxCompletionBuffer", "(", "b", "[", "]", "byte", ",", "i", "int", ",", "rxb", "RxBuffer", ")", "{", "b", "=", "b", "[", "RxCompletionSize", "(", "i", ")", ":", "]", "\n", "binary", ".", "LittleEndian", ".", "PutUint64", "(", "b", "[", "consumedOffset", ":", "]", ",", "rxb", ".", "Offset", ")", "\n", "binary", ".", "LittleEndian", ".", "PutUint32", "(", "b", "[", "consumedSize", ":", "]", ",", "rxb", ".", "Size", ")", "\n", "binary", ".", "LittleEndian", ".", "PutUint64", "(", "b", "[", "consumedUserData", ":", "]", ",", "rxb", ".", "UserData", ")", "\n", "binary", ".", "LittleEndian", ".", "PutUint64", "(", "b", "[", "consumedID", ":", "]", ",", "rxb", ".", "ID", ")", "\n", "}" ]

[ "EncodeRxCompletionBuffer", "encodes", "the", "i", "-", "th", "rx", "completion", "buffer", "header", "." ]

[ "func", "(", "*", "protocol", ")", "NewEndpoint", "(", "stack", "*", "stack", ".", "Stack", ",", "netProto", "tcpip", ".", "NetworkProtocolNumber", ",", "waiterQueue", "*", "waiter", ".", "Queue", ")", "(", "tcpip", ".", "Endpoint", ",", "*", "tcpip", ".", "Error", ")", "{", "return", "newEndpoint", "(", "stack", ",", "netProto", ",", "waiterQueue", ")", ",", "nil", "\n", "}" ]

[ "NewEndpoint", "creates", "a", "new", "tcp", "endpoint", "." ]

[ "func", "(", "p", "*", "protocol", ")", "NewRawEndpoint", "(", "stack", "*", "stack", ".", "Stack", ",", "netProto", "tcpip", ".", "NetworkProtocolNumber", ",", "waiterQueue", "*", "waiter", ".", "Queue", ")", "(", "tcpip", ".", "Endpoint", ",", "*", "tcpip", ".", "Error", ")", "{", "return", "nil", ",", "tcpip", ".", "ErrUnknownProtocol", "\n", "}" ]

[ "NewRawEndpoint", "creates", "a", "new", "raw", "TCP", "endpoint", ".", "Raw", "TCP", "sockets", "are", "currently", "unsupported", ".", "It", "implements", "stack", ".", "TransportProtocol", ".", "NewRawEndpoint", "." ]

[ "func", "replyWithReset", "(", "s", "*", "segment", ")", "{", "// Get the seqnum from the packet if the ack flag is set.", "seq", ":=", "seqnum", ".", "Value", "(", "0", ")", "\n", "if", "s", ".", "flagIsSet", "(", "header", ".", "TCPFlagAck", ")", "{", "seq", "=", "s", ".", "ackNumber", "\n", "}", "\n\n", "ack", ":=", "s", ".", "sequenceNumber", ".", "Add", "(", "s", ".", "logicalLen", "(", ")", ")", "\n\n", "sendTCP", "(", "&", "s", ".", "route", ",", "s", ".", "id", ",", "buffer", ".", "VectorisedView", "{", "}", ",", "s", ".", "route", ".", "DefaultTTL", "(", ")", ",", "header", ".", "TCPFlagRst", "|", "header", ".", "TCPFlagAck", ",", "seq", ",", "ack", ",", "0", ",", "nil", "/* options */", ",", "nil", "/* gso */", ")", "\n", "}" ]

[ "replyWithReset", "replies", "to", "the", "given", "segment", "with", "a", "reset", "segment", "." ]

[ "func", "(", "p", "*", "protocol", ")", "SetOption", "(", "option", "interface", "{", "}", ")", "*", "tcpip", ".", "Error", "{", "switch", "v", ":=", "option", ".", "(", "type", ")", "{", "case", "SACKEnabled", ":", "p", ".", "mu", ".", "Lock", "(", ")", "\n", "p", ".", "sackEnabled", "=", "bool", "(", "v", ")", "\n", "p", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n\n", "case", "SendBufferSizeOption", ":", "if", "v", ".", "Min", "<=", "0", "||", "v", ".", "Default", "<", "v", ".", "Min", "||", "v", ".", "Default", ">", "v", ".", "Max", "{", "return", "tcpip", ".", "ErrInvalidOptionValue", "\n", "}", "\n", "p", ".", "mu", ".", "Lock", "(", ")", "\n", "p", ".", "sendBufferSize", "=", "v", "\n", "p", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n\n", "case", "ReceiveBufferSizeOption", ":", "if", "v", ".", "Min", "<=", "0", "||", "v", ".", "Default", "<", "v", ".", "Min", "||", "v", ".", "Default", ">", "v", ".", "Max", "{", "return", "tcpip", ".", "ErrInvalidOptionValue", "\n", "}", "\n", "p", ".", "mu", ".", "Lock", "(", ")", "\n", "p", ".", "recvBufferSize", "=", "v", "\n", "p", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n\n", "case", "CongestionControlOption", ":", "for", "_", ",", "c", ":=", "range", "p", ".", "availableCongestionControl", "{", "if", "string", "(", "v", ")", "==", "c", "{", "p", ".", "mu", ".", "Lock", "(", ")", "\n", "p", ".", "congestionControl", "=", "string", "(", "v", ")", "\n", "p", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n", "}", "\n", "}", "\n", "return", "tcpip", ".", "ErrInvalidOptionValue", "\n", "default", ":", "return", "tcpip", ".", "ErrUnknownProtocolOption", "\n", "}", "\n", "}" ]

[ "SetOption", "implements", "TransportProtocol", ".", "SetOption", "." ]

[ "func", "(", "p", "*", "protocol", ")", "Option", "(", "option", "interface", "{", "}", ")", "*", "tcpip", ".", "Error", "{", "switch", "v", ":=", "option", ".", "(", "type", ")", "{", "case", "*", "SACKEnabled", ":", "p", ".", "mu", ".", "Lock", "(", ")", "\n", "*", "v", "=", "SACKEnabled", "(", "p", ".", "sackEnabled", ")", "\n", "p", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n\n", "case", "*", "SendBufferSizeOption", ":", "p", ".", "mu", ".", "Lock", "(", ")", "\n", "*", "v", "=", "p", ".", "sendBufferSize", "\n", "p", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n\n", "case", "*", "ReceiveBufferSizeOption", ":", "p", ".", "mu", ".", "Lock", "(", ")", "\n", "*", "v", "=", "p", ".", "recvBufferSize", "\n", "p", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n", "case", "*", "CongestionControlOption", ":", "p", ".", "mu", ".", "Lock", "(", ")", "\n", "*", "v", "=", "CongestionControlOption", "(", "p", ".", "congestionControl", ")", "\n", "p", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n", "case", "*", "AvailableCongestionControlOption", ":", "p", ".", "mu", ".", "Lock", "(", ")", "\n", "*", "v", "=", "AvailableCongestionControlOption", "(", "strings", ".", "Join", "(", "p", ".", "availableCongestionControl", ",", "\"", "\"", ")", ")", "\n", "p", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n", "default", ":", "return", "tcpip", ".", "ErrUnknownProtocolOption", "\n", "}", "\n", "}" ]

[ "Option", "implements", "TransportProtocol", ".", "Option", "." ]