Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "m", "*", "idManager", ")", "add", "(", "b", "*", "queue", ".", "TxBuffer", ")", "uint64", "{", "if", "i", ":=", "m", ".", "freeList", ";", "i", "!=", "nilID", "{", "// There is an id available in the free list, just use it.", "m", ".", "ids", "[", "i", "]", ".", "buf", "=", "b", "\n", "m", ".", "freeList", "=", "m", ".", "ids", "[", "i", "]", ".", "nextFree", "\n", "return", "i", "\n", "}", "\n\n", "// We need to expand the id descriptor.", "m", ".", "ids", "=", "append", "(", "m", ".", "ids", ",", "idDescriptor", "{", "buf", ":", "b", "}", ")", "\n", "return", "uint64", "(", "len", "(", "m", ".", "ids", ")", "-", "1", ")", "\n", "}" ]

[ "add", "assigns", "an", "ID", "to", "the", "given", "tx", "buffer", "." ]

[ "func", "(", "m", "*", "idManager", ")", "remove", "(", "i", "uint64", ")", "*", "queue", ".", "TxBuffer", "{", "if", "i", ">=", "uint64", "(", "len", "(", "m", ".", "ids", ")", ")", "{", "return", "nil", "\n", "}", "\n\n", "desc", ":=", "&", "m", ".", "ids", "[", "i", "]", "\n", "b", ":=", "desc", ".", "buf", "\n", "if", "b", "==", "nil", "{", "// The provided id is not currently assigned.", "return", "nil", "\n", "}", "\n\n", "desc", ".", "buf", "=", "nil", "\n", "desc", ".", "nextFree", "=", "m", ".", "freeList", "\n", "m", ".", "freeList", "=", "i", "\n\n", "return", "b", "\n", "}" ]

[ "remove", "retrieves", "the", "tx", "buffer", "associated", "with", "the", "given", "ID", "and", "removes", "the", "ID", "from", "the", "assigned", "table", "so", "that", "it", "can", "be", "reused", "in", "the", "future", "." ]

[ "func", "(", "b", "*", "bufferManager", ")", "init", "(", "initialOffset", ",", "size", ",", "entrySize", "int", ")", "{", "b", ".", "freeList", "=", "nil", "\n", "b", ".", "curOffset", "=", "uint64", "(", "initialOffset", ")", "\n", "b", ".", "limit", "=", "uint64", "(", "initialOffset", "+", "size", "/", "entrySize", "*", "entrySize", ")", "\n", "b", ".", "entrySize", "=", "uint32", "(", "entrySize", ")", "\n", "}" ]

[ "init", "initializes", "the", "buffer", "manager", "." ]

[ "func", "(", "b", "*", "bufferManager", ")", "alloc", "(", ")", "*", "queue", ".", "TxBuffer", "{", "if", "b", ".", "freeList", "!=", "nil", "{", "// There is a descriptor ready for reuse in the free list.", "d", ":=", "b", ".", "freeList", "\n", "b", ".", "freeList", "=", "d", ".", "Next", "\n", "d", ".", "Next", "=", "nil", "\n", "return", "d", "\n", "}", "\n\n", "if", "b", ".", "curOffset", "<", "b", ".", "limit", "{", "// There is room available in the never-used range, so create", "// a new descriptor for it.", "d", ":=", "&", "queue", ".", "TxBuffer", "{", "Offset", ":", "b", ".", "curOffset", ",", "Size", ":", "b", ".", "entrySize", ",", "}", "\n", "b", ".", "curOffset", "+=", "uint64", "(", "b", ".", "entrySize", ")", "\n", "return", "d", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "alloc", "allocates", "a", "buffer", "from", "the", "manager", "if", "one", "is", "available", "." ]

[ "func", "(", "b", "*", "bufferManager", ")", "free", "(", "d", "*", "queue", ".", "TxBuffer", ")", "{", "// Find the last buffer in the list.", "last", ":=", "d", "\n", "for", "last", ".", "Next", "!=", "nil", "{", "last", "=", "last", ".", "Next", "\n", "}", "\n\n", "// Push list onto free list.", "last", ".", "Next", "=", "b", ".", "freeList", "\n", "b", ".", "freeList", "=", "d", "\n", "}" ]

[ "free", "returns", "all", "buffers", "in", "the", "list", "to", "the", "buffer", "manager", "so", "that", "they", "can", "be", "reused", "." ]

[ "func", "incSynRcvdCount", "(", ")", "bool", "{", "synRcvdCount", ".", "Lock", "(", ")", "\n", "defer", "synRcvdCount", ".", "Unlock", "(", ")", "\n\n", "if", "synRcvdCount", ".", "value", ">=", "SynRcvdCountThreshold", "{", "return", "false", "\n", "}", "\n\n", "synRcvdCount", ".", "pending", ".", "Add", "(", "1", ")", "\n", "synRcvdCount", ".", "value", "++", "\n\n", "return", "true", "\n", "}" ]

[ "incSynRcvdCount", "tries", "to", "increment", "the", "global", "number", "of", "endpoints", "in", "SYN", "-", "RCVD", "state", ".", "It", "succeeds", "if", "the", "increment", "doesn", "t", "make", "the", "count", "go", "beyond", "the", "threshold", "and", "fails", "otherwise", "." ]

[ "func", "decSynRcvdCount", "(", ")", "{", "synRcvdCount", ".", "Lock", "(", ")", "\n", "defer", "synRcvdCount", ".", "Unlock", "(", ")", "\n\n", "synRcvdCount", ".", "value", "--", "\n", "synRcvdCount", ".", "pending", ".", "Done", "(", ")", "\n", "}" ]

[ "decSynRcvdCount", "atomically", "decrements", "the", "global", "number", "of", "endpoints", "in", "SYN", "-", "RCVD", "state", ".", "It", "must", "only", "be", "called", "if", "a", "previous", "call", "to", "incSynRcvdCount", "succeeded", "." ]

[ "func", "newListenContext", "(", "stack", "*", "stack", ".", "Stack", ",", "rcvWnd", "seqnum", ".", "Size", ",", "v6only", "bool", ",", "netProto", "tcpip", ".", "NetworkProtocolNumber", ")", "*", "listenContext", "{", "l", ":=", "&", "listenContext", "{", "stack", ":", "stack", ",", "rcvWnd", ":", "rcvWnd", ",", "hasher", ":", "sha1", ".", "New", "(", ")", ",", "v6only", ":", "v6only", ",", "netProto", ":", "netProto", ",", "}", "\n\n", "rand", ".", "Read", "(", "l", ".", "nonce", "[", "0", "]", "[", ":", "]", ")", "\n", "rand", ".", "Read", "(", "l", ".", "nonce", "[", "1", "]", "[", ":", "]", ")", "\n\n", "return", "l", "\n", "}" ]

[ "newListenContext", "creates", "a", "new", "listen", "context", "." ]

[ "func", "(", "l", "*", "listenContext", ")", "cookieHash", "(", "id", "stack", ".", "TransportEndpointID", ",", "ts", "uint32", ",", "nonceIndex", "int", ")", "uint32", "{", "// Initialize block with fixed-size data: local ports and v.", "var", "payload", "[", "8", "]", "byte", "\n", "binary", ".", "BigEndian", ".", "PutUint16", "(", "payload", "[", "0", ":", "]", ",", "id", ".", "LocalPort", ")", "\n", "binary", ".", "BigEndian", ".", "PutUint16", "(", "payload", "[", "2", ":", "]", ",", "id", ".", "RemotePort", ")", "\n", "binary", ".", "BigEndian", ".", "PutUint32", "(", "payload", "[", "4", ":", "]", ",", "ts", ")", "\n\n", "// Feed everything to the hasher.", "l", ".", "hasherMu", ".", "Lock", "(", ")", "\n", "l", ".", "hasher", ".", "Reset", "(", ")", "\n", "l", ".", "hasher", ".", "Write", "(", "payload", "[", ":", "]", ")", "\n", "l", ".", "hasher", ".", "Write", "(", "l", ".", "nonce", "[", "nonceIndex", "]", "[", ":", "]", ")", "\n", "io", ".", "WriteString", "(", "l", ".", "hasher", ",", "string", "(", "id", ".", "LocalAddress", ")", ")", "\n", "io", ".", "WriteString", "(", "l", ".", "hasher", ",", "string", "(", "id", ".", "RemoteAddress", ")", ")", "\n\n", "// Finalize the calculation of the hash and return the first 4 bytes.", "h", ":=", "make", "(", "[", "]", "byte", ",", "0", ",", "sha1", ".", "Size", ")", "\n", "h", "=", "l", ".", "hasher", ".", "Sum", "(", "h", ")", "\n", "l", ".", "hasherMu", ".", "Unlock", "(", ")", "\n\n", "return", "binary", ".", "BigEndian", ".", "Uint32", "(", "h", "[", ":", "]", ")", "\n", "}" ]

[ "cookieHash", "calculates", "the", "cookieHash", "for", "the", "given", "id", "timestamp", "and", "nonce", "index", ".", "The", "hash", "is", "used", "to", "create", "and", "validate", "cookies", "." ]

[ "func", "(", "l", "*", "listenContext", ")", "createCookie", "(", "id", "stack", ".", "TransportEndpointID", ",", "seq", "seqnum", ".", "Value", ",", "data", "uint32", ")", "seqnum", ".", "Value", "{", "ts", ":=", "timeStamp", "(", ")", "\n", "v", ":=", "l", ".", "cookieHash", "(", "id", ",", "0", ",", "0", ")", "+", "uint32", "(", "seq", ")", "+", "(", "ts", "<<", "tsOffset", ")", "\n", "v", "+=", "(", "l", ".", "cookieHash", "(", "id", ",", "ts", ",", "1", ")", "+", "data", ")", "&", "hashMask", "\n", "return", "seqnum", ".", "Value", "(", "v", ")", "\n", "}" ]

[ "createCookie", "creates", "a", "SYN", "cookie", "for", "the", "given", "id", "and", "incoming", "sequence", "number", "." ]

[ "func", "(", "l", "*", "listenContext", ")", "isCookieValid", "(", "id", "stack", ".", "TransportEndpointID", ",", "cookie", "seqnum", ".", "Value", ",", "seq", "seqnum", ".", "Value", ")", "(", "uint32", ",", "bool", ")", "{", "ts", ":=", "timeStamp", "(", ")", "\n", "v", ":=", "uint32", "(", "cookie", ")", "-", "l", ".", "cookieHash", "(", "id", ",", "0", ",", "0", ")", "-", "uint32", "(", "seq", ")", "\n", "cookieTS", ":=", "v", ">>", "tsOffset", "\n", "if", "(", "(", "ts", "-", "cookieTS", ")", "&", "tsMask", ")", ">", "maxTSDiff", "{", "return", "0", ",", "false", "\n", "}", "\n\n", "return", "(", "v", "-", "l", ".", "cookieHash", "(", "id", ",", "cookieTS", ",", "1", ")", ")", "&", "hashMask", ",", "true", "\n", "}" ]

[ "isCookieValid", "checks", "if", "the", "supplied", "cookie", "is", "valid", "for", "the", "given", "id", "and", "sequence", "number", ".", "If", "it", "is", "it", "also", "returns", "the", "data", "originally", "encoded", "in", "the", "cookie", "when", "createCookie", "was", "called", "." ]

[ "func", "(", "l", "*", "listenContext", ")", "createConnectedEndpoint", "(", "s", "*", "segment", ",", "iss", "seqnum", ".", "Value", ",", "irs", "seqnum", ".", "Value", ",", "rcvdSynOpts", "*", "header", ".", "TCPSynOptions", ")", "(", "*", "endpoint", ",", "*", "tcpip", ".", "Error", ")", "{", "// Create a new endpoint.", "netProto", ":=", "l", ".", "netProto", "\n", "if", "netProto", "==", "0", "{", "netProto", "=", "s", ".", "route", ".", "NetProto", "\n", "}", "\n", "n", ":=", "newEndpoint", "(", "l", ".", "stack", ",", "netProto", ",", "nil", ")", "\n", "n", ".", "v6only", "=", "l", ".", "v6only", "\n", "n", ".", "id", "=", "s", ".", "id", "\n", "n", ".", "boundNICID", "=", "s", ".", "route", ".", "NICID", "(", ")", "\n", "n", ".", "route", "=", "s", ".", "route", ".", "Clone", "(", ")", "\n", "n", ".", "effectiveNetProtos", "=", "[", "]", "tcpip", ".", "NetworkProtocolNumber", "{", "s", ".", "route", ".", "NetProto", "}", "\n", "n", ".", "rcvBufSize", "=", "int", "(", "l", ".", "rcvWnd", ")", "\n\n", "n", ".", "maybeEnableTimestamp", "(", "rcvdSynOpts", ")", "\n", "n", ".", "maybeEnableSACKPermitted", "(", "rcvdSynOpts", ")", "\n\n", "n", ".", "initGSO", "(", ")", "\n\n", "// Register new endpoint so that packets are routed to it.", "if", "err", ":=", "n", ".", "stack", ".", "RegisterTransportEndpoint", "(", "n", ".", "boundNICID", ",", "n", ".", "effectiveNetProtos", ",", "ProtocolNumber", ",", "n", ".", "id", ",", "n", ",", "n", ".", "reusePort", ")", ";", "err", "!=", "nil", "{", "n", ".", "Close", "(", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "n", ".", "isRegistered", "=", "true", "\n", "n", ".", "state", "=", "stateConnected", "\n\n", "// Create sender and receiver.", "//", "// The receiver at least temporarily has a zero receive window scale,", "// but the caller may change it (before starting the protocol loop).", "n", ".", "snd", "=", "newSender", "(", "n", ",", "iss", ",", "irs", ",", "s", ".", "window", ",", "rcvdSynOpts", ".", "MSS", ",", "rcvdSynOpts", ".", "WS", ")", "\n", "n", ".", "rcv", "=", "newReceiver", "(", "n", ",", "irs", ",", "l", ".", "rcvWnd", ",", "0", ")", "\n\n", "return", "n", ",", "nil", "\n", "}" ]

[ "createConnectedEndpoint", "creates", "a", "new", "connected", "endpoint", "with", "the", "connection", "parameters", "given", "by", "the", "arguments", "." ]

[ "func", "(", "l", "*", "listenContext", ")", "createEndpointAndPerformHandshake", "(", "s", "*", "segment", ",", "opts", "*", "header", ".", "TCPSynOptions", ")", "(", "*", "endpoint", ",", "*", "tcpip", ".", "Error", ")", "{", "// Create new endpoint.", "irs", ":=", "s", ".", "sequenceNumber", "\n", "cookie", ":=", "l", ".", "createCookie", "(", "s", ".", "id", ",", "irs", ",", "encodeMSS", "(", "opts", ".", "MSS", ")", ")", "\n", "ep", ",", "err", ":=", "l", ".", "createConnectedEndpoint", "(", "s", ",", "cookie", ",", "irs", ",", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Perform the 3-way handshake.", "h", ":=", "newHandshake", "(", "ep", ",", "l", ".", "rcvWnd", ")", "\n\n", "h", ".", "resetToSynRcvd", "(", "cookie", ",", "irs", ",", "opts", ")", "\n", "if", "err", ":=", "h", ".", "execute", "(", ")", ";", "err", "!=", "nil", "{", "ep", ".", "Close", "(", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Update the receive window scaling. We can't do it before the", "// handshake because it's possible that the peer doesn't support window", "// scaling.", "ep", ".", "rcv", ".", "rcvWndScale", "=", "h", ".", "effectiveRcvWndScale", "(", ")", "\n\n", "return", "ep", ",", "nil", "\n", "}" ]

[ "createEndpoint", "creates", "a", "new", "endpoint", "in", "connected", "state", "and", "then", "performs", "the", "TCP", "3", "-", "way", "handshake", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "deliverAccepted", "(", "n", "*", "endpoint", ")", "{", "e", ".", "mu", ".", "RLock", "(", ")", "\n", "if", "e", ".", "state", "==", "stateListen", "{", "e", ".", "acceptedChan", "<-", "n", "\n", "e", ".", "waiterQueue", ".", "Notify", "(", "waiter", ".", "EventIn", ")", "\n", "}", "else", "{", "n", ".", "Close", "(", ")", "\n", "}", "\n", "e", ".", "mu", ".", "RUnlock", "(", ")", "\n", "}" ]

[ "deliverAccepted", "delivers", "the", "newly", "-", "accepted", "endpoint", "to", "the", "listener", ".", "If", "the", "endpoint", "has", "transitioned", "out", "of", "the", "listen", "state", "the", "new", "endpoint", "is", "closed", "instead", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "handleSynSegment", "(", "ctx", "*", "listenContext", ",", "s", "*", "segment", ",", "opts", "*", "header", ".", "TCPSynOptions", ")", "{", "defer", "decSynRcvdCount", "(", ")", "\n", "defer", "s", ".", "decRef", "(", ")", "\n\n", "n", ",", "err", ":=", "ctx", ".", "createEndpointAndPerformHandshake", "(", "s", ",", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "e", ".", "deliverAccepted", "(", "n", ")", "\n", "}" ]

[ "handleSynSegment", "is", "called", "in", "its", "own", "goroutine", "once", "the", "listening", "endpoint", "receives", "a", "SYN", "segment", ".", "It", "is", "responsible", "for", "completing", "the", "handshake", "and", "queueing", "the", "new", "endpoint", "for", "acceptance", ".", "A", "limited", "number", "of", "these", "goroutines", "are", "allowed", "before", "TCP", "starts", "using", "SYN", "cookies", "to", "accept", "connections", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "handleListenSegment", "(", "ctx", "*", "listenContext", ",", "s", "*", "segment", ")", "{", "switch", "s", ".", "flags", "{", "case", "header", ".", "TCPFlagSyn", ":", "opts", ":=", "parseSynSegmentOptions", "(", "s", ")", "\n", "if", "incSynRcvdCount", "(", ")", "{", "s", ".", "incRef", "(", ")", "\n", "go", "e", ".", "handleSynSegment", "(", "ctx", ",", "s", ",", "&", "opts", ")", "\n", "}", "else", "{", "cookie", ":=", "ctx", ".", "createCookie", "(", "s", ".", "id", ",", "s", ".", "sequenceNumber", ",", "encodeMSS", "(", "opts", ".", "MSS", ")", ")", "\n", "// Send SYN with window scaling because we currently", "// dont't encode this information in the cookie.", "//", "// Enable Timestamp option if the original syn did have", "// the timestamp option specified.", "synOpts", ":=", "header", ".", "TCPSynOptions", "{", "WS", ":", "-", "1", ",", "TS", ":", "opts", ".", "TS", ",", "TSVal", ":", "tcpTimeStamp", "(", "timeStampOffset", "(", ")", ")", ",", "TSEcr", ":", "opts", ".", "TSVal", ",", "}", "\n", "sendSynTCP", "(", "&", "s", ".", "route", ",", "s", ".", "id", ",", "header", ".", "TCPFlagSyn", "|", "header", ".", "TCPFlagAck", ",", "cookie", ",", "s", ".", "sequenceNumber", "+", "1", ",", "ctx", ".", "rcvWnd", ",", "synOpts", ")", "\n", "}", "\n\n", "case", "header", ".", "TCPFlagAck", ":", "if", "data", ",", "ok", ":=", "ctx", ".", "isCookieValid", "(", "s", ".", "id", ",", "s", ".", "ackNumber", "-", "1", ",", "s", ".", "sequenceNumber", "-", "1", ")", ";", "ok", "&&", "int", "(", "data", ")", "<", "len", "(", "mssTable", ")", "{", "// Create newly accepted endpoint and deliver it.", "rcvdSynOptions", ":=", "&", "header", ".", "TCPSynOptions", "{", "MSS", ":", "mssTable", "[", "data", "]", ",", "// Disable Window scaling as original SYN is", "// lost.", "WS", ":", "-", "1", ",", "}", "\n", "// When syn cookies are in use we enable timestamp only", "// if the ack specifies the timestamp option assuming", "// that the other end did in fact negotiate the", "// timestamp option in the original SYN.", "if", "s", ".", "parsedOptions", ".", "TS", "{", "rcvdSynOptions", ".", "TS", "=", "true", "\n", "rcvdSynOptions", ".", "TSVal", "=", "s", ".", "parsedOptions", ".", "TSVal", "\n", "rcvdSynOptions", ".", "TSEcr", "=", "s", ".", "parsedOptions", ".", "TSEcr", "\n", "}", "\n", "n", ",", "err", ":=", "ctx", ".", "createConnectedEndpoint", "(", "s", ",", "s", ".", "ackNumber", "-", "1", ",", "s", ".", "sequenceNumber", "-", "1", ",", "rcvdSynOptions", ")", "\n", "if", "err", "==", "nil", "{", "// clear the tsOffset for the newly created", "// endpoint as the Timestamp was already", "// randomly offset when the original SYN-ACK was", "// sent above.", "n", ".", "tsOffset", "=", "0", "\n", "e", ".", "deliverAccepted", "(", "n", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "handleListenSegment", "is", "called", "when", "a", "listening", "endpoint", "receives", "a", "segment", "and", "needs", "to", "handle", "it", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "protocolListenLoop", "(", "rcvWnd", "seqnum", ".", "Size", ")", "*", "tcpip", ".", "Error", "{", "defer", "func", "(", ")", "{", "// Mark endpoint as closed. This will prevent goroutines running", "// handleSynSegment() from attempting to queue new connections", "// to the endpoint.", "e", ".", "mu", ".", "Lock", "(", ")", "\n", "e", ".", "state", "=", "stateClosed", "\n\n", "// Do cleanup if needed.", "e", ".", "completeWorkerLocked", "(", ")", "\n\n", "if", "e", ".", "drainDone", "!=", "nil", "{", "close", "(", "e", ".", "drainDone", ")", "\n", "}", "\n", "e", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "// Notify waiters that the endpoint is shutdown.", "e", ".", "waiterQueue", ".", "Notify", "(", "waiter", ".", "EventIn", "|", "waiter", ".", "EventOut", ")", "\n", "}", "(", ")", "\n\n", "e", ".", "mu", ".", "Lock", "(", ")", "\n", "v6only", ":=", "e", ".", "v6only", "\n", "e", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "ctx", ":=", "newListenContext", "(", "e", ".", "stack", ",", "rcvWnd", ",", "v6only", ",", "e", ".", "netProto", ")", "\n\n", "s", ":=", "sleep", ".", "Sleeper", "{", "}", "\n", "s", ".", "AddWaker", "(", "&", "e", ".", "notificationWaker", ",", "wakerForNotification", ")", "\n", "s", ".", "AddWaker", "(", "&", "e", ".", "newSegmentWaker", ",", "wakerForNewSegment", ")", "\n", "for", "{", "switch", "index", ",", "_", ":=", "s", ".", "Fetch", "(", "true", ")", ";", "index", "{", "case", "wakerForNotification", ":", "n", ":=", "e", ".", "fetchNotifications", "(", ")", "\n", "if", "n", "&", "notifyClose", "!=", "0", "{", "return", "nil", "\n", "}", "\n", "if", "n", "&", "notifyDrain", "!=", "0", "{", "for", "!", "e", ".", "segmentQueue", ".", "empty", "(", ")", "{", "s", ":=", "e", ".", "segmentQueue", ".", "dequeue", "(", ")", "\n", "e", ".", "handleListenSegment", "(", "ctx", ",", "s", ")", "\n", "s", ".", "decRef", "(", ")", "\n", "}", "\n", "synRcvdCount", ".", "pending", ".", "Wait", "(", ")", "\n", "close", "(", "e", ".", "drainDone", ")", "\n", "<-", "e", ".", "undrain", "\n", "}", "\n\n", "case", "wakerForNewSegment", ":", "// Process at most maxSegmentsPerWake segments.", "mayRequeue", ":=", "true", "\n", "for", "i", ":=", "0", ";", "i", "<", "maxSegmentsPerWake", ";", "i", "++", "{", "s", ":=", "e", ".", "segmentQueue", ".", "dequeue", "(", ")", "\n", "if", "s", "==", "nil", "{", "mayRequeue", "=", "false", "\n", "break", "\n", "}", "\n\n", "e", ".", "handleListenSegment", "(", "ctx", ",", "s", ")", "\n", "s", ".", "decRef", "(", ")", "\n", "}", "\n\n", "// If the queue is not empty, make sure we'll wake up", "// in the next iteration.", "if", "mayRequeue", "&&", "!", "e", ".", "segmentQueue", ".", "empty", "(", ")", "{", "e", ".", "newSegmentWaker", ".", "Assert", "(", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "protocolListenLoop", "is", "the", "main", "loop", "of", "a", "listening", "TCP", "endpoint", ".", "It", "runs", "in", "its", "own", "goroutine", "and", "is", "responsible", "for", "handling", "connection", "requests", "." ]

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

[ "SetChecksum", "calculates", "and", "sets", "the", "ICMP", "checksum", "field", "." ]

[ "func", "(", "n", "*", "NIC", ")", "setPromiscuousMode", "(", "enable", "bool", ")", "{", "n", ".", "mu", ".", "Lock", "(", ")", "\n", "n", ".", "promiscuous", "=", "enable", "\n", "n", ".", "mu", ".", "Unlock", "(", ")", "\n", "}" ]

[ "setPromiscuousMode", "enables", "or", "disables", "promiscuous", "mode", "." ]

[ "func", "(", "n", "*", "NIC", ")", "setSpoofing", "(", "enable", "bool", ")", "{", "n", ".", "mu", ".", "Lock", "(", ")", "\n", "n", ".", "spoofing", "=", "enable", "\n", "n", ".", "mu", ".", "Unlock", "(", ")", "\n", "}" ]

[ "setSpoofing", "enables", "or", "disables", "address", "spoofing", "." ]

[ "func", "(", "n", "*", "NIC", ")", "primaryEndpoint", "(", "protocol", "tcpip", ".", "NetworkProtocolNumber", ")", "*", "referencedNetworkEndpoint", "{", "n", ".", "mu", ".", "RLock", "(", ")", "\n", "defer", "n", ".", "mu", ".", "RUnlock", "(", ")", "\n\n", "list", ":=", "n", ".", "primary", "[", "protocol", "]", "\n", "if", "list", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "for", "e", ":=", "list", ".", "Front", "(", ")", ";", "e", "!=", "nil", ";", "e", "=", "e", ".", "Next", "(", ")", "{", "r", ":=", "e", ".", "(", "*", "referencedNetworkEndpoint", ")", "\n", "// TODO(crawshaw): allow broadcast address when SO_BROADCAST is set.", "switch", "r", ".", "ep", ".", "ID", "(", ")", ".", "LocalAddress", "{", "case", "header", ".", "IPv4Broadcast", ",", "header", ".", "IPv4Any", ":", "continue", "\n", "}", "\n", "if", "r", ".", "tryIncRef", "(", ")", "{", "return", "r", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "primaryEndpoint", "returns", "the", "primary", "endpoint", "of", "n", "for", "the", "given", "network", "protocol", "." ]

[ "func", "(", "n", "*", "NIC", ")", "findEndpoint", "(", "protocol", "tcpip", ".", "NetworkProtocolNumber", ",", "address", "tcpip", ".", "Address", ",", "peb", "PrimaryEndpointBehavior", ")", "*", "referencedNetworkEndpoint", "{", "id", ":=", "NetworkEndpointID", "{", "address", "}", "\n\n", "n", ".", "mu", ".", "RLock", "(", ")", "\n", "ref", ":=", "n", ".", "endpoints", "[", "id", "]", "\n", "if", "ref", "!=", "nil", "&&", "!", "ref", ".", "tryIncRef", "(", ")", "{", "ref", "=", "nil", "\n", "}", "\n", "spoofing", ":=", "n", ".", "spoofing", "\n", "n", ".", "mu", ".", "RUnlock", "(", ")", "\n\n", "if", "ref", "!=", "nil", "||", "!", "spoofing", "{", "return", "ref", "\n", "}", "\n\n", "// Try again with the lock in exclusive mode. If we still can't get the", "// endpoint, create a new \"temporary\" endpoint. It will only exist while", "// there's a route through it.", "n", ".", "mu", ".", "Lock", "(", ")", "\n", "ref", "=", "n", ".", "endpoints", "[", "id", "]", "\n", "if", "ref", "==", "nil", "||", "!", "ref", ".", "tryIncRef", "(", ")", "{", "ref", ",", "_", "=", "n", ".", "addAddressLocked", "(", "protocol", ",", "address", ",", "peb", ",", "true", ")", "\n", "if", "ref", "!=", "nil", "{", "ref", ".", "holdsInsertRef", "=", "false", "\n", "}", "\n", "}", "\n", "n", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "ref", "\n", "}" ]

[ "findEndpoint", "finds", "the", "endpoint", "if", "any", "with", "the", "given", "address", "." ]

[ "func", "(", "n", "*", "NIC", ")", "Addresses", "(", ")", "[", "]", "tcpip", ".", "ProtocolAddress", "{", "n", ".", "mu", ".", "RLock", "(", ")", "\n", "defer", "n", ".", "mu", ".", "RUnlock", "(", ")", "\n", "addrs", ":=", "make", "(", "[", "]", "tcpip", ".", "ProtocolAddress", ",", "0", ",", "len", "(", "n", ".", "endpoints", ")", ")", "\n", "for", "nid", ",", "ep", ":=", "range", "n", ".", "endpoints", "{", "addrs", "=", "append", "(", "addrs", ",", "tcpip", ".", "ProtocolAddress", "{", "Protocol", ":", "ep", ".", "protocol", ",", "Address", ":", "nid", ".", "LocalAddress", ",", "}", ")", "\n", "}", "\n", "return", "addrs", "\n", "}" ]

[ "Addresses", "returns", "the", "addresses", "associated", "with", "this", "NIC", "." ]

[ "func", "(", "n", "*", "NIC", ")", "AddSubnet", "(", "protocol", "tcpip", ".", "NetworkProtocolNumber", ",", "subnet", "tcpip", ".", "Subnet", ")", "{", "n", ".", "mu", ".", "Lock", "(", ")", "\n", "n", ".", "subnets", "=", "append", "(", "n", ".", "subnets", ",", "subnet", ")", "\n", "n", ".", "mu", ".", "Unlock", "(", ")", "\n", "}" ]

[ "AddSubnet", "adds", "a", "new", "subnet", "to", "n", "so", "that", "it", "starts", "accepting", "packets", "targeted", "at", "the", "given", "address", "and", "network", "protocol", "." ]

[ "func", "(", "n", "*", "NIC", ")", "RemoveSubnet", "(", "subnet", "tcpip", ".", "Subnet", ")", "{", "n", ".", "mu", ".", "Lock", "(", ")", "\n\n", "// Use the same underlying array.", "tmp", ":=", "n", ".", "subnets", "[", ":", "0", "]", "\n", "for", "_", ",", "sub", ":=", "range", "n", ".", "subnets", "{", "if", "sub", "!=", "subnet", "{", "tmp", "=", "append", "(", "tmp", ",", "sub", ")", "\n", "}", "\n", "}", "\n", "n", ".", "subnets", "=", "tmp", "\n\n", "n", ".", "mu", ".", "Unlock", "(", ")", "\n", "}" ]

[ "RemoveSubnet", "removes", "the", "given", "subnet", "from", "n", "." ]

[ "func", "(", "n", "*", "NIC", ")", "ContainsSubnet", "(", "subnet", "tcpip", ".", "Subnet", ")", "bool", "{", "for", "_", ",", "s", ":=", "range", "n", ".", "Subnets", "(", ")", "{", "if", "s", "==", "subnet", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "ContainsSubnet", "reports", "whether", "this", "NIC", "contains", "the", "given", "subnet", "." ]

[ "func", "(", "n", "*", "NIC", ")", "Subnets", "(", ")", "[", "]", "tcpip", ".", "Subnet", "{", "n", ".", "mu", ".", "RLock", "(", ")", "\n", "defer", "n", ".", "mu", ".", "RUnlock", "(", ")", "\n", "sns", ":=", "make", "(", "[", "]", "tcpip", ".", "Subnet", ",", "0", ",", "len", "(", "n", ".", "subnets", ")", "+", "len", "(", "n", ".", "endpoints", ")", ")", "\n", "for", "nid", ":=", "range", "n", ".", "endpoints", "{", "sn", ",", "err", ":=", "tcpip", ".", "NewSubnet", "(", "nid", ".", "LocalAddress", ",", "tcpip", ".", "AddressMask", "(", "strings", ".", "Repeat", "(", "\"", "\\xff", "\"", ",", "len", "(", "nid", ".", "LocalAddress", ")", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "// This should never happen as the mask has been carefully crafted to", "// match the address.", "panic", "(", "\"", "\"", "+", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "sns", "=", "append", "(", "sns", ",", "sn", ")", "\n", "}", "\n", "return", "append", "(", "sns", ",", "n", ".", "subnets", "...", ")", "\n", "}" ]

[ "Subnets", "returns", "the", "Subnets", "associated", "with", "this", "NIC", "." ]

[ "func", "(", "n", "*", "NIC", ")", "RemoveAddress", "(", "addr", "tcpip", ".", "Address", ")", "*", "tcpip", ".", "Error", "{", "n", ".", "mu", ".", "Lock", "(", ")", "\n", "r", ":=", "n", ".", "endpoints", "[", "NetworkEndpointID", "{", "addr", "}", "]", "\n", "if", "r", "==", "nil", "||", "!", "r", ".", "holdsInsertRef", "{", "n", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "tcpip", ".", "ErrBadLocalAddress", "\n", "}", "\n\n", "r", ".", "holdsInsertRef", "=", "false", "\n", "n", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "r", ".", "decRef", "(", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "RemoveAddress", "removes", "an", "address", "from", "n", "." ]

[ "func", "(", "n", "*", "NIC", ")", "DeliverTransportPacket", "(", "r", "*", "Route", ",", "protocol", "tcpip", ".", "TransportProtocolNumber", ",", "netHeader", "buffer", ".", "View", ",", "vv", "buffer", ".", "VectorisedView", ")", "{", "state", ",", "ok", ":=", "n", ".", "stack", ".", "transportProtocols", "[", "protocol", "]", "\n", "if", "!", "ok", "{", "n", ".", "stack", ".", "stats", ".", "UnknownProtocolRcvdPackets", ".", "Increment", "(", ")", "\n", "return", "\n", "}", "\n\n", "transProto", ":=", "state", ".", "proto", "\n", "if", "len", "(", "vv", ".", "First", "(", ")", ")", "<", "transProto", ".", "MinimumPacketSize", "(", ")", "{", "n", ".", "stack", ".", "stats", ".", "MalformedRcvdPackets", ".", "Increment", "(", ")", "\n", "return", "\n", "}", "\n\n", "srcPort", ",", "dstPort", ",", "err", ":=", "transProto", ".", "ParsePorts", "(", "vv", ".", "First", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "n", ".", "stack", ".", "stats", ".", "MalformedRcvdPackets", ".", "Increment", "(", ")", "\n", "return", "\n", "}", "\n\n", "id", ":=", "TransportEndpointID", "{", "dstPort", ",", "r", ".", "LocalAddress", ",", "srcPort", ",", "r", ".", "RemoteAddress", "}", "\n", "if", "n", ".", "demux", ".", "deliverPacket", "(", "r", ",", "protocol", ",", "netHeader", ",", "vv", ",", "id", ")", "{", "return", "\n", "}", "\n", "if", "n", ".", "stack", ".", "demux", ".", "deliverPacket", "(", "r", ",", "protocol", ",", "netHeader", ",", "vv", ",", "id", ")", "{", "return", "\n", "}", "\n\n", "// Try to deliver to per-stack default handler.", "if", "state", ".", "defaultHandler", "!=", "nil", "{", "if", "state", ".", "defaultHandler", "(", "r", ",", "id", ",", "netHeader", ",", "vv", ")", "{", "return", "\n", "}", "\n", "}", "\n\n", "// We could not find an appropriate destination for this packet, so", "// deliver it to the global handler.", "if", "!", "transProto", ".", "HandleUnknownDestinationPacket", "(", "r", ",", "id", ",", "vv", ")", "{", "n", ".", "stack", ".", "stats", ".", "MalformedRcvdPackets", ".", "Increment", "(", ")", "\n", "}", "\n", "}" ]

[ "DeliverTransportPacket", "delivers", "the", "packets", "to", "the", "appropriate", "transport", "protocol", "endpoint", "." ]

[ "func", "(", "n", "*", "NIC", ")", "DeliverTransportControlPacket", "(", "local", ",", "remote", "tcpip", ".", "Address", ",", "net", "tcpip", ".", "NetworkProtocolNumber", ",", "trans", "tcpip", ".", "TransportProtocolNumber", ",", "typ", "ControlType", ",", "extra", "uint32", ",", "vv", "buffer", ".", "VectorisedView", ")", "{", "state", ",", "ok", ":=", "n", ".", "stack", ".", "transportProtocols", "[", "trans", "]", "\n", "if", "!", "ok", "{", "return", "\n", "}", "\n\n", "transProto", ":=", "state", ".", "proto", "\n\n", "// ICMPv4 only guarantees that 8 bytes of the transport protocol will", "// be present in the payload. We know that the ports are within the", "// first 8 bytes for all known transport protocols.", "if", "len", "(", "vv", ".", "First", "(", ")", ")", "<", "8", "{", "return", "\n", "}", "\n\n", "srcPort", ",", "dstPort", ",", "err", ":=", "transProto", ".", "ParsePorts", "(", "vv", ".", "First", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "id", ":=", "TransportEndpointID", "{", "srcPort", ",", "local", ",", "dstPort", ",", "remote", "}", "\n", "if", "n", ".", "demux", ".", "deliverControlPacket", "(", "net", ",", "trans", ",", "typ", ",", "extra", ",", "vv", ",", "id", ")", "{", "return", "\n", "}", "\n", "if", "n", ".", "stack", ".", "demux", ".", "deliverControlPacket", "(", "net", ",", "trans", ",", "typ", ",", "extra", ",", "vv", ",", "id", ")", "{", "return", "\n", "}", "\n", "}" ]

[ "DeliverTransportControlPacket", "delivers", "control", "packets", "to", "the", "appropriate", "transport", "protocol", "endpoint", "." ]

[ "func", "(", "r", "*", "referencedNetworkEndpoint", ")", "decRef", "(", ")", "{", "if", "atomic", ".", "AddInt32", "(", "&", "r", ".", "refs", ",", "-", "1", ")", "==", "0", "{", "r", ".", "nic", ".", "removeEndpoint", "(", "r", ")", "\n", "}", "\n", "}" ]

[ "decRef", "decrements", "the", "ref", "count", "and", "cleans", "up", "the", "endpoint", "once", "it", "reaches", "zero", "." ]

[ "func", "(", "r", "*", "referencedNetworkEndpoint", ")", "tryIncRef", "(", ")", "bool", "{", "for", "{", "v", ":=", "atomic", ".", "LoadInt32", "(", "&", "r", ".", "refs", ")", "\n", "if", "v", "==", "0", "{", "return", "false", "\n", "}", "\n\n", "if", "atomic", ".", "CompareAndSwapInt32", "(", "&", "r", ".", "refs", ",", "v", ",", "v", "+", "1", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "}" ]

[ "tryIncRef", "attempts", "to", "increment", "the", "ref", "count", "from", "n", "to", "n", "+", "1", "but", "only", "if", "n", "is", "not", "zero", ".", "That", "is", "it", "will", "increment", "the", "count", "if", "the", "endpoint", "is", "still", "alive", "and", "do", "nothing", "if", "it", "has", "already", "been", "clean", "up", "." ]

[ "func", "(", "*", "protocol", ")", "ParsePorts", "(", "v", "buffer", ".", "View", ")", "(", "src", ",", "dst", "uint16", ",", "err", "*", "tcpip", ".", "Error", ")", "{", "h", ":=", "header", ".", "UDP", "(", "v", ")", "\n", "return", "h", ".", "SourcePort", "(", ")", ",", "h", ".", "DestinationPort", "(", ")", ",", "nil", "\n", "}" ]

[ "ParsePorts", "returns", "the", "source", "and", "destination", "ports", "stored", "in", "the", "given", "udp", "packet", "." ]

[ "func", "(", "*", "StdClock", ")", "NowNanoseconds", "(", ")", "int64", "{", "sec", ",", "nsec", ",", "_", ":=", "now", "(", ")", "\n", "return", "sec", "*", "1e9", "+", "int64", "(", "nsec", ")", "\n", "}" ]

[ "NowNanoseconds", "implements", "Clock", ".", "NowNanoseconds", "." ]

[ "func", "(", "b", "bindAddresses", ")", "isAvailable", "(", "addr", "tcpip", ".", "Address", ",", "reuse", "bool", ")", "bool", "{", "if", "addr", "==", "anyIPAddress", "{", "if", "len", "(", "b", ")", "==", "0", "{", "return", "true", "\n", "}", "\n", "if", "!", "reuse", "{", "return", "false", "\n", "}", "\n", "for", "_", ",", "n", ":=", "range", "b", "{", "if", "!", "n", ".", "reuse", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}", "\n\n", "// If all addresses for this portDescriptor are already bound, no", "// address is available.", "if", "n", ",", "ok", ":=", "b", "[", "anyIPAddress", "]", ";", "ok", "{", "if", "!", "reuse", "{", "return", "false", "\n", "}", "\n", "if", "!", "n", ".", "reuse", "{", "return", "false", "\n", "}", "\n", "}", "\n\n", "if", "n", ",", "ok", ":=", "b", "[", "addr", "]", ";", "ok", "{", "if", "!", "reuse", "{", "return", "false", "\n", "}", "\n", "return", "n", ".", "reuse", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "isAvailable", "checks", "whether", "an", "IP", "address", "is", "available", "to", "bind", "to", "." ]

[ "func", "(", "s", "*", "PortManager", ")", "PickEphemeralPort", "(", "testPort", "func", "(", "p", "uint16", ")", "(", "bool", ",", "*", "tcpip", ".", "Error", ")", ")", "(", "port", "uint16", ",", "err", "*", "tcpip", ".", "Error", ")", "{", "count", ":=", "uint16", "(", "math", ".", "MaxUint16", "-", "FirstEphemeral", "+", "1", ")", "\n", "offset", ":=", "uint16", "(", "rand", ".", "Int31n", "(", "int32", "(", "count", ")", ")", ")", "\n\n", "for", "i", ":=", "uint16", "(", "0", ")", ";", "i", "<", "count", ";", "i", "++", "{", "port", "=", "FirstEphemeral", "+", "(", "offset", "+", "i", ")", "%", "count", "\n", "ok", ",", "err", ":=", "testPort", "(", "port", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "if", "ok", "{", "return", "port", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "0", ",", "tcpip", ".", "ErrNoPortAvailable", "\n", "}" ]

[ "PickEphemeralPort", "randomly", "chooses", "a", "starting", "point", "and", "iterates", "over", "all", "possible", "ephemeral", "ports", "allowing", "the", "caller", "to", "decide", "whether", "a", "given", "port", "is", "suitable", "for", "its", "needs", "and", "stopping", "when", "a", "port", "is", "found", "or", "an", "error", "occurs", "." ]

[ "func", "(", "s", "*", "PortManager", ")", "IsPortAvailable", "(", "networks", "[", "]", "tcpip", ".", "NetworkProtocolNumber", ",", "transport", "tcpip", ".", "TransportProtocolNumber", ",", "addr", "tcpip", ".", "Address", ",", "port", "uint16", ",", "reuse", "bool", ")", "bool", "{", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "s", ".", "isPortAvailableLocked", "(", "networks", ",", "transport", ",", "addr", ",", "port", ",", "reuse", ")", "\n", "}" ]

[ "IsPortAvailable", "tests", "if", "the", "given", "port", "is", "available", "on", "all", "given", "protocols", "." ]

[ "func", "(", "s", "*", "PortManager", ")", "reserveSpecificPort", "(", "networks", "[", "]", "tcpip", ".", "NetworkProtocolNumber", ",", "transport", "tcpip", ".", "TransportProtocolNumber", ",", "addr", "tcpip", ".", "Address", ",", "port", "uint16", ",", "reuse", "bool", ")", "bool", "{", "if", "!", "s", ".", "isPortAvailableLocked", "(", "networks", ",", "transport", ",", "addr", ",", "port", ",", "reuse", ")", "{", "return", "false", "\n", "}", "\n\n", "// Reserve port on all network protocols.", "for", "_", ",", "network", ":=", "range", "networks", "{", "desc", ":=", "portDescriptor", "{", "network", ",", "transport", ",", "port", "}", "\n", "m", ",", "ok", ":=", "s", ".", "allocatedPorts", "[", "desc", "]", "\n", "if", "!", "ok", "{", "m", "=", "make", "(", "bindAddresses", ")", "\n", "s", ".", "allocatedPorts", "[", "desc", "]", "=", "m", "\n", "}", "\n", "if", "n", ",", "ok", ":=", "m", "[", "addr", "]", ";", "ok", "{", "n", ".", "refs", "++", "\n", "m", "[", "addr", "]", "=", "n", "\n", "}", "else", "{", "m", "[", "addr", "]", "=", "portNode", "{", "reuse", ":", "reuse", ",", "refs", ":", "1", "}", "\n", "}", "\n", "}", "\n\n", "return", "true", "\n", "}" ]

[ "reserveSpecificPort", "tries", "to", "reserve", "the", "given", "port", "on", "all", "given", "protocols", "." ]

[ "func", "(", "ep", "*", "endpoint", ")", "saveRcvBufSizeMax", "(", ")", "int", "{", "max", ":=", "ep", ".", "rcvBufSizeMax", "\n", "// Make sure no new packets will be handled regardless of the lock.", "ep", ".", "rcvBufSizeMax", "=", "0", "\n", "// Release the lock acquired in beforeSave() so regular endpoint closing", "// logic can proceed after save.", "ep", ".", "rcvMu", ".", "Unlock", "(", ")", "\n", "return", "max", "\n", "}" ]

[ "saveRcvBufSizeMax", "is", "invoked", "by", "stateify", "." ]

[ "func", "(", "ep", "*", "endpoint", ")", "afterLoad", "(", ")", "{", "// StackFromEnv is a stack used specifically for save/restore.", "ep", ".", "stack", "=", "stack", ".", "StackFromEnv", "\n\n", "// If the endpoint is connected, re-connect via the save/restore stack.", "if", "ep", ".", "connected", "{", "var", "err", "*", "tcpip", ".", "Error", "\n", "ep", ".", "route", ",", "err", "=", "ep", ".", "stack", ".", "FindRoute", "(", "ep", ".", "registeredNIC", ",", "ep", ".", "boundAddr", ",", "ep", ".", "route", ".", "RemoteAddress", ",", "ep", ".", "netProto", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "*", "err", ")", "\n", "}", "\n", "}", "\n\n", "// If the endpoint is bound, re-bind via the save/restore stack.", "if", "ep", ".", "bound", "{", "if", "ep", ".", "stack", ".", "CheckLocalAddress", "(", "ep", ".", "registeredNIC", ",", "ep", ".", "netProto", ",", "ep", ".", "boundAddr", ")", "==", "0", "{", "panic", "(", "tcpip", ".", "ErrBadLocalAddress", ")", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "ep", ".", "stack", ".", "RegisterRawTransportEndpoint", "(", "ep", ".", "registeredNIC", ",", "ep", ".", "netProto", ",", "ep", ".", "transProto", ",", "ep", ")", ";", "err", "!=", "nil", "{", "panic", "(", "*", "err", ")", "\n", "}", "\n", "}" ]

[ "afterLoad", "is", "invoked", "by", "stateify", "." ]

[ "func", "(", "t", "*", "TCB", ")", "Init", "(", "initialSyn", "header", ".", "TCP", ")", "Result", "{", "t", ".", "handlerInbound", "=", "synSentStateInbound", "\n", "t", ".", "handlerOutbound", "=", "synSentStateOutbound", "\n\n", "iss", ":=", "seqnum", ".", "Value", "(", "initialSyn", ".", "SequenceNumber", "(", ")", ")", "\n", "t", ".", "outbound", ".", "una", "=", "iss", "\n", "t", ".", "outbound", ".", "nxt", "=", "iss", ".", "Add", "(", "logicalLen", "(", "initialSyn", ")", ")", "\n", "t", ".", "outbound", ".", "end", "=", "t", ".", "outbound", ".", "nxt", "\n\n", "// Even though \"end\" is a sequence number, we don't know the initial", "// receive sequence number yet, so we store the window size until we get", "// a SYN from the peer.", "t", ".", "inbound", ".", "una", "=", "0", "\n", "t", ".", "inbound", ".", "nxt", "=", "0", "\n", "t", ".", "inbound", ".", "end", "=", "seqnum", ".", "Value", "(", "initialSyn", ".", "WindowSize", "(", ")", ")", "\n", "t", ".", "state", "=", "ResultConnecting", "\n", "return", "t", ".", "state", "\n", "}" ]

[ "Init", "initializes", "the", "state", "of", "the", "TCB", "according", "to", "the", "initial", "SYN", "." ]

[ "func", "(", "t", "*", "TCB", ")", "UpdateStateInbound", "(", "tcp", "header", ".", "TCP", ")", "Result", "{", "st", ":=", "t", ".", "handlerInbound", "(", "t", ",", "tcp", ")", "\n", "if", "st", "!=", "ResultDrop", "{", "t", ".", "state", "=", "st", "\n", "}", "\n", "return", "st", "\n", "}" ]

[ "UpdateStateInbound", "updates", "the", "state", "of", "the", "TCB", "based", "on", "the", "supplied", "inbound", "segment", "." ]

[ "func", "(", "t", "*", "TCB", ")", "UpdateStateOutbound", "(", "tcp", "header", ".", "TCP", ")", "Result", "{", "st", ":=", "t", ".", "handlerOutbound", "(", "t", ",", "tcp", ")", "\n", "if", "st", "!=", "ResultDrop", "{", "t", ".", "state", "=", "st", "\n", "}", "\n", "return", "st", "\n", "}" ]

[ "UpdateStateOutbound", "updates", "the", "state", "of", "the", "TCB", "based", "on", "the", "supplied", "outbound", "segment", "." ]

[ "func", "(", "t", "*", "TCB", ")", "adaptResult", "(", "r", "Result", ")", "Result", "{", "// Check the unmodified case.", "if", "r", "!=", "ResultAlive", "||", "!", "t", ".", "inbound", ".", "closed", "(", ")", "||", "!", "t", ".", "outbound", ".", "closed", "(", ")", "{", "return", "r", "\n", "}", "\n\n", "// Find out which was closed first.", "if", "t", ".", "firstFin", "==", "&", "t", ".", "outbound", "{", "return", "ResultClosedBySelf", "\n", "}", "\n\n", "return", "ResultClosedByPeer", "\n", "}" ]

[ "adapResult", "modifies", "the", "supplied", "Result", "according", "to", "the", "state", "of", "the", "TCB", ";", "if", "r", "is", "anything", "other", "than", "Alive", "or", "if", "one", "of", "the", "streams", "isn", "t", "closed", "yet", "it", "is", "returned", "unmodified", ".", "Otherwise", "it", "s", "converted", "to", "either", "ClosedBySelf", "or", "ClosedByPeer", "depending", "on", "which", "stream", "was", "closed", "first", "." ]

[ "func", "synSentStateInbound", "(", "t", "*", "TCB", ",", "tcp", "header", ".", "TCP", ")", "Result", "{", "flags", ":=", "tcp", ".", "Flags", "(", ")", "\n", "ackPresent", ":=", "flags", "&", "header", ".", "TCPFlagAck", "!=", "0", "\n", "ack", ":=", "seqnum", ".", "Value", "(", "tcp", ".", "AckNumber", "(", ")", ")", "\n\n", "// Ignore segment if ack is present but not acceptable.", "if", "ackPresent", "&&", "!", "(", "ack", "-", "1", ")", ".", "InRange", "(", "t", ".", "outbound", ".", "una", ",", "t", ".", "outbound", ".", "nxt", ")", "{", "return", "ResultConnecting", "\n", "}", "\n\n", "// If reset is specified, we will let the packet through no matter what", "// but we will also destroy the connection if the ACK is present (and", "// implicitly acceptable).", "if", "flags", "&", "header", ".", "TCPFlagRst", "!=", "0", "{", "if", "ackPresent", "{", "t", ".", "inbound", ".", "rstSeen", "=", "true", "\n", "return", "ResultReset", "\n", "}", "\n", "return", "ResultConnecting", "\n", "}", "\n\n", "// Ignore segment if SYN is not set.", "if", "flags", "&", "header", ".", "TCPFlagSyn", "==", "0", "{", "return", "ResultConnecting", "\n", "}", "\n\n", "// Update state informed by this SYN.", "irs", ":=", "seqnum", ".", "Value", "(", "tcp", ".", "SequenceNumber", "(", ")", ")", "\n", "t", ".", "inbound", ".", "una", "=", "irs", "\n", "t", ".", "inbound", ".", "nxt", "=", "irs", ".", "Add", "(", "logicalLen", "(", "tcp", ")", ")", "\n", "t", ".", "inbound", ".", "end", "+=", "irs", "\n\n", "t", ".", "outbound", ".", "end", "=", "t", ".", "outbound", ".", "una", ".", "Add", "(", "seqnum", ".", "Size", "(", "tcp", ".", "WindowSize", "(", ")", ")", ")", "\n\n", "// If the ACK was set (it is acceptable), update our unacknowledgement", "// tracking.", "if", "ackPresent", "{", "// Advance the \"una\" and \"end\" indices of the outbound stream.", "if", "t", ".", "outbound", ".", "una", ".", "LessThan", "(", "ack", ")", "{", "t", ".", "outbound", ".", "una", "=", "ack", "\n", "}", "\n\n", "if", "end", ":=", "ack", ".", "Add", "(", "seqnum", ".", "Size", "(", "tcp", ".", "WindowSize", "(", ")", ")", ")", ";", "t", ".", "outbound", ".", "end", ".", "LessThan", "(", "end", ")", "{", "t", ".", "outbound", ".", "end", "=", "end", "\n", "}", "\n", "}", "\n\n", "// Update handlers so that new calls will be handled by new state.", "t", ".", "handlerInbound", "=", "allOtherInbound", "\n", "t", ".", "handlerOutbound", "=", "allOtherOutbound", "\n\n", "return", "ResultAlive", "\n", "}" ]

[ "synSentStateInbound", "is", "the", "state", "handler", "for", "inbound", "segments", "when", "the", "connection", "is", "in", "SYN", "-", "SENT", "state", "." ]

[ "func", "synSentStateOutbound", "(", "t", "*", "TCB", ",", "tcp", "header", ".", "TCP", ")", "Result", "{", "// Drop outbound segments that aren't retransmits of the original one.", "if", "tcp", ".", "Flags", "(", ")", "!=", "header", ".", "TCPFlagSyn", "||", "tcp", ".", "SequenceNumber", "(", ")", "!=", "uint32", "(", "t", ".", "outbound", ".", "una", ")", "{", "return", "ResultDrop", "\n", "}", "\n\n", "// Update the receive window. We only remember the largest value seen.", "if", "wnd", ":=", "seqnum", ".", "Value", "(", "tcp", ".", "WindowSize", "(", ")", ")", ";", "wnd", ">", "t", ".", "inbound", ".", "end", "{", "t", ".", "inbound", ".", "end", "=", "wnd", "\n", "}", "\n\n", "return", "ResultConnecting", "\n", "}" ]

[ "synSentStateOutbound", "is", "the", "state", "handler", "for", "outbound", "segments", "when", "the", "connection", "is", "in", "SYN", "-", "SENT", "state", "." ]

[ "func", "allOtherInbound", "(", "t", "*", "TCB", ",", "tcp", "header", ".", "TCP", ")", "Result", "{", "return", "t", ".", "adaptResult", "(", "update", "(", "tcp", ",", "&", "t", ".", "inbound", ",", "&", "t", ".", "outbound", ",", "&", "t", ".", "firstFin", ")", ")", "\n", "}" ]

[ "allOtherInbound", "is", "the", "state", "handler", "for", "inbound", "segments", "in", "all", "states", "except", "SYN", "-", "SENT", "." ]

[ "func", "(", "s", "*", "stream", ")", "acceptable", "(", "segSeq", "seqnum", ".", "Value", ",", "segLen", "seqnum", ".", "Size", ")", "bool", "{", "wnd", ":=", "s", ".", "una", ".", "Size", "(", "s", ".", "end", ")", "\n", "if", "wnd", "==", "0", "{", "return", "segLen", "==", "0", "&&", "segSeq", "==", "s", ".", "una", "\n", "}", "\n\n", "// Make sure [segSeq, seqSeq+segLen) is non-empty.", "if", "segLen", "==", "0", "{", "segLen", "=", "1", "\n", "}", "\n\n", "return", "seqnum", ".", "Overlap", "(", "s", ".", "una", ",", "wnd", ",", "segSeq", ",", "segLen", ")", "\n", "}" ]

[ "acceptable", "determines", "if", "the", "segment", "with", "the", "given", "sequence", "number", "and", "data", "length", "is", "acceptable", "i", ".", "e", ".", "if", "it", "s", "within", "the", "[", "una", "end", ")", "window", "or", "in", "case", "the", "window", "is", "zero", "if", "it", "s", "a", "packet", "with", "no", "payload", "and", "sequence", "number", "equal", "to", "una", "." ]

[ "func", "(", "s", "*", "stream", ")", "closed", "(", ")", "bool", "{", "return", "s", ".", "finSeen", "&&", "s", ".", "fin", ".", "LessThan", "(", "s", ".", "una", ")", "\n", "}" ]

[ "closed", "determines", "if", "the", "stream", "has", "already", "been", "closed", ".", "This", "happens", "when", "a", "FIN", "has", "been", "set", "by", "the", "sender", "and", "acknowledged", "by", "the", "receiver", "." ]

[ "func", "dataLen", "(", "tcp", "header", ".", "TCP", ")", "seqnum", ".", "Size", "{", "return", "seqnum", ".", "Size", "(", "len", "(", "tcp", ")", "-", "int", "(", "tcp", ".", "DataOffset", "(", ")", ")", ")", "\n", "}" ]

[ "dataLen", "returns", "the", "length", "of", "the", "TCP", "segment", "payload", "." ]

[ "func", "logicalLen", "(", "tcp", "header", ".", "TCP", ")", "seqnum", ".", "Size", "{", "l", ":=", "dataLen", "(", "tcp", ")", "\n", "flags", ":=", "tcp", ".", "Flags", "(", ")", "\n", "if", "flags", "&", "header", ".", "TCPFlagSyn", "!=", "0", "{", "l", "++", "\n", "}", "\n", "if", "flags", "&", "header", ".", "TCPFlagFin", "!=", "0", "{", "l", "++", "\n", "}", "\n", "return", "l", "\n", "}" ]

[ "logicalLen", "calculates", "the", "logical", "length", "of", "the", "TCP", "segment", "." ]

[ "func", "(", "h", "segmentHeap", ")", "Less", "(", "i", ",", "j", "int", ")", "bool", "{", "return", "h", "[", "i", "]", ".", "sequenceNumber", ".", "LessThan", "(", "h", "[", "j", "]", ".", "sequenceNumber", ")", "\n", "}" ]

[ "Less", "determines", "whether", "the", "i", "-", "th", "element", "of", "h", "is", "less", "than", "the", "j", "-", "th", "element", "." ]

[ "func", "(", "h", "segmentHeap", ")", "Swap", "(", "i", ",", "j", "int", ")", "{", "h", "[", "i", "]", ",", "h", "[", "j", "]", "=", "h", "[", "j", "]", ",", "h", "[", "i", "]", "\n", "}" ]

[ "Swap", "swaps", "the", "i", "-", "th", "and", "j", "-", "th", "elements", "of", "h", "." ]

[ "func", "(", "h", "*", "segmentHeap", ")", "Pop", "(", ")", "interface", "{", "}", "{", "old", ":=", "*", "h", "\n", "n", ":=", "len", "(", "old", ")", "\n", "x", ":=", "old", "[", "n", "-", "1", "]", "\n", "*", "h", "=", "old", "[", ":", "n", "-", "1", "]", "\n", "return", "x", "\n", "}" ]

[ "Pop", "removes", "the", "last", "element", "of", "h", "and", "returns", "it", "." ]

[ "func", "NewSACKScoreboard", "(", "smss", "uint16", ",", "iss", "seqnum", ".", "Value", ")", "*", "SACKScoreboard", "{", "return", "&", "SACKScoreboard", "{", "smss", ":", "smss", ",", "ranges", ":", "btree", ".", "New", "(", "defaultBtreeDegree", ")", ",", "maxSACKED", ":", "iss", ",", "}", "\n", "}" ]

[ "NewSACKScoreboard", "returns", "a", "new", "SACK", "Scoreboard", "." ]

[ "func", "(", "s", "*", "SACKScoreboard", ")", "Reset", "(", ")", "{", "s", ".", "ranges", "=", "btree", ".", "New", "(", "defaultBtreeDegree", ")", "\n", "s", ".", "sacked", "=", "0", "\n", "}" ]

[ "Reset", "erases", "all", "known", "range", "information", "from", "the", "SACK", "scoreboard", "." ]

[ "func", "(", "s", "*", "SACKScoreboard", ")", "IsSACKED", "(", "r", "header", ".", "SACKBlock", ")", "bool", "{", "found", ":=", "false", "\n", "s", ".", "ranges", ".", "DescendLessOrEqual", "(", "r", ",", "func", "(", "i", "btree", ".", "Item", ")", "bool", "{", "sacked", ":=", "i", ".", "(", "header", ".", "SACKBlock", ")", "\n", "if", "sacked", ".", "End", ".", "LessThan", "(", "r", ".", "Start", ")", "{", "return", "false", "\n", "}", "\n", "if", "sacked", ".", "Contains", "(", "r", ")", "{", "found", "=", "true", "\n", "return", "false", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n", "return", "found", "\n", "}" ]

[ "IsSACKED", "returns", "true", "if", "the", "a", "given", "range", "of", "sequence", "numbers", "denoted", "by", "r", "are", "already", "covered", "by", "SACK", "information", "in", "the", "scoreboard", "." ]

[ "func", "(", "s", "*", "SACKScoreboard", ")", "String", "(", ")", "string", "{", "var", "str", "strings", ".", "Builder", "\n", "str", ".", "WriteString", "(", "\"", "\"", ")", "\n", "s", ".", "ranges", ".", "Ascend", "(", "func", "(", "i", "btree", ".", "Item", ")", "bool", "{", "str", ".", "WriteString", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "i", ")", ")", "\n", "return", "true", "\n", "}", ")", "\n", "str", ".", "WriteString", "(", "\"", "\\n", "\"", ")", "\n", "return", "str", ".", "String", "(", ")", "\n", "}" ]

[ "Dump", "prints", "the", "state", "of", "the", "scoreboard", "structure", "." ]

[ "func", "(", "s", "*", "SACKScoreboard", ")", "Delete", "(", "seq", "seqnum", ".", "Value", ")", "{", "if", "s", ".", "Empty", "(", ")", "{", "return", "\n", "}", "\n", "toDelete", ":=", "[", "]", "btree", ".", "Item", "{", "}", "\n", "toInsert", ":=", "[", "]", "btree", ".", "Item", "{", "}", "\n", "r", ":=", "header", ".", "SACKBlock", "{", "seq", ",", "seq", ".", "Add", "(", "1", ")", "}", "\n", "s", ".", "ranges", ".", "DescendLessOrEqual", "(", "r", ",", "func", "(", "i", "btree", ".", "Item", ")", "bool", "{", "if", "i", "==", "r", "{", "return", "true", "\n", "}", "\n", "sb", ":=", "i", ".", "(", "header", ".", "SACKBlock", ")", "\n", "toDelete", "=", "append", "(", "toDelete", ",", "i", ")", "\n", "if", "sb", ".", "End", ".", "LessThanEq", "(", "seq", ")", "{", "s", ".", "sacked", "-=", "sb", ".", "Start", ".", "Size", "(", "sb", ".", "End", ")", "\n", "}", "else", "{", "newSB", ":=", "header", ".", "SACKBlock", "{", "seq", ",", "sb", ".", "End", "}", "\n", "toInsert", "=", "append", "(", "toInsert", ",", "newSB", ")", "\n", "s", ".", "sacked", "-=", "sb", ".", "Start", ".", "Size", "(", "seq", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n", "for", "_", ",", "sb", ":=", "range", "toDelete", "{", "s", ".", "ranges", ".", "Delete", "(", "sb", ")", "\n", "}", "\n", "for", "_", ",", "sb", ":=", "range", "toInsert", "{", "s", ".", "ranges", ".", "ReplaceOrInsert", "(", "sb", ")", "\n", "}", "\n", "}" ]

[ "Delete", "removes", "all", "SACK", "information", "prior", "to", "seq", "." ]

[ "func", "(", "s", "*", "SACKScoreboard", ")", "Copy", "(", ")", "(", "sackBlocks", "[", "]", "header", ".", "SACKBlock", ",", "maxSACKED", "seqnum", ".", "Value", ")", "{", "s", ".", "ranges", ".", "Ascend", "(", "func", "(", "i", "btree", ".", "Item", ")", "bool", "{", "sackBlocks", "=", "append", "(", "sackBlocks", ",", "i", ".", "(", "header", ".", "SACKBlock", ")", ")", "\n", "return", "true", "\n", "}", ")", "\n", "return", "sackBlocks", ",", "s", ".", "maxSACKED", "\n", "}" ]

[ "Copy", "provides", "a", "copy", "of", "the", "SACK", "scoreboard", "." ]

[ "func", "(", "q", "*", "Queue", ")", "EventRegister", "(", "e", "*", "Entry", ",", "mask", "EventMask", ")", "{", "q", ".", "mu", ".", "Lock", "(", ")", "\n", "e", ".", "mask", "=", "mask", "\n", "q", ".", "list", ".", "PushBack", "(", "e", ")", "\n", "q", ".", "mu", ".", "Unlock", "(", ")", "\n", "}" ]

[ "EventRegister", "adds", "a", "waiter", "to", "the", "wait", "queue", ";", "the", "waiter", "will", "be", "notified", "when", "at", "least", "one", "of", "the", "events", "specified", "in", "mask", "happens", "." ]

[ "func", "(", "q", "*", "Queue", ")", "EventUnregister", "(", "e", "*", "Entry", ")", "{", "q", ".", "mu", ".", "Lock", "(", ")", "\n", "q", ".", "list", ".", "Remove", "(", "e", ")", "\n", "q", ".", "mu", ".", "Unlock", "(", ")", "\n", "}" ]

[ "EventUnregister", "removes", "the", "given", "waiter", "entry", "from", "the", "wait", "queue", "." ]

[ "func", "(", "q", "*", "Queue", ")", "Notify", "(", "mask", "EventMask", ")", "{", "q", ".", "mu", ".", "RLock", "(", ")", "\n", "for", "e", ":=", "q", ".", "list", ".", "Front", "(", ")", ";", "e", "!=", "nil", ";", "e", "=", "e", ".", "Next", "(", ")", "{", "if", "mask", "&", "e", ".", "mask", "!=", "0", "{", "e", ".", "Callback", ".", "Callback", "(", "e", ")", "\n", "}", "\n", "}", "\n", "q", ".", "mu", ".", "RUnlock", "(", ")", "\n", "}" ]

[ "Notify", "notifies", "all", "waiters", "in", "the", "queue", "whose", "masks", "have", "at", "least", "one", "bit", "in", "common", "with", "the", "notification", "mask", "." ]

[ "func", "(", "q", "*", "Queue", ")", "Events", "(", ")", "EventMask", "{", "ret", ":=", "EventMask", "(", "0", ")", "\n\n", "q", ".", "mu", ".", "RLock", "(", ")", "\n", "for", "e", ":=", "q", ".", "list", ".", "Front", "(", ")", ";", "e", "!=", "nil", ";", "e", "=", "e", ".", "Next", "(", ")", "{", "ret", "|=", "e", ".", "mask", "\n", "}", "\n", "q", ".", "mu", ".", "RUnlock", "(", ")", "\n\n", "return", "ret", "\n", "}" ]

[ "Events", "returns", "the", "set", "of", "events", "being", "waited", "on", ".", "It", "is", "the", "union", "of", "the", "masks", "of", "all", "registered", "entries", "." ]

[ "func", "(", "q", "*", "Queue", ")", "IsEmpty", "(", ")", "bool", "{", "q", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "q", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "return", "q", ".", "list", ".", "Front", "(", ")", "==", "nil", "\n", "}" ]

[ "IsEmpty", "returns", "if", "the", "wait", "queue", "is", "empty", "or", "not", "." ]

[ "func", "(", "b", "GUE", ")", "Encode", "(", "i", "*", "GUEFields", ")", "{", "ctl", ":=", "uint8", "(", "0", ")", "\n", "if", "i", ".", "Control", "{", "ctl", "=", "1", "<<", "5", "\n", "}", "\n", "b", "[", "typeHLen", "]", "=", "ctl", "|", "i", ".", "Type", "<<", "6", "|", "(", "i", ".", "HeaderLength", "-", "4", ")", "/", "4", "\n", "b", "[", "encapProto", "]", "=", "i", ".", "Protocol", "\n", "}" ]

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

[ "func", "ParseRSAPrivateKeyFromPEM", "(", "key", "[", "]", "byte", ")", "(", "*", "rsa", ".", "PrivateKey", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// Parse PEM block", "var", "block", "*", "pem", ".", "Block", "\n", "if", "block", ",", "_", "=", "pem", ".", "Decode", "(", "key", ")", ";", "block", "==", "nil", "{", "return", "nil", ",", "ErrKeyMustBePEMEncoded", "\n", "}", "\n\n", "var", "parsedKey", "interface", "{", "}", "\n", "if", "parsedKey", ",", "err", "=", "x509", ".", "ParsePKCS1PrivateKey", "(", "block", ".", "Bytes", ")", ";", "err", "!=", "nil", "{", "if", "parsedKey", ",", "err", "=", "x509", ".", "ParsePKCS8PrivateKey", "(", "block", ".", "Bytes", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "var", "pkey", "*", "rsa", ".", "PrivateKey", "\n", "var", "ok", "bool", "\n", "if", "pkey", ",", "ok", "=", "parsedKey", ".", "(", "*", "rsa", ".", "PrivateKey", ")", ";", "!", "ok", "{", "return", "nil", ",", "ErrNotRSAPrivateKey", "\n", "}", "\n\n", "return", "pkey", ",", "nil", "\n", "}" ]

[ "Parse", "PEM", "encoded", "PKCS1", "or", "PKCS8", "private", "key" ]

[ "func", "ParseRSAPrivateKeyFromPEMWithPassword", "(", "key", "[", "]", "byte", ",", "password", "string", ")", "(", "*", "rsa", ".", "PrivateKey", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// Parse PEM block", "var", "block", "*", "pem", ".", "Block", "\n", "if", "block", ",", "_", "=", "pem", ".", "Decode", "(", "key", ")", ";", "block", "==", "nil", "{", "return", "nil", ",", "ErrKeyMustBePEMEncoded", "\n", "}", "\n\n", "var", "parsedKey", "interface", "{", "}", "\n\n", "var", "blockDecrypted", "[", "]", "byte", "\n", "if", "blockDecrypted", ",", "err", "=", "x509", ".", "DecryptPEMBlock", "(", "block", ",", "[", "]", "byte", "(", "password", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "parsedKey", ",", "err", "=", "x509", ".", "ParsePKCS1PrivateKey", "(", "blockDecrypted", ")", ";", "err", "!=", "nil", "{", "if", "parsedKey", ",", "err", "=", "x509", ".", "ParsePKCS8PrivateKey", "(", "blockDecrypted", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "var", "pkey", "*", "rsa", ".", "PrivateKey", "\n", "var", "ok", "bool", "\n", "if", "pkey", ",", "ok", "=", "parsedKey", ".", "(", "*", "rsa", ".", "PrivateKey", ")", ";", "!", "ok", "{", "return", "nil", ",", "ErrNotRSAPrivateKey", "\n", "}", "\n\n", "return", "pkey", ",", "nil", "\n", "}" ]

[ "Parse", "PEM", "encoded", "PKCS1", "or", "PKCS8", "private", "key", "protected", "with", "password" ]

[ "func", "ParseRSAPublicKeyFromPEM", "(", "key", "[", "]", "byte", ")", "(", "*", "rsa", ".", "PublicKey", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// Parse PEM block", "var", "block", "*", "pem", ".", "Block", "\n", "if", "block", ",", "_", "=", "pem", ".", "Decode", "(", "key", ")", ";", "block", "==", "nil", "{", "return", "nil", ",", "ErrKeyMustBePEMEncoded", "\n", "}", "\n\n", "// Parse the key", "var", "parsedKey", "interface", "{", "}", "\n", "if", "parsedKey", ",", "err", "=", "x509", ".", "ParsePKIXPublicKey", "(", "block", ".", "Bytes", ")", ";", "err", "!=", "nil", "{", "if", "cert", ",", "err", ":=", "x509", ".", "ParseCertificate", "(", "block", ".", "Bytes", ")", ";", "err", "==", "nil", "{", "parsedKey", "=", "cert", ".", "PublicKey", "\n", "}", "else", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "var", "pkey", "*", "rsa", ".", "PublicKey", "\n", "var", "ok", "bool", "\n", "if", "pkey", ",", "ok", "=", "parsedKey", ".", "(", "*", "rsa", ".", "PublicKey", ")", ";", "!", "ok", "{", "return", "nil", ",", "ErrNotRSAPublicKey", "\n", "}", "\n\n", "return", "pkey", ",", "nil", "\n", "}" ]

[ "Parse", "PEM", "encoded", "PKCS1", "or", "PKCS8", "public", "key" ]

[ "func", "(", "m", "*", "SigningMethodECDSA", ")", "Verify", "(", "signingString", ",", "signature", "string", ",", "key", "interface", "{", "}", ")", "error", "{", "var", "err", "error", "\n\n", "// Decode the signature", "var", "sig", "[", "]", "byte", "\n", "if", "sig", ",", "err", "=", "DecodeSegment", "(", "signature", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Get the key", "var", "ecdsaKey", "*", "ecdsa", ".", "PublicKey", "\n", "switch", "k", ":=", "key", ".", "(", "type", ")", "{", "case", "*", "ecdsa", ".", "PublicKey", ":", "ecdsaKey", "=", "k", "\n", "default", ":", "return", "ErrInvalidKeyType", "\n", "}", "\n\n", "if", "len", "(", "sig", ")", "!=", "2", "*", "m", ".", "KeySize", "{", "return", "ErrECDSAVerification", "\n", "}", "\n\n", "r", ":=", "big", ".", "NewInt", "(", "0", ")", ".", "SetBytes", "(", "sig", "[", ":", "m", ".", "KeySize", "]", ")", "\n", "s", ":=", "big", ".", "NewInt", "(", "0", ")", ".", "SetBytes", "(", "sig", "[", "m", ".", "KeySize", ":", "]", ")", "\n\n", "// Create hasher", "if", "!", "m", ".", "Hash", ".", "Available", "(", ")", "{", "return", "ErrHashUnavailable", "\n", "}", "\n", "hasher", ":=", "m", ".", "Hash", ".", "New", "(", ")", "\n", "hasher", ".", "Write", "(", "[", "]", "byte", "(", "signingString", ")", ")", "\n\n", "// Verify the signature", "if", "verifystatus", ":=", "ecdsa", ".", "Verify", "(", "ecdsaKey", ",", "hasher", ".", "Sum", "(", "nil", ")", ",", "r", ",", "s", ")", ";", "verifystatus", "==", "true", "{", "return", "nil", "\n", "}", "else", "{", "return", "ErrECDSAVerification", "\n", "}", "\n", "}" ]

[ "Implements", "the", "Verify", "method", "from", "SigningMethod", "For", "this", "verify", "method", "key", "must", "be", "an", "ecdsa", ".", "PublicKey", "struct" ]

[ "func", "(", "m", "*", "SigningMethodECDSA", ")", "Sign", "(", "signingString", "string", ",", "key", "interface", "{", "}", ")", "(", "string", ",", "error", ")", "{", "// Get the key", "var", "ecdsaKey", "*", "ecdsa", ".", "PrivateKey", "\n", "switch", "k", ":=", "key", ".", "(", "type", ")", "{", "case", "*", "ecdsa", ".", "PrivateKey", ":", "ecdsaKey", "=", "k", "\n", "default", ":", "return", "\"", "\"", ",", "ErrInvalidKeyType", "\n", "}", "\n\n", "// Create the hasher", "if", "!", "m", ".", "Hash", ".", "Available", "(", ")", "{", "return", "\"", "\"", ",", "ErrHashUnavailable", "\n", "}", "\n\n", "hasher", ":=", "m", ".", "Hash", ".", "New", "(", ")", "\n", "hasher", ".", "Write", "(", "[", "]", "byte", "(", "signingString", ")", ")", "\n\n", "// Sign the string and return r, s", "if", "r", ",", "s", ",", "err", ":=", "ecdsa", ".", "Sign", "(", "rand", ".", "Reader", ",", "ecdsaKey", ",", "hasher", ".", "Sum", "(", "nil", ")", ")", ";", "err", "==", "nil", "{", "curveBits", ":=", "ecdsaKey", ".", "Curve", ".", "Params", "(", ")", ".", "BitSize", "\n\n", "if", "m", ".", "CurveBits", "!=", "curveBits", "{", "return", "\"", "\"", ",", "ErrInvalidKey", "\n", "}", "\n\n", "keyBytes", ":=", "curveBits", "/", "8", "\n", "if", "curveBits", "%", "8", ">", "0", "{", "keyBytes", "+=", "1", "\n", "}", "\n\n", "// We serialize the outpus (r and s) into big-endian byte arrays and pad", "// them with zeros on the left to make sure the sizes work out. Both arrays", "// must be keyBytes long, and the output must be 2*keyBytes long.", "rBytes", ":=", "r", ".", "Bytes", "(", ")", "\n", "rBytesPadded", ":=", "make", "(", "[", "]", "byte", ",", "keyBytes", ")", "\n", "copy", "(", "rBytesPadded", "[", "keyBytes", "-", "len", "(", "rBytes", ")", ":", "]", ",", "rBytes", ")", "\n\n", "sBytes", ":=", "s", ".", "Bytes", "(", ")", "\n", "sBytesPadded", ":=", "make", "(", "[", "]", "byte", ",", "keyBytes", ")", "\n", "copy", "(", "sBytesPadded", "[", "keyBytes", "-", "len", "(", "sBytes", ")", ":", "]", ",", "sBytes", ")", "\n\n", "out", ":=", "append", "(", "rBytesPadded", ",", "sBytesPadded", "...", ")", "\n\n", "return", "EncodeSegment", "(", "out", ")", ",", "nil", "\n", "}", "else", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "}" ]

[ "Implements", "the", "Sign", "method", "from", "SigningMethod", "For", "this", "signing", "method", "key", "must", "be", "an", "ecdsa", ".", "PrivateKey", "struct" ]

[ "func", "start", "(", ")", "error", "{", "if", "*", "flagSign", "!=", "\"", "\"", "{", "return", "signToken", "(", ")", "\n", "}", "else", "if", "*", "flagVerify", "!=", "\"", "\"", "{", "return", "verifyToken", "(", ")", "\n", "}", "else", "if", "*", "flagShow", "!=", "\"", "\"", "{", "return", "showToken", "(", ")", "\n", "}", "else", "{", "flag", ".", "Usage", "(", ")", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "Figure", "out", "which", "thing", "to", "do", "and", "then", "do", "that" ]

[ "func", "verifyToken", "(", ")", "error", "{", "// get the token", "tokData", ",", "err", ":=", "loadData", "(", "*", "flagVerify", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// trim possible whitespace from token", "tokData", "=", "regexp", ".", "MustCompile", "(", "`\\s*$`", ")", ".", "ReplaceAll", "(", "tokData", ",", "[", "]", "byte", "{", "}", ")", "\n", "if", "*", "flagDebug", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "len", "(", "tokData", ")", ")", "\n", "}", "\n\n", "// Parse the token. Load the key from command line option", "token", ",", "err", ":=", "jwt", ".", "Parse", "(", "string", "(", "tokData", ")", ",", "func", "(", "t", "*", "jwt", ".", "Token", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "data", ",", "err", ":=", "loadData", "(", "*", "flagKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "isEs", "(", ")", "{", "return", "jwt", ".", "ParseECPublicKeyFromPEM", "(", "data", ")", "\n", "}", "else", "if", "isRs", "(", ")", "{", "return", "jwt", ".", "ParseRSAPublicKeyFromPEM", "(", "data", ")", "\n", "}", "\n", "return", "data", ",", "nil", "\n", "}", ")", "\n\n", "// Print some debug data", "if", "*", "flagDebug", "&&", "token", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\\n", "\"", ",", "token", ".", "Header", ")", "\n", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\\n", "\"", ",", "token", ".", "Claims", ")", "\n", "}", "\n\n", "// Print an error if we can't parse for some reason", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Is token invalid?", "if", "!", "token", ".", "Valid", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Print the token details", "if", "err", ":=", "printJSON", "(", "token", ".", "Claims", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Verify", "a", "token", "and", "output", "the", "claims", ".", "This", "is", "a", "great", "example", "of", "how", "to", "verify", "and", "view", "a", "token", "." ]

[ "func", "signToken", "(", ")", "error", "{", "// get the token data from command line arguments", "tokData", ",", "err", ":=", "loadData", "(", "*", "flagSign", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "else", "if", "*", "flagDebug", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\"", ",", "len", "(", "tokData", ")", ")", "\n", "}", "\n\n", "// parse the JSON of the claims", "var", "claims", "jwt", ".", "MapClaims", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "tokData", ",", "&", "claims", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// add command line claims", "if", "len", "(", "flagClaims", ")", ">", "0", "{", "for", "k", ",", "v", ":=", "range", "flagClaims", "{", "claims", "[", "k", "]", "=", "v", "\n", "}", "\n", "}", "\n\n", "// get the key", "var", "key", "interface", "{", "}", "\n", "key", ",", "err", "=", "loadData", "(", "*", "flagKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// get the signing alg", "alg", ":=", "jwt", ".", "GetSigningMethod", "(", "*", "flagAlg", ")", "\n", "if", "alg", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "*", "flagAlg", ")", "\n", "}", "\n\n", "// create a new token", "token", ":=", "jwt", ".", "NewWithClaims", "(", "alg", ",", "claims", ")", "\n\n", "// add command line headers", "if", "len", "(", "flagHead", ")", ">", "0", "{", "for", "k", ",", "v", ":=", "range", "flagHead", "{", "token", ".", "Header", "[", "k", "]", "=", "v", "\n", "}", "\n", "}", "\n\n", "if", "isEs", "(", ")", "{", "if", "k", ",", "ok", ":=", "key", ".", "(", "[", "]", "byte", ")", ";", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "else", "{", "key", ",", "err", "=", "jwt", ".", "ParseECPrivateKeyFromPEM", "(", "k", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "else", "if", "isRs", "(", ")", "{", "if", "k", ",", "ok", ":=", "key", ".", "(", "[", "]", "byte", ")", ";", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "else", "{", "key", ",", "err", "=", "jwt", ".", "ParseRSAPrivateKeyFromPEM", "(", "k", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "out", ",", "err", ":=", "token", ".", "SignedString", "(", "key", ")", ";", "err", "==", "nil", "{", "fmt", ".", "Println", "(", "out", ")", "\n", "}", "else", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Create", "sign", "and", "output", "a", "token", ".", "This", "is", "a", "great", "simple", "example", "of", "how", "to", "use", "this", "library", "to", "create", "and", "sign", "a", "token", "." ]

[ "func", "showToken", "(", ")", "error", "{", "// get the token", "tokData", ",", "err", ":=", "loadData", "(", "*", "flagShow", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// trim possible whitespace from token", "tokData", "=", "regexp", ".", "MustCompile", "(", "`\\s*$`", ")", ".", "ReplaceAll", "(", "tokData", ",", "[", "]", "byte", "{", "}", ")", "\n", "if", "*", "flagDebug", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "len", "(", "tokData", ")", ")", "\n", "}", "\n\n", "token", ",", "err", ":=", "jwt", ".", "Parse", "(", "string", "(", "tokData", ")", ",", "nil", ")", "\n", "if", "token", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Print the token details", "fmt", ".", "Println", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "printJSON", "(", "token", ".", "Header", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "fmt", ".", "Println", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "printJSON", "(", "token", ".", "Claims", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "showToken", "pretty", "-", "prints", "the", "token", "on", "the", "command", "line", "." ]

[ "func", "stripBearerPrefixFromTokenString", "(", "tok", "string", ")", "(", "string", ",", "error", ")", "{", "// Should be a bearer token", "if", "len", "(", "tok", ")", ">", "6", "&&", "strings", ".", "ToUpper", "(", "tok", "[", "0", ":", "7", "]", ")", "==", "\"", "\"", "{", "return", "tok", "[", "7", ":", "]", ",", "nil", "\n", "}", "\n", "return", "tok", ",", "nil", "\n", "}" ]

[ "Strips", "Bearer", "prefix", "from", "bearer", "token", "string" ]

[ "func", "(", "t", "*", "Token", ")", "SignedString", "(", "key", "interface", "{", "}", ")", "(", "string", ",", "error", ")", "{", "var", "sig", ",", "sstr", "string", "\n", "var", "err", "error", "\n", "if", "sstr", ",", "err", "=", "t", ".", "SigningString", "(", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "sig", ",", "err", "=", "t", ".", "Method", ".", "Sign", "(", "sstr", ",", "key", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "[", "]", "string", "{", "sstr", ",", "sig", "}", ",", "\"", "\"", ")", ",", "nil", "\n", "}" ]

[ "Get", "the", "complete", "signed", "token" ]

[ "func", "(", "t", "*", "Token", ")", "SigningString", "(", ")", "(", "string", ",", "error", ")", "{", "var", "err", "error", "\n", "parts", ":=", "make", "(", "[", "]", "string", ",", "2", ")", "\n", "for", "i", ",", "_", ":=", "range", "parts", "{", "var", "jsonValue", "[", "]", "byte", "\n", "if", "i", "==", "0", "{", "if", "jsonValue", ",", "err", "=", "json", ".", "Marshal", "(", "t", ".", "Header", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "}", "else", "{", "if", "jsonValue", ",", "err", "=", "json", ".", "Marshal", "(", "t", ".", "Claims", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "}", "\n\n", "parts", "[", "i", "]", "=", "EncodeSegment", "(", "jsonValue", ")", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "parts", ",", "\"", "\"", ")", ",", "nil", "\n", "}" ]

[ "Generate", "the", "signing", "string", ".", "This", "is", "the", "most", "expensive", "part", "of", "the", "whole", "deal", ".", "Unless", "you", "need", "this", "for", "something", "special", "just", "go", "straight", "for", "the", "SignedString", "." ]

[ "func", "EncodeSegment", "(", "seg", "[", "]", "byte", ")", "string", "{", "return", "strings", ".", "TrimRight", "(", "base64", ".", "URLEncoding", ".", "EncodeToString", "(", "seg", ")", ",", "\"", "\"", ")", "\n", "}" ]

[ "Encode", "JWT", "specific", "base64url", "encoding", "with", "padding", "stripped" ]

[ "func", "DecodeSegment", "(", "seg", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "l", ":=", "len", "(", "seg", ")", "%", "4", ";", "l", ">", "0", "{", "seg", "+=", "strings", ".", "Repeat", "(", "\"", "\"", ",", "4", "-", "l", ")", "\n", "}", "\n\n", "return", "base64", ".", "URLEncoding", ".", "DecodeString", "(", "seg", ")", "\n", "}" ]

[ "Decode", "JWT", "specific", "base64url", "encoding", "with", "padding", "stripped" ]

[ "func", "NewValidationError", "(", "errorText", "string", ",", "errorFlags", "uint32", ")", "*", "ValidationError", "{", "return", "&", "ValidationError", "{", "text", ":", "errorText", ",", "Errors", ":", "errorFlags", ",", "}", "\n", "}" ]

[ "Helper", "for", "constructing", "a", "ValidationError", "with", "a", "string", "error", "message" ]

[ "func", "(", "e", "ValidationError", ")", "Error", "(", ")", "string", "{", "if", "e", ".", "Inner", "!=", "nil", "{", "return", "e", ".", "Inner", ".", "Error", "(", ")", "\n", "}", "else", "if", "e", ".", "text", "!=", "\"", "\"", "{", "return", "e", ".", "text", "\n", "}", "else", "{", "return", "\"", "\"", "\n", "}", "\n", "}" ]

[ "Validation", "error", "is", "an", "error", "type" ]

[ "func", "GetSigningMethod", "(", "alg", "string", ")", "(", "method", "SigningMethod", ")", "{", "signingMethodLock", ".", "RLock", "(", ")", "\n", "defer", "signingMethodLock", ".", "RUnlock", "(", ")", "\n\n", "if", "methodF", ",", "ok", ":=", "signingMethods", "[", "alg", "]", ";", "ok", "{", "method", "=", "methodF", "(", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "Get", "a", "signing", "method", "from", "an", "alg", "string" ]

[ "func", "(", "m", "*", "SigningMethodRSAPSS", ")", "Verify", "(", "signingString", ",", "signature", "string", ",", "key", "interface", "{", "}", ")", "error", "{", "var", "err", "error", "\n\n", "// Decode the signature", "var", "sig", "[", "]", "byte", "\n", "if", "sig", ",", "err", "=", "DecodeSegment", "(", "signature", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "var", "rsaKey", "*", "rsa", ".", "PublicKey", "\n", "switch", "k", ":=", "key", ".", "(", "type", ")", "{", "case", "*", "rsa", ".", "PublicKey", ":", "rsaKey", "=", "k", "\n", "default", ":", "return", "ErrInvalidKey", "\n", "}", "\n\n", "// Create hasher", "if", "!", "m", ".", "Hash", ".", "Available", "(", ")", "{", "return", "ErrHashUnavailable", "\n", "}", "\n", "hasher", ":=", "m", ".", "Hash", ".", "New", "(", ")", "\n", "hasher", ".", "Write", "(", "[", "]", "byte", "(", "signingString", ")", ")", "\n\n", "return", "rsa", ".", "VerifyPSS", "(", "rsaKey", ",", "m", ".", "Hash", ",", "hasher", ".", "Sum", "(", "nil", ")", ",", "sig", ",", "m", ".", "Options", ")", "\n", "}" ]

[ "Implements", "the", "Verify", "method", "from", "SigningMethod", "For", "this", "verify", "method", "key", "must", "be", "an", "rsa", ".", "PublicKey", "struct" ]

[ "func", "(", "m", "*", "SigningMethodRSAPSS", ")", "Sign", "(", "signingString", "string", ",", "key", "interface", "{", "}", ")", "(", "string", ",", "error", ")", "{", "var", "rsaKey", "*", "rsa", ".", "PrivateKey", "\n\n", "switch", "k", ":=", "key", ".", "(", "type", ")", "{", "case", "*", "rsa", ".", "PrivateKey", ":", "rsaKey", "=", "k", "\n", "default", ":", "return", "\"", "\"", ",", "ErrInvalidKeyType", "\n", "}", "\n\n", "// Create the hasher", "if", "!", "m", ".", "Hash", ".", "Available", "(", ")", "{", "return", "\"", "\"", ",", "ErrHashUnavailable", "\n", "}", "\n\n", "hasher", ":=", "m", ".", "Hash", ".", "New", "(", ")", "\n", "hasher", ".", "Write", "(", "[", "]", "byte", "(", "signingString", ")", ")", "\n\n", "// Sign the string and return the encoded bytes", "if", "sigBytes", ",", "err", ":=", "rsa", ".", "SignPSS", "(", "rand", ".", "Reader", ",", "rsaKey", ",", "m", ".", "Hash", ",", "hasher", ".", "Sum", "(", "nil", ")", ",", "m", ".", "Options", ")", ";", "err", "==", "nil", "{", "return", "EncodeSegment", "(", "sigBytes", ")", ",", "nil", "\n", "}", "else", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "}" ]

[ "Implements", "the", "Sign", "method", "from", "SigningMethod", "For", "this", "signing", "method", "key", "must", "be", "an", "rsa", ".", "PrivateKey", "struct" ]

[ "func", "ParseECPrivateKeyFromPEM", "(", "key", "[", "]", "byte", ")", "(", "*", "ecdsa", ".", "PrivateKey", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// Parse PEM block", "var", "block", "*", "pem", ".", "Block", "\n", "if", "block", ",", "_", "=", "pem", ".", "Decode", "(", "key", ")", ";", "block", "==", "nil", "{", "return", "nil", ",", "ErrKeyMustBePEMEncoded", "\n", "}", "\n\n", "// Parse the key", "var", "parsedKey", "interface", "{", "}", "\n", "if", "parsedKey", ",", "err", "=", "x509", ".", "ParseECPrivateKey", "(", "block", ".", "Bytes", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "pkey", "*", "ecdsa", ".", "PrivateKey", "\n", "var", "ok", "bool", "\n", "if", "pkey", ",", "ok", "=", "parsedKey", ".", "(", "*", "ecdsa", ".", "PrivateKey", ")", ";", "!", "ok", "{", "return", "nil", ",", "ErrNotECPrivateKey", "\n", "}", "\n\n", "return", "pkey", ",", "nil", "\n", "}" ]

[ "Parse", "PEM", "encoded", "Elliptic", "Curve", "Private", "Key", "Structure" ]

[ "func", "(", "m", "*", "signingMethodNone", ")", "Verify", "(", "signingString", ",", "signature", "string", ",", "key", "interface", "{", "}", ")", "(", "err", "error", ")", "{", "// Key must be UnsafeAllowNoneSignatureType to prevent accidentally", "// accepting 'none' signing method", "if", "_", ",", "ok", ":=", "key", ".", "(", "unsafeNoneMagicConstant", ")", ";", "!", "ok", "{", "return", "NoneSignatureTypeDisallowedError", "\n", "}", "\n", "// If signing method is none, signature must be an empty string", "if", "signature", "!=", "\"", "\"", "{", "return", "NewValidationError", "(", "\"", "\"", ",", "ValidationErrorSignatureInvalid", ",", ")", "\n", "}", "\n\n", "// Accept 'none' signing method.", "return", "nil", "\n", "}" ]

[ "Only", "allow", "none", "alg", "type", "if", "UnsafeAllowNoneSignatureType", "is", "specified", "as", "the", "key" ]

[ "func", "(", "m", "*", "signingMethodNone", ")", "Sign", "(", "signingString", "string", ",", "key", "interface", "{", "}", ")", "(", "string", ",", "error", ")", "{", "if", "_", ",", "ok", ":=", "key", ".", "(", "unsafeNoneMagicConstant", ")", ";", "ok", "{", "return", "\"", "\"", ",", "nil", "\n", "}", "\n", "return", "\"", "\"", ",", "NoneSignatureTypeDisallowedError", "\n", "}" ]

[ "Only", "allow", "none", "signing", "if", "UnsafeAllowNoneSignatureType", "is", "specified", "as", "the", "key" ]

[ "func", "ParseFromRequest", "(", "req", "*", "http", ".", "Request", ",", "extractor", "Extractor", ",", "keyFunc", "jwt", ".", "Keyfunc", ",", "options", "...", "ParseFromRequestOption", ")", "(", "token", "*", "jwt", ".", "Token", ",", "err", "error", ")", "{", "// Create basic parser struct", "p", ":=", "&", "fromRequestParser", "{", "req", ",", "extractor", ",", "nil", ",", "nil", "}", "\n\n", "// Handle options", "for", "_", ",", "option", ":=", "range", "options", "{", "option", "(", "p", ")", "\n", "}", "\n\n", "// Set defaults", "if", "p", ".", "claims", "==", "nil", "{", "p", ".", "claims", "=", "jwt", ".", "MapClaims", "{", "}", "\n", "}", "\n", "if", "p", ".", "parser", "==", "nil", "{", "p", ".", "parser", "=", "&", "jwt", ".", "Parser", "{", "}", "\n", "}", "\n\n", "// perform extract", "tokenString", ",", "err", ":=", "p", ".", "extractor", ".", "ExtractToken", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// perform parse", "return", "p", ".", "parser", ".", "ParseWithClaims", "(", "tokenString", ",", "p", ".", "claims", ",", "keyFunc", ")", "\n", "}" ]

[ "Extract", "and", "parse", "a", "JWT", "token", "from", "an", "HTTP", "request", ".", "This", "behaves", "the", "same", "as", "Parse", "but", "accepts", "a", "request", "and", "an", "extractor", "instead", "of", "a", "token", "string", ".", "The", "Extractor", "interface", "allows", "you", "to", "define", "the", "logic", "for", "extracting", "a", "token", ".", "Several", "useful", "implementations", "are", "provided", ".", "You", "can", "provide", "options", "to", "modify", "parsing", "behavior" ]

[ "func", "WithClaims", "(", "claims", "jwt", ".", "Claims", ")", "ParseFromRequestOption", "{", "return", "func", "(", "p", "*", "fromRequestParser", ")", "{", "p", ".", "claims", "=", "claims", "\n", "}", "\n", "}" ]

[ "Parse", "with", "custom", "claims" ]

[ "func", "WithParser", "(", "parser", "*", "jwt", ".", "Parser", ")", "ParseFromRequestOption", "{", "return", "func", "(", "p", "*", "fromRequestParser", ")", "{", "p", ".", "parser", "=", "parser", "\n", "}", "\n", "}" ]

[ "Parse", "using", "a", "custom", "parser" ]

[ "func", "(", "m", "*", "SigningMethodHMAC", ")", "Verify", "(", "signingString", ",", "signature", "string", ",", "key", "interface", "{", "}", ")", "error", "{", "// Verify the key is the right type", "keyBytes", ",", "ok", ":=", "key", ".", "(", "[", "]", "byte", ")", "\n", "if", "!", "ok", "{", "return", "ErrInvalidKeyType", "\n", "}", "\n\n", "// Decode signature, for comparison", "sig", ",", "err", ":=", "DecodeSegment", "(", "signature", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Can we use the specified hashing method?", "if", "!", "m", ".", "Hash", ".", "Available", "(", ")", "{", "return", "ErrHashUnavailable", "\n", "}", "\n\n", "// This signing method is symmetric, so we validate the signature", "// by reproducing the signature from the signing string and key, then", "// comparing that against the provided signature.", "hasher", ":=", "hmac", ".", "New", "(", "m", ".", "Hash", ".", "New", ",", "keyBytes", ")", "\n", "hasher", ".", "Write", "(", "[", "]", "byte", "(", "signingString", ")", ")", "\n", "if", "!", "hmac", ".", "Equal", "(", "sig", ",", "hasher", ".", "Sum", "(", "nil", ")", ")", "{", "return", "ErrSignatureInvalid", "\n", "}", "\n\n", "// No validation errors. Signature is good.", "return", "nil", "\n", "}" ]

[ "Verify", "the", "signature", "of", "HSXXX", "tokens", ".", "Returns", "nil", "if", "the", "signature", "is", "valid", "." ]

[ "func", "ErrHandler", "(", "action", "Action", ")", "Action", "{", "return", "func", "(", "ctx", "*", "context", ".", "Context", ")", "error", "{", "var", "err", "=", "action", "(", "ctx", ")", "\n", "if", "err", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "if", "pipe", ".", "IsSkip", "(", "err", ")", "{", "log", ".", "WithError", "(", "err", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "err", "\n", "}", "\n", "}" ]

[ "ErrHandler", "handles", "an", "action", "error", "ignoring", "and", "logging", "pipe", "skipped", "errors", "." ]

[ "func", "remoteRepo", "(", ")", "(", "result", "config", ".", "Repo", ",", "err", "error", ")", "{", "if", "!", "git", ".", "IsRepo", "(", ")", "{", "return", "result", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "out", ",", "err", ":=", "git", ".", "Run", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "result", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "extractRepoFromURL", "(", "out", ")", ",", "nil", "\n", "}" ]

[ "remoteRepo", "gets", "the", "repo", "name", "from", "the", "Git", "config", "." ]

[ "func", "(", "a", "Artifact", ")", "ExtraOr", "(", "key", "string", ",", "or", "interface", "{", "}", ")", "interface", "{", "}", "{", "if", "a", ".", "Extra", "[", "key", "]", "==", "nil", "{", "return", "or", "\n", "}", "\n", "return", "a", ".", "Extra", "[", "key", "]", "\n", "}" ]

[ "ExtraOr", "returns", "the", "Extra", "field", "with", "the", "given", "key", "or", "the", "or", "value", "specified", "if", "it", "is", "nil", "." ]

[ "func", "(", "artifacts", "Artifacts", ")", "GroupByPlatform", "(", ")", "map", "[", "string", "]", "[", "]", "Artifact", "{", "var", "result", "=", "map", "[", "string", "]", "[", "]", "Artifact", "{", "}", "\n", "for", "_", ",", "a", ":=", "range", "artifacts", ".", "items", "{", "plat", ":=", "a", ".", "Goos", "+", "a", ".", "Goarch", "+", "a", ".", "Goarm", "\n", "result", "[", "plat", "]", "=", "append", "(", "result", "[", "plat", "]", ",", "a", ")", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "GroupByPlatform", "groups", "the", "artifacts", "by", "their", "platform" ]

[ "func", "(", "artifacts", "*", "Artifacts", ")", "Add", "(", "a", "Artifact", ")", "{", "artifacts", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "artifacts", ".", "lock", ".", "Unlock", "(", ")", "\n", "log", ".", "WithFields", "(", "log", ".", "Fields", "{", "\"", "\"", ":", "a", ".", "Name", ",", "\"", "\"", ":", "a", ".", "Path", ",", "\"", "\"", ":", "a", ".", "Type", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "artifacts", ".", "items", "=", "append", "(", "artifacts", ".", "items", ",", "a", ")", "\n", "}" ]

[ "Add", "safely", "adds", "a", "new", "artifact", "to", "an", "artifact", "list" ]

[ "func", "ByGoos", "(", "s", "string", ")", "Filter", "{", "return", "func", "(", "a", "Artifact", ")", "bool", "{", "return", "a", ".", "Goos", "==", "s", "\n", "}", "\n", "}" ]

[ "ByGoos", "is", "a", "predefined", "filter", "that", "filters", "by", "the", "given", "goos" ]

[ "func", "ByGoarch", "(", "s", "string", ")", "Filter", "{", "return", "func", "(", "a", "Artifact", ")", "bool", "{", "return", "a", ".", "Goarch", "==", "s", "\n", "}", "\n", "}" ]

[ "ByGoarch", "is", "a", "predefined", "filter", "that", "filters", "by", "the", "given", "goarch" ]

[ "func", "ByGoarm", "(", "s", "string", ")", "Filter", "{", "return", "func", "(", "a", "Artifact", ")", "bool", "{", "return", "a", ".", "Goarm", "==", "s", "\n", "}", "\n", "}" ]

[ "ByGoarm", "is", "a", "predefined", "filter", "that", "filters", "by", "the", "given", "goarm" ]