Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "d", "*", "Dock", ")", "Show", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "d", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "_", ",", "err", "=", "synchronousEvent", "(", "d", ".", "c", ",", "d", ",", "d", ".", "w", ",", "Event", "{", "Name", ":", "eventNameDockCmdShow", ",", "TargetID", ":", "d", ".", "id", "}", ",", "eventNameDockEventShown", ")", "\n", "return", "\n", "}" ]

[ "Show", "shows", "the", "dock" ]

[ "func", "Disembed", "(", "ctx", "context", ".", "Context", ",", "d", "Disembedder", ",", "src", ",", "dst", "string", ")", "(", "err", "error", ")", "{", "// Log", "astilog", ".", "Debugf", "(", "\"", "\"", ",", "src", ",", "dst", ")", "\n\n", "// No need to disembed", "if", "_", ",", "err", "=", "os", ".", "Stat", "(", "dst", ")", ";", "err", "!=", "nil", "&&", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "dst", ")", "\n", "}", "else", "if", "err", "==", "nil", "{", "astilog", ".", "Debugf", "(", "\"", "\"", ",", "dst", ")", "\n", "return", "\n", "}", "\n", "err", "=", "nil", "\n\n", "// Clean up on error", "defer", "func", "(", "err", "*", "error", ")", "{", "if", "*", "err", "!=", "nil", "||", "ctx", ".", "Err", "(", ")", "!=", "nil", "{", "astilog", ".", "Debugf", "(", "\"", "\"", ",", "dst", ")", "\n", "os", ".", "Remove", "(", "dst", ")", "\n", "}", "\n", "}", "(", "&", "err", ")", "\n\n", "// Make sure directory exists", "var", "dirPath", "=", "filepath", ".", "Dir", "(", "dst", ")", "\n", "astilog", ".", "Debugf", "(", "\"", "\"", ",", "dirPath", ")", "\n", "if", "err", "=", "os", ".", "MkdirAll", "(", "dirPath", ",", "0755", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "dirPath", ")", "\n", "}", "\n\n", "// Create dst", "var", "f", "*", "os", ".", "File", "\n", "astilog", ".", "Debugf", "(", "\"", "\"", ",", "dst", ")", "\n", "if", "f", ",", "err", "=", "os", ".", "Create", "(", "dst", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "dst", ")", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n\n", "// Disembed", "var", "b", "[", "]", "byte", "\n", "astilog", ".", "Debugf", "(", "\"", "\"", ",", "src", ")", "\n", "if", "b", ",", "err", "=", "d", "(", "src", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "src", ")", "\n", "}", "\n\n", "// Copy", "astilog", ".", "Debugf", "(", "\"", "\"", ",", "dst", ")", "\n", "if", "_", ",", "err", "=", "astiio", ".", "Copy", "(", "ctx", ",", "bytes", ".", "NewReader", "(", "b", ")", ",", "f", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "dst", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "Disembed", "is", "a", "cancellable", "disembed", "of", "an", "src", "to", "a", "dst", "using", "a", "custom", "Disembedder" ]

[ "func", "synchronousFunc", "(", "c", "*", "asticontext", ".", "Canceller", ",", "l", "listenable", ",", "fn", "func", "(", ")", ",", "eventNameDone", "string", ")", "(", "e", "Event", ")", "{", "var", "ctx", ",", "cancel", "=", "c", ".", "NewContext", "(", ")", "\n", "defer", "cancel", "(", ")", "\n", "l", ".", "On", "(", "eventNameDone", ",", "func", "(", "i", "Event", ")", "(", "deleteListener", "bool", ")", "{", "e", "=", "i", "\n", "cancel", "(", ")", "\n", "return", "true", "\n", "}", ")", "\n", "fn", "(", ")", "\n", "<-", "ctx", ".", "Done", "(", ")", "\n", "return", "\n", "}" ]

[ "synchronousFunc", "executes", "a", "function", "blocks", "until", "it", "has", "received", "a", "specific", "event", "or", "the", "canceller", "has", "been", "cancelled", "and", "returns", "the", "corresponding", "event" ]

[ "func", "synchronousEvent", "(", "c", "*", "asticontext", ".", "Canceller", ",", "l", "listenable", ",", "w", "*", "writer", ",", "i", "Event", ",", "eventNameDone", "string", ")", "(", "o", "Event", ",", "err", "error", ")", "{", "o", "=", "synchronousFunc", "(", "c", ",", "l", ",", "func", "(", ")", "{", "if", "err", "=", "w", ".", "write", "(", "i", ")", ";", "err", "!=", "nil", "{", "err", "=", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "i", ")", "\n", "return", "\n", "}", "\n", "return", "\n", "}", ",", "eventNameDone", ")", "\n", "return", "\n", "}" ]

[ "synchronousEvent", "sends", "an", "event", "blocks", "until", "it", "has", "received", "a", "specific", "event", "or", "the", "canceller", "has", "been", "cancelled", "and", "returns", "the", "corresponding", "event" ]

[ "func", "(", "i", "*", "identifier", ")", "new", "(", ")", "string", "{", "i", ".", "m", ".", "Lock", "(", ")", "\n", "defer", "i", ".", "m", ".", "Unlock", "(", ")", "\n", "i", ".", "i", "++", "\n", "return", "strconv", ".", "Itoa", "(", "i", ".", "i", ")", "\n", "}" ]

[ "new", "returns", "a", "new", "unique", "identifier" ]

[ "func", "newReader", "(", "ctx", "context", ".", "Context", ",", "d", "*", "dispatcher", ",", "r", "io", ".", "ReadCloser", ")", "*", "reader", "{", "return", "&", "reader", "{", "ctx", ":", "ctx", ",", "d", ":", "d", ",", "r", ":", "r", ",", "}", "\n", "}" ]

[ "newReader", "creates", "a", "new", "reader" ]

[ "func", "(", "r", "*", "reader", ")", "isEOFErr", "(", "err", "error", ")", "bool", "{", "return", "err", "==", "io", ".", "EOF", "||", "strings", ".", "Contains", "(", "strings", ".", "ToLower", "(", "err", ".", "Error", "(", ")", ")", ",", "\"", "\"", ")", "\n", "}" ]

[ "isEOFErr", "checks", "whether", "the", "error", "is", "an", "EOF", "error", "wsarecv", "is", "the", "error", "sent", "on", "Windows", "when", "the", "client", "closes", "its", "connection" ]

[ "func", "(", "r", "*", "reader", ")", "read", "(", ")", "{", "var", "reader", "=", "bufio", ".", "NewReader", "(", "r", ".", "r", ")", "\n", "for", "{", "// Check context error", "if", "r", ".", "ctx", ".", "Err", "(", ")", "!=", "nil", "{", "return", "\n", "}", "\n\n", "// Read next line", "var", "b", "[", "]", "byte", "\n", "var", "err", "error", "\n", "if", "b", ",", "err", "=", "reader", ".", "ReadBytes", "(", "'\\n'", ")", ";", "err", "!=", "nil", "{", "if", "!", "r", ".", "isEOFErr", "(", "err", ")", "{", "astilog", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "return", "\n", "}", "\n", "b", "=", "bytes", ".", "TrimSpace", "(", "b", ")", "\n", "astilog", ".", "Debugf", "(", "\"", "\"", ",", "b", ")", "\n\n", "// Unmarshal", "var", "e", "Event", "\n", "if", "err", "=", "json", ".", "Unmarshal", "(", "b", ",", "&", "e", ")", ";", "err", "!=", "nil", "{", "astilog", ".", "Errorf", "(", "\"", "\"", ",", "err", ",", "b", ")", "\n", "continue", "\n", "}", "\n\n", "// Dispatch", "r", ".", "d", ".", "dispatch", "(", "e", ")", "\n", "}", "\n", "}" ]

[ "read", "reads", "from", "stdout" ]

[ "func", "(", "d", "*", "dispatcher", ")", "addListener", "(", "targetID", ",", "eventName", "string", ",", "l", "Listener", ")", "{", "d", ".", "m", ".", "Lock", "(", ")", "\n", "defer", "d", ".", "m", ".", "Unlock", "(", ")", "\n", "if", "_", ",", "ok", ":=", "d", ".", "l", "[", "targetID", "]", ";", "!", "ok", "{", "d", ".", "l", "[", "targetID", "]", "=", "make", "(", "map", "[", "string", "]", "map", "[", "int", "]", "Listener", ")", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "d", ".", "l", "[", "targetID", "]", "[", "eventName", "]", ";", "!", "ok", "{", "d", ".", "l", "[", "targetID", "]", "[", "eventName", "]", "=", "make", "(", "map", "[", "int", "]", "Listener", ")", "\n", "}", "\n", "d", ".", "id", "++", "\n", "d", ".", "l", "[", "targetID", "]", "[", "eventName", "]", "[", "d", ".", "id", "]", "=", "l", "\n", "}" ]

[ "addListener", "adds", "a", "listener" ]

[ "func", "(", "d", "*", "dispatcher", ")", "delListener", "(", "targetID", ",", "eventName", "string", ",", "id", "int", ")", "{", "d", ".", "m", ".", "Lock", "(", ")", "\n", "defer", "d", ".", "m", ".", "Unlock", "(", ")", "\n", "if", "_", ",", "ok", ":=", "d", ".", "l", "[", "targetID", "]", ";", "!", "ok", "{", "return", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "d", ".", "l", "[", "targetID", "]", "[", "eventName", "]", ";", "!", "ok", "{", "return", "\n", "}", "\n", "delete", "(", "d", ".", "l", "[", "targetID", "]", "[", "eventName", "]", ",", "id", ")", "\n", "}" ]

[ "delListener", "delete", "a", "specific", "listener" ]

[ "func", "(", "d", "*", "dispatcher", ")", "dispatch", "(", "e", "Event", ")", "{", "// needed so dispatches of events triggered in the listeners can be received without blocking", "go", "func", "(", ")", "{", "for", "id", ",", "l", ":=", "range", "d", ".", "listeners", "(", "e", ".", "TargetID", ",", "e", ".", "Name", ")", "{", "if", "l", "(", "e", ")", "{", "d", ".", "delListener", "(", "e", ".", "TargetID", ",", "e", ".", "Name", ",", "id", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "}" ]

[ "Dispatch", "dispatches", "an", "event" ]

[ "func", "(", "d", "*", "dispatcher", ")", "listeners", "(", "targetID", ",", "eventName", "string", ")", "(", "l", "map", "[", "int", "]", "Listener", ")", "{", "d", ".", "m", ".", "Lock", "(", ")", "\n", "defer", "d", ".", "m", ".", "Unlock", "(", ")", "\n", "l", "=", "map", "[", "int", "]", "Listener", "{", "}", "\n", "if", "_", ",", "ok", ":=", "d", ".", "l", "[", "targetID", "]", ";", "!", "ok", "{", "return", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "d", ".", "l", "[", "targetID", "]", "[", "eventName", "]", ";", "!", "ok", "{", "return", "\n", "}", "\n", "for", "k", ",", "v", ":=", "range", "d", ".", "l", "[", "targetID", "]", "[", "eventName", "]", "{", "l", "[", "k", "]", "=", "v", "\n", "}", "\n", "return", "\n", "}" ]

[ "listeners", "returns", "the", "listeners", "for", "a", "target", "ID", "and", "an", "event", "name" ]

[ "func", "newMenuItem", "(", "parentCtx", "context", ".", "Context", ",", "rootID", "string", ",", "o", "*", "MenuItemOptions", ",", "c", "*", "asticontext", ".", "Canceller", ",", "d", "*", "dispatcher", ",", "i", "*", "identifier", ",", "w", "*", "writer", ")", "(", "m", "*", "MenuItem", ")", "{", "m", "=", "&", "MenuItem", "{", "o", ":", "o", ",", "object", ":", "newObject", "(", "parentCtx", ",", "c", ",", "d", ",", "i", ",", "w", ",", "i", ".", "new", "(", ")", ")", ",", "rootID", ":", "rootID", ",", "}", "\n", "if", "o", ".", "OnClick", "!=", "nil", "{", "m", ".", "On", "(", "EventNameMenuItemEventClicked", ",", "o", ".", "OnClick", ")", "\n", "}", "\n", "if", "len", "(", "o", ".", "SubMenu", ")", ">", "0", "{", "m", ".", "s", "=", "&", "SubMenu", "{", "newSubMenu", "(", "parentCtx", ",", "rootID", ",", "o", ".", "SubMenu", ",", "c", ",", "d", ",", "i", ",", "w", ")", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "newMenu", "creates", "a", "new", "menu", "item" ]

[ "func", "(", "i", "*", "MenuItem", ")", "toEvent", "(", ")", "(", "e", "*", "EventMenuItem", ")", "{", "e", "=", "&", "EventMenuItem", "{", "ID", ":", "i", ".", "id", ",", "Options", ":", "i", ".", "o", ",", "RootID", ":", "i", ".", "rootID", ",", "}", "\n", "if", "i", ".", "s", "!=", "nil", "{", "e", ".", "SubMenu", "=", "i", ".", "s", ".", "toEvent", "(", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "toEvent", "returns", "the", "menu", "item", "in", "the", "proper", "event", "format" ]

[ "func", "(", "i", "*", "MenuItem", ")", "SetChecked", "(", "checked", "bool", ")", "(", "err", "error", ")", "{", "if", "err", "=", "i", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "i", ".", "o", ".", "Checked", "=", "PtrBool", "(", "checked", ")", "\n", "_", ",", "err", "=", "synchronousEvent", "(", "i", ".", "c", ",", "i", ",", "i", ".", "w", ",", "Event", "{", "Name", ":", "EventNameMenuItemCmdSetChecked", ",", "TargetID", ":", "i", ".", "id", ",", "MenuItemOptions", ":", "&", "MenuItemOptions", "{", "Checked", ":", "i", ".", "o", ".", "Checked", "}", "}", ",", "EventNameMenuItemEventCheckedSet", ")", "\n", "return", "\n", "}" ]

[ "SetChecked", "sets", "the", "checked", "attribute" ]

[ "func", "(", "i", "*", "MenuItem", ")", "SetEnabled", "(", "enabled", "bool", ")", "(", "err", "error", ")", "{", "if", "err", "=", "i", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "i", ".", "o", ".", "Enabled", "=", "PtrBool", "(", "enabled", ")", "\n", "_", ",", "err", "=", "synchronousEvent", "(", "i", ".", "c", ",", "i", ",", "i", ".", "w", ",", "Event", "{", "Name", ":", "EventNameMenuItemCmdSetEnabled", ",", "TargetID", ":", "i", ".", "id", ",", "MenuItemOptions", ":", "&", "MenuItemOptions", "{", "Enabled", ":", "i", ".", "o", ".", "Enabled", "}", "}", ",", "EventNameMenuItemEventEnabledSet", ")", "\n", "return", "\n", "}" ]

[ "SetEnabled", "sets", "the", "enabled", "attribute" ]

[ "func", "(", "i", "*", "MenuItem", ")", "SetLabel", "(", "label", "string", ")", "(", "err", "error", ")", "{", "if", "err", "=", "i", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "i", ".", "o", ".", "Label", "=", "PtrStr", "(", "label", ")", "\n", "_", ",", "err", "=", "synchronousEvent", "(", "i", ".", "c", ",", "i", ",", "i", ".", "w", ",", "Event", "{", "Name", ":", "EventNameMenuItemCmdSetLabel", ",", "TargetID", ":", "i", ".", "id", ",", "MenuItemOptions", ":", "&", "MenuItemOptions", "{", "Label", ":", "i", ".", "o", ".", "Label", "}", "}", ",", "EventNameMenuItemEventLabelSet", ")", "\n", "return", "\n", "}" ]

[ "SetLabel", "sets", "the", "label", "attribute" ]

[ "func", "(", "i", "*", "MenuItem", ")", "SetVisible", "(", "visible", "bool", ")", "(", "err", "error", ")", "{", "if", "err", "=", "i", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "i", ".", "o", ".", "Visible", "=", "PtrBool", "(", "visible", ")", "\n", "_", ",", "err", "=", "synchronousEvent", "(", "i", ".", "c", ",", "i", ",", "i", ".", "w", ",", "Event", "{", "Name", ":", "EventNameMenuItemCmdSetVisible", ",", "TargetID", ":", "i", ".", "id", ",", "MenuItemOptions", ":", "&", "MenuItemOptions", "{", "Visible", ":", "i", ".", "o", ".", "Visible", "}", "}", ",", "EventNameMenuItemEventVisibleSet", ")", "\n", "return", "\n", "}" ]

[ "SetVisible", "sets", "the", "visible", "attribute" ]

[ "func", "(", "d", "Display", ")", "Bounds", "(", ")", "Rectangle", "{", "return", "Rectangle", "{", "Position", ":", "Position", "{", "X", ":", "*", "d", ".", "o", ".", "Bounds", ".", "X", ",", "Y", ":", "*", "d", ".", "o", ".", "Bounds", ".", "Y", "}", ",", "Size", ":", "Size", "{", "Height", ":", "*", "d", ".", "o", ".", "Bounds", ".", "Height", ",", "Width", ":", "*", "d", ".", "o", ".", "Bounds", ".", "Width", "}", ",", "}", "\n", "}" ]

[ "Bounds", "returns", "the", "display", "bounds" ]

[ "func", "(", "d", "Display", ")", "Size", "(", ")", "Size", "{", "return", "Size", "{", "Height", ":", "*", "d", ".", "o", ".", "Size", ".", "Height", ",", "Width", ":", "*", "d", ".", "o", ".", "Size", ".", "Width", "}", "\n", "}" ]

[ "Size", "returns", "the", "display", "size" ]

[ "func", "(", "d", "Display", ")", "WorkAreaSize", "(", ")", "Size", "{", "return", "Size", "{", "Height", ":", "*", "d", ".", "o", ".", "WorkAreaSize", ".", "Height", ",", "Width", ":", "*", "d", ".", "o", ".", "WorkAreaSize", ".", "Width", "}", "\n", "}" ]

[ "WorkAreaSize", "returns", "the", "display", "work", "area", "size" ]

[ "func", "newWindow", "(", "o", "Options", ",", "p", "Paths", ",", "url", "string", ",", "wo", "*", "WindowOptions", ",", "c", "*", "asticontext", ".", "Canceller", ",", "d", "*", "dispatcher", ",", "i", "*", "identifier", ",", "wrt", "*", "writer", ")", "(", "w", "*", "Window", ",", "err", "error", ")", "{", "// Init", "w", "=", "&", "Window", "{", "callbackIdentifier", ":", "newIdentifier", "(", ")", ",", "o", ":", "wo", ",", "object", ":", "newObject", "(", "nil", ",", "c", ",", "d", ",", "i", ",", "wrt", ",", "i", ".", "new", "(", ")", ")", ",", "}", "\n", "w", ".", "Session", "=", "newSession", "(", "w", ".", "ctx", ",", "c", ",", "d", ",", "i", ",", "wrt", ")", "\n\n", "// Check app details", "if", "wo", ".", "Icon", "==", "nil", "&&", "p", ".", "AppIconDefaultSrc", "(", ")", "!=", "\"", "\"", "{", "wo", ".", "Icon", "=", "PtrStr", "(", "p", ".", "AppIconDefaultSrc", "(", ")", ")", "\n", "}", "\n", "if", "wo", ".", "Title", "==", "nil", "&&", "o", ".", "AppName", "!=", "\"", "\"", "{", "wo", ".", "Title", "=", "PtrStr", "(", "o", ".", "AppName", ")", "\n", "}", "\n\n", "// Make sure the window's context is cancelled once the closed event is received", "w", ".", "On", "(", "EventNameWindowEventClosed", ",", "func", "(", "e", "Event", ")", "(", "deleteListener", "bool", ")", "{", "w", ".", "cancel", "(", ")", "\n", "return", "true", "\n", "}", ")", "\n\n", "// Show", "w", ".", "On", "(", "EventNameWindowEventHide", ",", "func", "(", "e", "Event", ")", "(", "deleteListener", "bool", ")", "{", "w", ".", "m", ".", "Lock", "(", ")", "\n", "defer", "w", ".", "m", ".", "Unlock", "(", ")", "\n", "w", ".", "o", ".", "Show", "=", "PtrBool", "(", "false", ")", "\n", "return", "\n", "}", ")", "\n", "w", ".", "On", "(", "EventNameWindowEventShow", ",", "func", "(", "e", "Event", ")", "(", "deleteListener", "bool", ")", "{", "w", ".", "m", ".", "Lock", "(", ")", "\n", "defer", "w", ".", "m", ".", "Unlock", "(", ")", "\n", "w", ".", "o", ".", "Show", "=", "PtrBool", "(", "true", ")", "\n", "return", "\n", "}", ")", "\n\n", "// Parse url", "if", "w", ".", "url", ",", "err", "=", "astiurl", ".", "Parse", "(", "url", ")", ";", "err", "!=", "nil", "{", "err", "=", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "url", ")", "\n", "return", "\n", "}", "\n", "return", "\n", "}" ]

[ "newWindow", "creates", "a", "new", "window" ]

[ "func", "(", "w", "*", "Window", ")", "NewMenu", "(", "i", "[", "]", "*", "MenuItemOptions", ")", "*", "Menu", "{", "return", "newMenu", "(", "w", ".", "ctx", ",", "w", ".", "id", ",", "i", ",", "w", ".", "c", ",", "w", ".", "d", ",", "w", ".", "i", ",", "w", ".", "w", ")", "\n", "}" ]

[ "NewMenu", "creates", "a", "new", "window", "menu" ]

[ "func", "(", "w", "*", "Window", ")", "Blur", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "w", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "_", ",", "err", "=", "synchronousEvent", "(", "w", ".", "c", ",", "w", ",", "w", ".", "w", ",", "Event", "{", "Name", ":", "EventNameWindowCmdBlur", ",", "TargetID", ":", "w", ".", "id", "}", ",", "EventNameWindowEventBlur", ")", "\n", "return", "\n", "}" ]

[ "Blur", "blurs", "the", "window" ]

[ "func", "(", "w", "*", "Window", ")", "Center", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "w", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "_", ",", "err", "=", "synchronousEvent", "(", "w", ".", "c", ",", "w", ",", "w", ".", "w", ",", "Event", "{", "Name", ":", "EventNameWindowCmdCenter", ",", "TargetID", ":", "w", ".", "id", "}", ",", "EventNameWindowEventMove", ")", "\n", "return", "\n", "}" ]

[ "Center", "centers", "the", "window" ]

[ "func", "(", "w", "*", "Window", ")", "Close", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "w", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "_", ",", "err", "=", "synchronousEvent", "(", "w", ".", "c", ",", "w", ",", "w", ".", "w", ",", "Event", "{", "Name", ":", "EventNameWindowCmdClose", ",", "TargetID", ":", "w", ".", "id", "}", ",", "EventNameWindowEventClosed", ")", "\n", "return", "\n", "}" ]

[ "Close", "closes", "the", "window" ]

[ "func", "(", "w", "*", "Window", ")", "CloseDevTools", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "w", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "return", "w", ".", "w", ".", "write", "(", "Event", "{", "Name", ":", "EventNameWindowCmdWebContentsCloseDevTools", ",", "TargetID", ":", "w", ".", "id", "}", ")", "\n", "}" ]

[ "CloseDevTools", "closes", "the", "dev", "tools" ]

[ "func", "(", "w", "*", "Window", ")", "Create", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "w", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "_", ",", "err", "=", "synchronousEvent", "(", "w", ".", "c", ",", "w", ",", "w", ".", "w", ",", "Event", "{", "Name", ":", "EventNameWindowCmdCreate", ",", "SessionID", ":", "w", ".", "Session", ".", "id", ",", "TargetID", ":", "w", ".", "id", ",", "URL", ":", "w", ".", "url", ".", "String", "(", ")", ",", "WindowOptions", ":", "w", ".", "o", "}", ",", "EventNameWindowEventDidFinishLoad", ")", "\n", "return", "\n", "}" ]

[ "Create", "creates", "the", "window", "We", "wait", "for", "EventNameWindowEventDidFinishLoad", "since", "we", "need", "the", "web", "content", "to", "be", "fully", "loaded", "before", "being", "able", "to", "send", "messages", "to", "it" ]

[ "func", "(", "w", "*", "Window", ")", "Destroy", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "w", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "_", ",", "err", "=", "synchronousEvent", "(", "w", ".", "c", ",", "w", ",", "w", ".", "w", ",", "Event", "{", "Name", ":", "EventNameWindowCmdDestroy", ",", "TargetID", ":", "w", ".", "id", "}", ",", "EventNameWindowEventClosed", ")", "\n", "return", "\n", "}" ]

[ "Destroy", "destroys", "the", "window" ]

[ "func", "(", "w", "*", "Window", ")", "Focus", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "w", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "_", ",", "err", "=", "synchronousEvent", "(", "w", ".", "c", ",", "w", ",", "w", ".", "w", ",", "Event", "{", "Name", ":", "EventNameWindowCmdFocus", ",", "TargetID", ":", "w", ".", "id", "}", ",", "EventNameWindowEventFocus", ")", "\n", "return", "\n", "}" ]

[ "Focus", "focuses", "on", "the", "window" ]

[ "func", "(", "w", "*", "Window", ")", "Hide", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "w", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "_", ",", "err", "=", "synchronousEvent", "(", "w", ".", "c", ",", "w", ",", "w", ".", "w", ",", "Event", "{", "Name", ":", "EventNameWindowCmdHide", ",", "TargetID", ":", "w", ".", "id", "}", ",", "EventNameWindowEventHide", ")", "\n", "return", "\n", "}" ]

[ "Hide", "hides", "the", "window" ]

[ "func", "(", "w", "*", "Window", ")", "IsShown", "(", ")", "bool", "{", "if", "err", ":=", "w", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "w", ".", "m", ".", "Lock", "(", ")", "\n", "defer", "w", ".", "m", ".", "Unlock", "(", ")", "\n", "return", "w", ".", "o", ".", "Show", "!=", "nil", "&&", "*", "w", ".", "o", ".", "Show", "\n", "}" ]

[ "IsShown", "returns", "whether", "the", "window", "is", "shown" ]

[ "func", "(", "w", "*", "Window", ")", "Log", "(", "message", "string", ")", "(", "err", "error", ")", "{", "if", "err", "=", "w", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "return", "w", ".", "w", ".", "write", "(", "Event", "{", "Message", ":", "newEventMessage", "(", "message", ")", ",", "Name", ":", "EventNameWindowCmdLog", ",", "TargetID", ":", "w", ".", "id", "}", ")", "\n", "}" ]

[ "Log", "logs", "a", "message", "in", "the", "JS", "console", "of", "the", "window" ]

[ "func", "(", "w", "*", "Window", ")", "Maximize", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "w", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "_", ",", "err", "=", "synchronousEvent", "(", "w", ".", "c", ",", "w", ",", "w", ".", "w", ",", "Event", "{", "Name", ":", "EventNameWindowCmdMaximize", ",", "TargetID", ":", "w", ".", "id", "}", ",", "EventNameWindowEventMaximize", ")", "\n", "return", "\n", "}" ]

[ "Maximize", "maximizes", "the", "window" ]

[ "func", "(", "w", "*", "Window", ")", "Minimize", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "w", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "_", ",", "err", "=", "synchronousEvent", "(", "w", ".", "c", ",", "w", ",", "w", ".", "w", ",", "Event", "{", "Name", ":", "EventNameWindowCmdMinimize", ",", "TargetID", ":", "w", ".", "id", "}", ",", "EventNameWindowEventMinimize", ")", "\n", "return", "\n", "}" ]

[ "Minimize", "minimizes", "the", "window" ]

[ "func", "(", "w", "*", "Window", ")", "Move", "(", "x", ",", "y", "int", ")", "(", "err", "error", ")", "{", "if", "err", "=", "w", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "w", ".", "m", ".", "Lock", "(", ")", "\n", "w", ".", "o", ".", "X", "=", "PtrInt", "(", "x", ")", "\n", "w", ".", "o", ".", "Y", "=", "PtrInt", "(", "y", ")", "\n", "w", ".", "m", ".", "Unlock", "(", ")", "\n", "_", ",", "err", "=", "synchronousEvent", "(", "w", ".", "c", ",", "w", ",", "w", ".", "w", ",", "Event", "{", "Name", ":", "EventNameWindowCmdMove", ",", "TargetID", ":", "w", ".", "id", ",", "WindowOptions", ":", "&", "WindowOptions", "{", "X", ":", "PtrInt", "(", "x", ")", ",", "Y", ":", "PtrInt", "(", "y", ")", "}", "}", ",", "EventNameWindowEventMove", ")", "\n", "return", "\n", "}" ]

[ "Move", "moves", "the", "window" ]

[ "func", "(", "w", "*", "Window", ")", "MoveInDisplay", "(", "d", "*", "Display", ",", "x", ",", "y", "int", ")", "error", "{", "return", "w", ".", "Move", "(", "d", ".", "Bounds", "(", ")", ".", "X", "+", "x", ",", "d", ".", "Bounds", "(", ")", ".", "Y", "+", "y", ")", "\n", "}" ]

[ "MoveInDisplay", "moves", "the", "window", "in", "the", "proper", "display" ]

[ "func", "(", "w", "*", "Window", ")", "OnMessage", "(", "l", "ListenerMessage", ")", "{", "w", ".", "onMessageOnce", ".", "Do", "(", "func", "(", ")", "{", "w", ".", "On", "(", "eventNameWindowEventMessage", ",", "func", "(", "i", "Event", ")", "(", "deleteListener", "bool", ")", "{", "v", ":=", "l", "(", "i", ".", "Message", ")", "\n", "if", "len", "(", "i", ".", "CallbackID", ")", ">", "0", "{", "o", ":=", "Event", "{", "CallbackID", ":", "i", ".", "CallbackID", ",", "Name", ":", "eventNameWindowCmdMessageCallback", ",", "TargetID", ":", "w", ".", "id", "}", "\n", "if", "v", "!=", "nil", "{", "o", ".", "Message", "=", "newEventMessage", "(", "v", ")", "\n", "}", "\n", "if", "err", ":=", "w", ".", "w", ".", "write", "(", "o", ")", ";", "err", "!=", "nil", "{", "astilog", ".", "Error", "(", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "}", "\n", "return", "\n", "}", ")", "\n", "}", ")", "\n", "}" ]

[ "OnMessage", "adds", "a", "specific", "listener", "executed", "when", "receiving", "a", "message", "from", "the", "JS", "This", "method", "can", "be", "called", "only", "once" ]

[ "func", "(", "w", "*", "Window", ")", "OpenDevTools", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "w", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "return", "w", ".", "w", ".", "write", "(", "Event", "{", "Name", ":", "EventNameWindowCmdWebContentsOpenDevTools", ",", "TargetID", ":", "w", ".", "id", "}", ")", "\n", "}" ]

[ "OpenDevTools", "opens", "the", "dev", "tools" ]

[ "func", "(", "w", "*", "Window", ")", "Resize", "(", "width", ",", "height", "int", ")", "(", "err", "error", ")", "{", "if", "err", "=", "w", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "w", ".", "m", ".", "Lock", "(", ")", "\n", "w", ".", "o", ".", "Height", "=", "PtrInt", "(", "height", ")", "\n", "w", ".", "o", ".", "Width", "=", "PtrInt", "(", "width", ")", "\n", "w", ".", "m", ".", "Unlock", "(", ")", "\n", "_", ",", "err", "=", "synchronousEvent", "(", "w", ".", "c", ",", "w", ",", "w", ".", "w", ",", "Event", "{", "Name", ":", "EventNameWindowCmdResize", ",", "TargetID", ":", "w", ".", "id", ",", "WindowOptions", ":", "&", "WindowOptions", "{", "Height", ":", "PtrInt", "(", "height", ")", ",", "Width", ":", "PtrInt", "(", "width", ")", "}", "}", ",", "EventNameWindowEventResize", ")", "\n", "return", "\n", "}" ]

[ "Resize", "resizes", "the", "window" ]

[ "func", "(", "w", "*", "Window", ")", "SetBounds", "(", "r", "RectangleOptions", ")", "(", "err", "error", ")", "{", "if", "err", "=", "w", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "w", ".", "m", ".", "Lock", "(", ")", "\n", "w", ".", "o", ".", "Height", "=", "r", ".", "Height", "\n", "w", ".", "o", ".", "Width", "=", "r", ".", "Width", "\n", "w", ".", "o", ".", "X", "=", "r", ".", "X", "\n", "w", ".", "o", ".", "Y", "=", "r", ".", "Y", "\n", "w", ".", "m", ".", "Unlock", "(", ")", "\n", "_", ",", "err", "=", "synchronousEvent", "(", "w", ".", "c", ",", "w", ",", "w", ".", "w", ",", "Event", "{", "Name", ":", "EventNameWindowCmdSetBounds", ",", "TargetID", ":", "w", ".", "id", ",", "Bounds", ":", "&", "r", "}", ",", "EventNameWindowEventResize", ")", "\n", "return", "\n", "}" ]

[ "SetBounds", "set", "bounds", "of", "the", "window" ]

[ "func", "(", "w", "*", "Window", ")", "Restore", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "w", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "_", ",", "err", "=", "synchronousEvent", "(", "w", ".", "c", ",", "w", ",", "w", ".", "w", ",", "Event", "{", "Name", ":", "EventNameWindowCmdRestore", ",", "TargetID", ":", "w", ".", "id", "}", ",", "EventNameWindowEventRestore", ")", "\n", "return", "\n", "}" ]

[ "Restore", "restores", "the", "window" ]

[ "func", "(", "w", "*", "Window", ")", "SendMessage", "(", "message", "interface", "{", "}", ",", "callbacks", "...", "CallbackMessage", ")", "(", "err", "error", ")", "{", "if", "err", "=", "w", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "var", "e", "=", "Event", "{", "Message", ":", "newEventMessage", "(", "message", ")", ",", "Name", ":", "eventNameWindowCmdMessage", ",", "TargetID", ":", "w", ".", "id", "}", "\n", "if", "len", "(", "callbacks", ")", ">", "0", "{", "e", ".", "CallbackID", "=", "w", ".", "callbackIdentifier", ".", "new", "(", ")", "\n", "w", ".", "On", "(", "eventNameWindowEventMessageCallback", ",", "func", "(", "i", "Event", ")", "(", "deleteListener", "bool", ")", "{", "if", "i", ".", "CallbackID", "==", "e", ".", "CallbackID", "{", "for", "_", ",", "c", ":=", "range", "callbacks", "{", "c", "(", "i", ".", "Message", ")", "\n", "}", "\n", "deleteListener", "=", "true", "\n", "}", "\n", "return", "\n", "}", ")", "\n", "}", "\n", "return", "w", ".", "w", ".", "write", "(", "e", ")", "\n", "}" ]

[ "SendMessage", "sends", "a", "message", "to", "the", "JS", "window", "and", "execute", "optional", "callbacks", "upon", "receiving", "a", "response", "from", "the", "JS", "Use", "astilectron", ".", "onMessage", "method", "to", "capture", "those", "messages", "in", "JS" ]

[ "func", "(", "w", "*", "Window", ")", "Show", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "w", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "_", ",", "err", "=", "synchronousEvent", "(", "w", ".", "c", ",", "w", ",", "w", ".", "w", ",", "Event", "{", "Name", ":", "EventNameWindowCmdShow", ",", "TargetID", ":", "w", ".", "id", "}", ",", "EventNameWindowEventShow", ")", "\n", "return", "\n", "}" ]

[ "Show", "shows", "the", "window" ]

[ "func", "(", "w", "*", "Window", ")", "Unmaximize", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "w", ".", "isActionable", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "_", ",", "err", "=", "synchronousEvent", "(", "w", ".", "c", ",", "w", ",", "w", ".", "w", ",", "Event", "{", "Name", ":", "EventNameWindowCmdUnmaximize", ",", "TargetID", ":", "w", ".", "id", "}", ",", "EventNameWindowEventUnmaximize", ")", "\n", "return", "\n", "}" ]

[ "Unmaximize", "unmaximize", "the", "window" ]

[ "func", "CheckPayloadSignature", "(", "payload", "[", "]", "byte", ",", "secret", "string", ",", "signature", "string", ")", "(", "string", ",", "error", ")", "{", "signature", "=", "strings", ".", "TrimPrefix", "(", "signature", ",", "\"", "\"", ")", "\n\n", "mac", ":=", "hmac", ".", "New", "(", "sha1", ".", "New", ",", "[", "]", "byte", "(", "secret", ")", ")", "\n", "_", ",", "err", ":=", "mac", ".", "Write", "(", "payload", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "expectedMAC", ":=", "hex", ".", "EncodeToString", "(", "mac", ".", "Sum", "(", "nil", ")", ")", "\n\n", "if", "!", "hmac", ".", "Equal", "(", "[", "]", "byte", "(", "signature", ")", ",", "[", "]", "byte", "(", "expectedMAC", ")", ")", "{", "return", "expectedMAC", ",", "&", "SignatureError", "{", "signature", "}", "\n", "}", "\n", "return", "expectedMAC", ",", "err", "\n", "}" ]

[ "CheckPayloadSignature", "calculates", "and", "verifies", "SHA1", "signature", "of", "the", "given", "payload" ]

[ "func", "(", "ha", "*", "Argument", ")", "Get", "(", "headers", ",", "query", ",", "payload", "*", "map", "[", "string", "]", "interface", "{", "}", ")", "(", "string", ",", "bool", ")", "{", "var", "source", "*", "map", "[", "string", "]", "interface", "{", "}", "\n", "key", ":=", "ha", ".", "Name", "\n\n", "switch", "ha", ".", "Source", "{", "case", "SourceHeader", ":", "source", "=", "headers", "\n", "key", "=", "textproto", ".", "CanonicalMIMEHeaderKey", "(", "ha", ".", "Name", ")", "\n", "case", "SourceQuery", ",", "SourceQueryAlias", ":", "source", "=", "query", "\n", "case", "SourcePayload", ":", "source", "=", "payload", "\n", "case", "SourceString", ":", "return", "ha", ".", "Name", ",", "true", "\n", "case", "SourceEntirePayload", ":", "r", ",", "err", ":=", "json", ".", "Marshal", "(", "payload", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "false", "\n", "}", "\n\n", "return", "string", "(", "r", ")", ",", "true", "\n", "case", "SourceEntireHeaders", ":", "r", ",", "err", ":=", "json", ".", "Marshal", "(", "headers", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "false", "\n", "}", "\n\n", "return", "string", "(", "r", ")", ",", "true", "\n", "case", "SourceEntireQuery", ":", "r", ",", "err", ":=", "json", ".", "Marshal", "(", "query", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "false", "\n", "}", "\n\n", "return", "string", "(", "r", ")", ",", "true", "\n", "}", "\n\n", "if", "source", "!=", "nil", "{", "return", "ExtractParameterAsString", "(", "key", ",", "*", "source", ")", "\n", "}", "\n\n", "return", "\"", "\"", ",", "false", "\n", "}" ]

[ "Get", "Argument", "method", "returns", "the", "value", "for", "the", "Argument", "s", "key", "name", "based", "on", "the", "Argument", "s", "source" ]

[ "func", "(", "h", "*", "ResponseHeaders", ")", "Set", "(", "value", "string", ")", "error", "{", "splitResult", ":=", "strings", ".", "SplitN", "(", "value", ",", "\"", "\"", ",", "2", ")", "\n\n", "if", "len", "(", "splitResult", ")", "!=", "2", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "*", "h", "=", "append", "(", "*", "h", ",", "Header", "{", "Name", ":", "splitResult", "[", "0", "]", ",", "Value", ":", "splitResult", "[", "1", "]", "}", ")", "\n", "return", "nil", "\n", "}" ]

[ "Set", "method", "appends", "new", "Header", "object", "from", "header", "=", "value", "notation" ]

[ "func", "(", "h", "*", "HooksFiles", ")", "Set", "(", "value", "string", ")", "error", "{", "*", "h", "=", "append", "(", "*", "h", ",", "value", ")", "\n", "return", "nil", "\n", "}" ]

[ "Set", "method", "appends", "new", "string" ]

[ "func", "(", "h", "*", "Hook", ")", "ParseJSONParameters", "(", "headers", ",", "query", ",", "payload", "*", "map", "[", "string", "]", "interface", "{", "}", ")", "[", "]", "error", "{", "var", "errors", "=", "make", "(", "[", "]", "error", ",", "0", ")", "\n\n", "for", "i", ":=", "range", "h", ".", "JSONStringParameters", "{", "if", "arg", ",", "ok", ":=", "h", ".", "JSONStringParameters", "[", "i", "]", ".", "Get", "(", "headers", ",", "query", ",", "payload", ")", ";", "ok", "{", "var", "newArg", "map", "[", "string", "]", "interface", "{", "}", "\n\n", "decoder", ":=", "json", ".", "NewDecoder", "(", "strings", ".", "NewReader", "(", "string", "(", "arg", ")", ")", ")", "\n", "decoder", ".", "UseNumber", "(", ")", "\n\n", "err", ":=", "decoder", ".", "Decode", "(", "&", "newArg", ")", "\n\n", "if", "err", "!=", "nil", "{", "errors", "=", "append", "(", "errors", ",", "&", "ParseError", "{", "err", "}", ")", "\n", "continue", "\n", "}", "\n\n", "var", "source", "*", "map", "[", "string", "]", "interface", "{", "}", "\n\n", "switch", "h", ".", "JSONStringParameters", "[", "i", "]", ".", "Source", "{", "case", "SourceHeader", ":", "source", "=", "headers", "\n", "case", "SourcePayload", ":", "source", "=", "payload", "\n", "case", "SourceQuery", ",", "SourceQueryAlias", ":", "source", "=", "query", "\n", "}", "\n\n", "if", "source", "!=", "nil", "{", "key", ":=", "h", ".", "JSONStringParameters", "[", "i", "]", ".", "Name", "\n\n", "if", "h", ".", "JSONStringParameters", "[", "i", "]", ".", "Source", "==", "SourceHeader", "{", "key", "=", "textproto", ".", "CanonicalMIMEHeaderKey", "(", "h", ".", "JSONStringParameters", "[", "i", "]", ".", "Name", ")", "\n", "}", "\n\n", "ReplaceParameter", "(", "key", ",", "source", ",", "newArg", ")", "\n", "}", "else", "{", "errors", "=", "append", "(", "errors", ",", "&", "SourceError", "{", "h", ".", "JSONStringParameters", "[", "i", "]", "}", ")", "\n", "}", "\n", "}", "else", "{", "errors", "=", "append", "(", "errors", ",", "&", "ArgumentError", "{", "h", ".", "JSONStringParameters", "[", "i", "]", "}", ")", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "errors", ")", ">", "0", "{", "return", "errors", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "ParseJSONParameters", "decodes", "specified", "arguments", "to", "JSON", "objects", "and", "replaces", "the", "string", "with", "the", "newly", "created", "object" ]

[ "func", "(", "h", "*", "Hooks", ")", "Append", "(", "other", "*", "Hooks", ")", "error", "{", "for", "_", ",", "hook", ":=", "range", "*", "other", "{", "if", "h", ".", "Match", "(", "hook", ".", "ID", ")", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "hook", ".", "ID", ")", "\n", "}", "\n\n", "*", "h", "=", "append", "(", "*", "h", ",", "hook", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Append", "appends", "hooks", "unless", "the", "new", "hooks", "contain", "a", "hook", "with", "an", "ID", "that", "already", "exists" ]

[ "func", "(", "h", "*", "Hooks", ")", "Match", "(", "id", "string", ")", "*", "Hook", "{", "for", "i", ":=", "range", "*", "h", "{", "if", "(", "*", "h", ")", "[", "i", "]", ".", "ID", "==", "id", "{", "return", "&", "(", "*", "h", ")", "[", "i", "]", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Match", "iterates", "through", "Hooks", "and", "returns", "first", "one", "that", "matches", "the", "given", "ID", "if", "no", "hook", "matches", "the", "given", "ID", "nil", "is", "returned" ]

[ "func", "(", "r", "Rules", ")", "Evaluate", "(", "headers", ",", "query", ",", "payload", "*", "map", "[", "string", "]", "interface", "{", "}", ",", "body", "*", "[", "]", "byte", ",", "remoteAddr", "string", ")", "(", "bool", ",", "error", ")", "{", "switch", "{", "case", "r", ".", "And", "!=", "nil", ":", "return", "r", ".", "And", ".", "Evaluate", "(", "headers", ",", "query", ",", "payload", ",", "body", ",", "remoteAddr", ")", "\n", "case", "r", ".", "Or", "!=", "nil", ":", "return", "r", ".", "Or", ".", "Evaluate", "(", "headers", ",", "query", ",", "payload", ",", "body", ",", "remoteAddr", ")", "\n", "case", "r", ".", "Not", "!=", "nil", ":", "return", "r", ".", "Not", ".", "Evaluate", "(", "headers", ",", "query", ",", "payload", ",", "body", ",", "remoteAddr", ")", "\n", "case", "r", ".", "Match", "!=", "nil", ":", "return", "r", ".", "Match", ".", "Evaluate", "(", "headers", ",", "query", ",", "payload", ",", "body", ",", "remoteAddr", ")", "\n", "}", "\n\n", "return", "false", ",", "nil", "\n", "}" ]

[ "Evaluate", "finds", "the", "first", "rule", "property", "that", "is", "not", "nil", "and", "returns", "the", "value", "it", "evaluates", "to" ]

[ "func", "(", "r", "AndRule", ")", "Evaluate", "(", "headers", ",", "query", ",", "payload", "*", "map", "[", "string", "]", "interface", "{", "}", ",", "body", "*", "[", "]", "byte", ",", "remoteAddr", "string", ")", "(", "bool", ",", "error", ")", "{", "res", ":=", "true", "\n\n", "for", "_", ",", "v", ":=", "range", "r", "{", "rv", ",", "err", ":=", "v", ".", "Evaluate", "(", "headers", ",", "query", ",", "payload", ",", "body", ",", "remoteAddr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "res", "=", "res", "&&", "rv", "\n", "if", "!", "res", "{", "return", "res", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "Evaluate", "AndRule", "will", "return", "true", "if", "and", "only", "if", "all", "of", "ChildRules", "evaluate", "to", "true" ]

[ "func", "(", "r", "NotRule", ")", "Evaluate", "(", "headers", ",", "query", ",", "payload", "*", "map", "[", "string", "]", "interface", "{", "}", ",", "body", "*", "[", "]", "byte", ",", "remoteAddr", "string", ")", "(", "bool", ",", "error", ")", "{", "rv", ",", "err", ":=", "Rules", "(", "r", ")", ".", "Evaluate", "(", "headers", ",", "query", ",", "payload", ",", "body", ",", "remoteAddr", ")", "\n", "return", "!", "rv", ",", "err", "\n", "}" ]

[ "Evaluate", "NotRule", "will", "return", "true", "if", "and", "only", "if", "ChildRule", "evaluates", "to", "false" ]

[ "func", "(", "r", "MatchRule", ")", "Evaluate", "(", "headers", ",", "query", ",", "payload", "*", "map", "[", "string", "]", "interface", "{", "}", ",", "body", "*", "[", "]", "byte", ",", "remoteAddr", "string", ")", "(", "bool", ",", "error", ")", "{", "if", "r", ".", "Type", "==", "IPWhitelist", "{", "return", "CheckIPWhitelist", "(", "remoteAddr", ",", "r", ".", "IPRange", ")", "\n", "}", "\n", "if", "r", ".", "Type", "==", "ScalrSignature", "{", "return", "CheckScalrSignature", "(", "*", "headers", ",", "*", "body", ",", "r", ".", "Secret", ",", "true", ")", "\n", "}", "\n\n", "if", "arg", ",", "ok", ":=", "r", ".", "Parameter", ".", "Get", "(", "headers", ",", "query", ",", "payload", ")", ";", "ok", "{", "switch", "r", ".", "Type", "{", "case", "MatchValue", ":", "return", "arg", "==", "r", ".", "Value", ",", "nil", "\n", "case", "MatchRegex", ":", "return", "regexp", ".", "MatchString", "(", "r", ".", "Regex", ",", "arg", ")", "\n", "case", "MatchHashSHA1", ":", "_", ",", "err", ":=", "CheckPayloadSignature", "(", "*", "body", ",", "r", ".", "Secret", ",", "arg", ")", "\n", "return", "err", "==", "nil", ",", "err", "\n", "case", "MatchHashSHA256", ":", "_", ",", "err", ":=", "CheckPayloadSignature256", "(", "*", "body", ",", "r", ".", "Secret", ",", "arg", ")", "\n", "return", "err", "==", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "return", "false", ",", "nil", "\n", "}" ]

[ "Evaluate", "MatchRule", "will", "return", "based", "on", "the", "type" ]

[ "func", "(", "b", "IPv6", ")", "SourceAddress", "(", ")", "tcpip", ".", "Address", "{", "return", "tcpip", ".", "Address", "(", "b", "[", "v6SrcAddr", ":", "v6SrcAddr", "+", "IPv6AddressSize", "]", ")", "\n", "}" ]

[ "SourceAddress", "returns", "the", "source", "address", "field", "of", "the", "ipv6", "header", "." ]

[ "func", "(", "b", "IPv6", ")", "DestinationAddress", "(", ")", "tcpip", ".", "Address", "{", "return", "tcpip", ".", "Address", "(", "b", "[", "v6DstAddr", ":", "v6DstAddr", "+", "IPv6AddressSize", "]", ")", "\n", "}" ]

[ "DestinationAddress", "returns", "the", "destination", "address", "field", "of", "the", "ipv6", "header", "." ]

[ "func", "(", "b", "IPv6", ")", "TOS", "(", ")", "(", "uint8", ",", "uint32", ")", "{", "v", ":=", "binary", ".", "BigEndian", ".", "Uint32", "(", "b", "[", "versTCFL", ":", "]", ")", "\n", "return", "uint8", "(", "v", ">>", "20", ")", ",", "v", "&", "0xfffff", "\n", "}" ]

[ "TOS", "returns", "the", "traffic", "class", "and", "flow", "label", "fields", "of", "the", "ipv6", "header", "." ]

[ "func", "(", "b", "IPv6", ")", "SetTOS", "(", "t", "uint8", ",", "l", "uint32", ")", "{", "vtf", ":=", "(", "6", "<<", "28", ")", "|", "(", "uint32", "(", "t", ")", "<<", "20", ")", "|", "(", "l", "&", "0xfffff", ")", "\n", "binary", ".", "BigEndian", ".", "PutUint32", "(", "b", "[", "versTCFL", ":", "]", ",", "vtf", ")", "\n", "}" ]

[ "SetTOS", "sets", "the", "traffic", "class", "and", "flow", "label", "fields", "of", "the", "ipv6", "header", "." ]

[ "func", "(", "b", "IPv6", ")", "SetPayloadLength", "(", "payloadLength", "uint16", ")", "{", "binary", ".", "BigEndian", ".", "PutUint16", "(", "b", "[", "payloadLen", ":", "]", ",", "payloadLength", ")", "\n", "}" ]

[ "SetPayloadLength", "sets", "the", "payload", "length", "field", "of", "the", "ipv6", "header", "." ]

[ "func", "(", "b", "IPv6", ")", "SetSourceAddress", "(", "addr", "tcpip", ".", "Address", ")", "{", "copy", "(", "b", "[", "v6SrcAddr", ":", "v6SrcAddr", "+", "IPv6AddressSize", "]", ",", "addr", ")", "\n", "}" ]

[ "SetSourceAddress", "sets", "the", "source", "address", "field", "of", "the", "ipv6", "header", "." ]

[ "func", "(", "b", "IPv6", ")", "SetDestinationAddress", "(", "addr", "tcpip", ".", "Address", ")", "{", "copy", "(", "b", "[", "v6DstAddr", ":", "v6DstAddr", "+", "IPv6AddressSize", "]", ",", "addr", ")", "\n", "}" ]

[ "SetDestinationAddress", "sets", "the", "destination", "address", "field", "of", "the", "ipv6", "header", "." ]

[ "func", "(", "b", "IPv6", ")", "Encode", "(", "i", "*", "IPv6Fields", ")", "{", "b", ".", "SetTOS", "(", "i", ".", "TrafficClass", ",", "i", ".", "FlowLabel", ")", "\n", "b", ".", "SetPayloadLength", "(", "i", ".", "PayloadLength", ")", "\n", "b", "[", "nextHdr", "]", "=", "i", ".", "NextHeader", "\n", "b", "[", "hopLimit", "]", "=", "i", ".", "HopLimit", "\n", "copy", "(", "b", "[", "v6SrcAddr", ":", "v6SrcAddr", "+", "IPv6AddressSize", "]", ",", "i", ".", "SrcAddr", ")", "\n", "copy", "(", "b", "[", "v6DstAddr", ":", "v6DstAddr", "+", "IPv6AddressSize", "]", ",", "i", ".", "DstAddr", ")", "\n", "}" ]

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

[ "func", "SolicitedNodeAddr", "(", "addr", "tcpip", ".", "Address", ")", "tcpip", ".", "Address", "{", "const", "solicitedNodeMulticastPrefix", "=", "\"", "\\xff", "\\x02", "\\x00", "\\x00", "\\x00", "\\x00", "\\x00", "\\x00", "\\x00", "\\x00", "\\x00", "\\x01", "\\xff", "\"", "\n", "return", "solicitedNodeMulticastPrefix", "+", "addr", "[", "len", "(", "addr", ")", "-", "3", ":", "]", "\n", "}" ]

[ "SolicitedNodeAddr", "computes", "the", "solicited", "-", "node", "multicast", "address", ".", "This", "is", "used", "for", "NDP", ".", "Described", "in", "RFC", "4291", ".", "The", "argument", "must", "be", "a", "full", "-", "length", "IPv6", "address", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "Read", "(", "addr", "*", "tcpip", ".", "FullAddress", ")", "(", "buffer", ".", "View", ",", "tcpip", ".", "ControlMessages", ",", "*", "tcpip", ".", "Error", ")", "{", "e", ".", "rcvMu", ".", "Lock", "(", ")", "\n\n", "if", "e", ".", "rcvList", ".", "Empty", "(", ")", "{", "err", ":=", "tcpip", ".", "ErrWouldBlock", "\n", "if", "e", ".", "rcvClosed", "{", "err", "=", "tcpip", ".", "ErrClosedForReceive", "\n", "}", "\n", "e", ".", "rcvMu", ".", "Unlock", "(", ")", "\n", "return", "buffer", ".", "View", "{", "}", ",", "tcpip", ".", "ControlMessages", "{", "}", ",", "err", "\n", "}", "\n\n", "p", ":=", "e", ".", "rcvList", ".", "Front", "(", ")", "\n", "e", ".", "rcvList", ".", "Remove", "(", "p", ")", "\n", "e", ".", "rcvBufSize", "-=", "p", ".", "data", ".", "Size", "(", ")", "\n\n", "e", ".", "rcvMu", ".", "Unlock", "(", ")", "\n\n", "if", "addr", "!=", "nil", "{", "*", "addr", "=", "p", ".", "senderAddress", "\n", "}", "\n\n", "return", "p", ".", "data", ".", "ToView", "(", ")", ",", "tcpip", ".", "ControlMessages", "{", "HasTimestamp", ":", "true", ",", "Timestamp", ":", "p", ".", "timestamp", "}", ",", "nil", "\n", "}" ]

[ "Read", "reads", "data", "from", "the", "endpoint", ".", "This", "method", "does", "not", "block", "if", "there", "is", "no", "data", "pending", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "prepareForWrite", "(", "to", "*", "tcpip", ".", "FullAddress", ")", "(", "retry", "bool", ",", "err", "*", "tcpip", ".", "Error", ")", "{", "switch", "e", ".", "state", "{", "case", "stateInitial", ":", "case", "stateConnected", ":", "return", "false", ",", "nil", "\n\n", "case", "stateBound", ":", "if", "to", "==", "nil", "{", "return", "false", ",", "tcpip", ".", "ErrDestinationRequired", "\n", "}", "\n", "return", "false", ",", "nil", "\n", "default", ":", "return", "false", ",", "tcpip", ".", "ErrInvalidEndpointState", "\n", "}", "\n\n", "e", ".", "mu", ".", "RUnlock", "(", ")", "\n", "defer", "e", ".", "mu", ".", "RLock", "(", ")", "\n\n", "e", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "e", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "// The state changed when we released the shared locked and re-acquired", "// it in exclusive mode. Try again.", "if", "e", ".", "state", "!=", "stateInitial", "{", "return", "true", ",", "nil", "\n", "}", "\n\n", "// The state is still 'initial', so try to bind the endpoint.", "if", "err", ":=", "e", ".", "bindLocked", "(", "tcpip", ".", "FullAddress", "{", "}", ")", ";", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "return", "true", ",", "nil", "\n", "}" ]

[ "prepareForWrite", "prepares", "the", "endpoint", "for", "sending", "data", ".", "In", "particular", "it", "binds", "it", "if", "it", "s", "still", "in", "the", "initial", "state", ".", "To", "do", "so", "it", "must", "first", "reacquire", "the", "mutex", "in", "exclusive", "mode", ".", "Returns", "true", "for", "retry", "if", "preparation", "should", "be", "retried", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "connectRoute", "(", "nicid", "tcpip", ".", "NICID", ",", "addr", "tcpip", ".", "FullAddress", ")", "(", "stack", ".", "Route", ",", "tcpip", ".", "NICID", ",", "tcpip", ".", "NetworkProtocolNumber", ",", "*", "tcpip", ".", "Error", ")", "{", "netProto", ",", "err", ":=", "e", ".", "checkV4Mapped", "(", "&", "addr", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "stack", ".", "Route", "{", "}", ",", "0", ",", "0", ",", "err", "\n", "}", "\n\n", "localAddr", ":=", "e", ".", "id", ".", "LocalAddress", "\n", "if", "header", ".", "IsV4MulticastAddress", "(", "addr", ".", "Addr", ")", "||", "header", ".", "IsV6MulticastAddress", "(", "addr", ".", "Addr", ")", "{", "if", "nicid", "==", "0", "{", "nicid", "=", "e", ".", "multicastNICID", "\n", "}", "\n", "if", "localAddr", "==", "\"", "\"", "{", "localAddr", "=", "e", ".", "multicastAddr", "\n", "}", "\n", "}", "\n\n", "// Find a route to the desired destination.", "r", ",", "err", ":=", "e", ".", "stack", ".", "FindRoute", "(", "nicid", ",", "localAddr", ",", "addr", ".", "Addr", ",", "netProto", ",", "e", ".", "multicastLoop", ")", "\n", "if", "err", "!=", "nil", "{", "return", "stack", ".", "Route", "{", "}", ",", "0", ",", "0", ",", "err", "\n", "}", "\n", "return", "r", ",", "nicid", ",", "netProto", ",", "nil", "\n", "}" ]

[ "connectRoute", "establishes", "a", "route", "to", "the", "specified", "interface", "or", "the", "configured", "multicast", "interface", "if", "no", "interface", "is", "specified", "and", "the", "specified", "address", "is", "a", "multicast", "address", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "Peek", "(", "[", "]", "[", "]", "byte", ")", "(", "uintptr", ",", "tcpip", ".", "ControlMessages", ",", "*", "tcpip", ".", "Error", ")", "{", "return", "0", ",", "tcpip", ".", "ControlMessages", "{", "}", ",", "nil", "\n", "}" ]

[ "Peek", "only", "returns", "data", "from", "a", "single", "datagram", "so", "do", "nothing", "here", "." ]

[ "func", "sendUDP", "(", "r", "*", "stack", ".", "Route", ",", "data", "buffer", ".", "VectorisedView", ",", "localPort", ",", "remotePort", "uint16", ",", "ttl", "uint8", ")", "*", "tcpip", ".", "Error", "{", "// Allocate a buffer for the UDP header.", "hdr", ":=", "buffer", ".", "NewPrependable", "(", "header", ".", "UDPMinimumSize", "+", "int", "(", "r", ".", "MaxHeaderLength", "(", ")", ")", ")", "\n\n", "// Initialize the header.", "udp", ":=", "header", ".", "UDP", "(", "hdr", ".", "Prepend", "(", "header", ".", "UDPMinimumSize", ")", ")", "\n\n", "length", ":=", "uint16", "(", "hdr", ".", "UsedLength", "(", ")", "+", "data", ".", "Size", "(", ")", ")", "\n", "udp", ".", "Encode", "(", "&", "header", ".", "UDPFields", "{", "SrcPort", ":", "localPort", ",", "DstPort", ":", "remotePort", ",", "Length", ":", "length", ",", "}", ")", "\n\n", "// Only calculate the checksum if offloading isn't supported.", "if", "r", ".", "Capabilities", "(", ")", "&", "stack", ".", "CapabilityTXChecksumOffload", "==", "0", "{", "xsum", ":=", "r", ".", "PseudoHeaderChecksum", "(", "ProtocolNumber", ",", "length", ")", "\n", "for", "_", ",", "v", ":=", "range", "data", ".", "Views", "(", ")", "{", "xsum", "=", "header", ".", "Checksum", "(", "v", ",", "xsum", ")", "\n", "}", "\n", "udp", ".", "SetChecksum", "(", "^", "udp", ".", "CalculateChecksum", "(", "xsum", ")", ")", "\n", "}", "\n\n", "// Track count of packets sent.", "r", ".", "Stats", "(", ")", ".", "UDP", ".", "PacketsSent", ".", "Increment", "(", ")", "\n\n", "return", "r", ".", "WritePacket", "(", "nil", "/* gso */", ",", "hdr", ",", "data", ",", "ProtocolNumber", ",", "ttl", ")", "\n", "}" ]

[ "sendUDP", "sends", "a", "UDP", "segment", "via", "the", "provided", "network", "endpoint", "and", "under", "the", "provided", "identity", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "GetLocalAddress", "(", ")", "(", "tcpip", ".", "FullAddress", ",", "*", "tcpip", ".", "Error", ")", "{", "e", ".", "mu", ".", "RLock", "(", ")", "\n", "defer", "e", ".", "mu", ".", "RUnlock", "(", ")", "\n\n", "return", "tcpip", ".", "FullAddress", "{", "NIC", ":", "e", ".", "regNICID", ",", "Addr", ":", "e", ".", "id", ".", "LocalAddress", ",", "Port", ":", "e", ".", "id", ".", "LocalPort", ",", "}", ",", "nil", "\n", "}" ]

[ "GetLocalAddress", "returns", "the", "address", "to", "which", "the", "endpoint", "is", "bound", "." ]

[ "func", "(", "t", "*", "timer", ")", "init", "(", "w", "*", "sleep", ".", "Waker", ")", "{", "t", ".", "state", "=", "timerStateDisabled", "\n\n", "// Initialize a runtime timer that will assert the waker, then", "// immediately stop it.", "t", ".", "timer", "=", "time", ".", "AfterFunc", "(", "time", ".", "Hour", ",", "func", "(", ")", "{", "w", ".", "Assert", "(", ")", "\n", "}", ")", "\n", "t", ".", "timer", ".", "Stop", "(", ")", "\n", "}" ]

[ "init", "initializes", "the", "timer", ".", "Once", "it", "expires", "it", "the", "given", "waker", "will", "be", "asserted", "." ]

[ "func", "(", "t", "*", "timer", ")", "enable", "(", "d", "time", ".", "Duration", ")", "{", "t", ".", "target", "=", "time", ".", "Now", "(", ")", ".", "Add", "(", "d", ")", "\n\n", "// Check if we need to set the runtime timer.", "if", "t", ".", "state", "==", "timerStateDisabled", "||", "t", ".", "target", ".", "Before", "(", "t", ".", "runtimeTarget", ")", "{", "t", ".", "runtimeTarget", "=", "t", ".", "target", "\n", "t", ".", "timer", ".", "Reset", "(", "d", ")", "\n", "}", "\n\n", "t", ".", "state", "=", "timerStateEnabled", "\n", "}" ]

[ "enable", "enables", "the", "timer", "programming", "the", "runtime", "timer", "if", "necessary", "." ]

[ "func", "NewServer", "(", "ctx", "context", ".", "Context", ",", "c", "conn", ",", "addrs", "[", "]", "tcpip", ".", "Address", ",", "cfg", "Config", ")", "(", "*", "Server", ",", "error", ")", "{", "if", "cfg", ".", "ServerAddress", "==", "\"", "\"", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "s", ":=", "&", "Server", "{", "conn", ":", "c", ",", "addrs", ":", "addrs", ",", "cfg", ":", "cfg", ",", "cfgopts", ":", "cfg", ".", "encode", "(", ")", ",", "broadcast", ":", "tcpip", ".", "FullAddress", "{", "Addr", ":", "\"", "\\xff", "\\xff", "\\xff", "\\xff", "\"", ",", "Port", ":", "ClientPort", ",", "}", ",", "handlers", ":", "make", "(", "[", "]", "chan", "header", ",", "8", ")", ",", "leases", ":", "make", "(", "map", "[", "tcpip", ".", "LinkAddress", "]", "serverLease", ")", ",", "}", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "s", ".", "handlers", ")", ";", "i", "++", "{", "ch", ":=", "make", "(", "chan", "header", ",", "8", ")", "\n", "s", ".", "handlers", "[", "i", "]", "=", "ch", "\n", "go", "s", ".", "handler", "(", "ctx", ",", "ch", ")", "\n", "}", "\n\n", "go", "s", ".", "expirer", "(", "ctx", ")", "\n", "go", "s", ".", "reader", "(", "ctx", ")", "\n", "return", "s", ",", "nil", "\n", "}" ]

[ "NewServer", "creates", "a", "new", "DHCP", "server", "and", "begins", "serving", ".", "The", "server", "continues", "serving", "until", "ctx", "is", "done", "." ]

[ "func", "(", "s", "*", "Server", ")", "reader", "(", "ctx", "context", ".", "Context", ")", "{", "for", "{", "v", ",", "_", ",", "err", ":=", "s", ".", "conn", ".", "Read", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "h", ":=", "header", "(", "v", ")", "\n", "if", "!", "h", ".", "isValid", "(", ")", "||", "h", ".", "op", "(", ")", "!=", "opRequest", "{", "continue", "\n", "}", "\n", "xid", ":=", "h", ".", "xid", "(", ")", "\n\n", "// Fan out the packet to a handler goroutine.", "//", "// Use a consistent handler for a given xid, so that", "// packets from a particular client are processed", "// in order.", "ch", ":=", "s", ".", "handlers", "[", "int", "(", "xid", ")", "%", "len", "(", "s", ".", "handlers", ")", "]", "\n", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "\n", "case", "ch", "<-", "h", ":", "default", ":", "// drop the packet", "}", "\n", "}", "\n", "}" ]

[ "reader", "listens", "for", "all", "incoming", "DHCP", "packets", "and", "fans", "them", "out", "to", "handling", "goroutines", "based", "on", "XID", "as", "session", "identifiers", "." ]

[ "func", "(", "f", "*", "Fragmentation", ")", "Process", "(", "id", "uint32", ",", "first", ",", "last", "uint16", ",", "more", "bool", ",", "vv", "buffer", ".", "VectorisedView", ")", "(", "buffer", ".", "VectorisedView", ",", "bool", ")", "{", "f", ".", "mu", ".", "Lock", "(", ")", "\n", "r", ",", "ok", ":=", "f", ".", "reassemblers", "[", "id", "]", "\n", "if", "ok", "&&", "r", ".", "tooOld", "(", "f", ".", "timeout", ")", "{", "// This is very likely to be an id-collision or someone performing a slow-rate attack.", "f", ".", "release", "(", "r", ")", "\n", "ok", "=", "false", "\n", "}", "\n", "if", "!", "ok", "{", "r", "=", "newReassembler", "(", "id", ")", "\n", "f", ".", "reassemblers", "[", "id", "]", "=", "r", "\n", "f", ".", "rList", ".", "PushFront", "(", "r", ")", "\n", "}", "\n", "f", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "res", ",", "done", ",", "consumed", ":=", "r", ".", "process", "(", "first", ",", "last", ",", "more", ",", "vv", ")", "\n\n", "f", ".", "mu", ".", "Lock", "(", ")", "\n", "f", ".", "size", "+=", "consumed", "\n", "if", "done", "{", "f", ".", "release", "(", "r", ")", "\n", "}", "\n", "// Evict reassemblers if we are consuming more memory than highLimit until", "// we reach lowLimit.", "if", "f", ".", "size", ">", "f", ".", "highLimit", "{", "tail", ":=", "f", ".", "rList", ".", "Back", "(", ")", "\n", "for", "f", ".", "size", ">", "f", ".", "lowLimit", "&&", "tail", "!=", "nil", "{", "f", ".", "release", "(", "tail", ")", "\n", "tail", "=", "tail", ".", "Prev", "(", ")", "\n", "}", "\n", "}", "\n", "f", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "res", ",", "done", "\n", "}" ]

[ "Process", "processes", "an", "incoming", "fragment", "beloning", "to", "an", "ID", "and", "returns", "a", "complete", "packet", "when", "all", "the", "packets", "belonging", "to", "that", "ID", "have", "been", "received", "." ]

[ "func", "IPv6", "(", "t", "*", "testing", ".", "T", ",", "b", "[", "]", "byte", ",", "checkers", "...", "NetworkChecker", ")", "{", "t", ".", "Helper", "(", ")", "\n\n", "ipv6", ":=", "header", ".", "IPv6", "(", "b", ")", "\n", "if", "!", "ipv6", ".", "IsValid", "(", "len", "(", "b", ")", ")", "{", "t", ".", "Error", "(", "\"", "\"", ")", "\n", "}", "\n\n", "for", "_", ",", "f", ":=", "range", "checkers", "{", "f", "(", "t", ",", "[", "]", "header", ".", "Network", "{", "ipv6", "}", ")", "\n", "}", "\n", "if", "t", ".", "Failed", "(", ")", "{", "t", ".", "FailNow", "(", ")", "\n", "}", "\n", "}" ]

[ "IPv6", "checks", "the", "validity", "and", "properties", "of", "the", "given", "IPv6", "packet", ".", "The", "usage", "is", "similar", "to", "IPv4", "." ]

[ "func", "SrcAddr", "(", "addr", "tcpip", ".", "Address", ")", "NetworkChecker", "{", "return", "func", "(", "t", "*", "testing", ".", "T", ",", "h", "[", "]", "header", ".", "Network", ")", "{", "t", ".", "Helper", "(", ")", "\n\n", "if", "a", ":=", "h", "[", "0", "]", ".", "SourceAddress", "(", ")", ";", "a", "!=", "addr", "{", "t", ".", "Errorf", "(", "\"", "\"", ",", "a", ",", "addr", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "SrcAddr", "creates", "a", "checker", "that", "checks", "the", "source", "address", "." ]

[ "func", "DstAddr", "(", "addr", "tcpip", ".", "Address", ")", "NetworkChecker", "{", "return", "func", "(", "t", "*", "testing", ".", "T", ",", "h", "[", "]", "header", ".", "Network", ")", "{", "t", ".", "Helper", "(", ")", "\n\n", "if", "a", ":=", "h", "[", "0", "]", ".", "DestinationAddress", "(", ")", ";", "a", "!=", "addr", "{", "t", ".", "Errorf", "(", "\"", "\"", ",", "a", ",", "addr", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "DstAddr", "creates", "a", "checker", "that", "checks", "the", "destination", "address", "." ]

[ "func", "PayloadLen", "(", "plen", "int", ")", "NetworkChecker", "{", "return", "func", "(", "t", "*", "testing", ".", "T", ",", "h", "[", "]", "header", ".", "Network", ")", "{", "t", ".", "Helper", "(", ")", "\n\n", "if", "l", ":=", "len", "(", "h", "[", "0", "]", ".", "Payload", "(", ")", ")", ";", "l", "!=", "plen", "{", "t", ".", "Errorf", "(", "\"", "\"", ",", "l", ",", "plen", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "PayloadLen", "creates", "a", "checker", "that", "checks", "the", "payload", "length", "." ]

[ "func", "FragmentOffset", "(", "offset", "uint16", ")", "NetworkChecker", "{", "return", "func", "(", "t", "*", "testing", ".", "T", ",", "h", "[", "]", "header", ".", "Network", ")", "{", "t", ".", "Helper", "(", ")", "\n\n", "// We only do this of IPv4 for now.", "switch", "ip", ":=", "h", "[", "0", "]", ".", "(", "type", ")", "{", "case", "header", ".", "IPv4", ":", "if", "v", ":=", "ip", ".", "FragmentOffset", "(", ")", ";", "v", "!=", "offset", "{", "t", ".", "Errorf", "(", "\"", "\"", ",", "v", ",", "offset", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "FragmentOffset", "creates", "a", "checker", "that", "checks", "the", "FragmentOffset", "field", "." ]

[ "func", "FragmentFlags", "(", "flags", "uint8", ")", "NetworkChecker", "{", "return", "func", "(", "t", "*", "testing", ".", "T", ",", "h", "[", "]", "header", ".", "Network", ")", "{", "t", ".", "Helper", "(", ")", "\n\n", "// We only do this of IPv4 for now.", "switch", "ip", ":=", "h", "[", "0", "]", ".", "(", "type", ")", "{", "case", "header", ".", "IPv4", ":", "if", "v", ":=", "ip", ".", "Flags", "(", ")", ";", "v", "!=", "flags", "{", "t", ".", "Errorf", "(", "\"", "\"", ",", "v", ",", "flags", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "FragmentFlags", "creates", "a", "checker", "that", "checks", "the", "fragment", "flags", "field", "." ]

[ "func", "TOS", "(", "tos", "uint8", ",", "label", "uint32", ")", "NetworkChecker", "{", "return", "func", "(", "t", "*", "testing", ".", "T", ",", "h", "[", "]", "header", ".", "Network", ")", "{", "t", ".", "Helper", "(", ")", "\n\n", "if", "v", ",", "l", ":=", "h", "[", "0", "]", ".", "TOS", "(", ")", ";", "v", "!=", "tos", "||", "l", "!=", "label", "{", "t", ".", "Errorf", "(", "\"", "\"", ",", "v", ",", "l", ",", "tos", ",", "label", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "TOS", "creates", "a", "checker", "that", "checks", "the", "TOS", "field", "." ]

[ "func", "Raw", "(", "want", "[", "]", "byte", ")", "NetworkChecker", "{", "return", "func", "(", "t", "*", "testing", ".", "T", ",", "h", "[", "]", "header", ".", "Network", ")", "{", "t", ".", "Helper", "(", ")", "\n\n", "if", "got", ":=", "h", "[", "len", "(", "h", ")", "-", "1", "]", ".", "Payload", "(", ")", ";", "!", "reflect", ".", "DeepEqual", "(", "got", ",", "want", ")", "{", "t", ".", "Errorf", "(", "\"", "\"", ",", "got", ",", "want", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Raw", "creates", "a", "checker", "that", "checks", "the", "bytes", "of", "payload", ".", "The", "checker", "always", "checks", "the", "payload", "of", "the", "last", "network", "header", ".", "For", "instance", "in", "case", "of", "IPv6", "fragments", "the", "payload", "that", "will", "be", "checked", "is", "the", "one", "containing", "the", "actual", "data", "that", "the", "packet", "is", "carrying", "without", "the", "bytes", "added", "by", "the", "IPv6", "fragmentation", "." ]

[ "func", "IPv6Fragment", "(", "checkers", "...", "NetworkChecker", ")", "NetworkChecker", "{", "return", "func", "(", "t", "*", "testing", ".", "T", ",", "h", "[", "]", "header", ".", "Network", ")", "{", "t", ".", "Helper", "(", ")", "\n\n", "if", "p", ":=", "h", "[", "0", "]", ".", "TransportProtocol", "(", ")", ";", "p", "!=", "header", ".", "IPv6FragmentHeader", "{", "t", ".", "Errorf", "(", "\"", "\"", ",", "p", ",", "header", ".", "UDPProtocolNumber", ")", "\n", "}", "\n\n", "ipv6Frag", ":=", "header", ".", "IPv6Fragment", "(", "h", "[", "0", "]", ".", "Payload", "(", ")", ")", "\n", "if", "!", "ipv6Frag", ".", "IsValid", "(", ")", "{", "t", ".", "Error", "(", "\"", "\"", ")", "\n", "}", "\n\n", "for", "_", ",", "f", ":=", "range", "checkers", "{", "f", "(", "t", ",", "[", "]", "header", ".", "Network", "{", "h", "[", "0", "]", ",", "ipv6Frag", "}", ")", "\n", "}", "\n", "if", "t", ".", "Failed", "(", ")", "{", "t", ".", "FailNow", "(", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "IPv6Fragment", "creates", "a", "checker", "that", "validates", "an", "IPv6", "fragment", "." ]

[ "func", "TCP", "(", "checkers", "...", "TransportChecker", ")", "NetworkChecker", "{", "return", "func", "(", "t", "*", "testing", ".", "T", ",", "h", "[", "]", "header", ".", "Network", ")", "{", "t", ".", "Helper", "(", ")", "\n\n", "first", ":=", "h", "[", "0", "]", "\n", "last", ":=", "h", "[", "len", "(", "h", ")", "-", "1", "]", "\n\n", "if", "p", ":=", "last", ".", "TransportProtocol", "(", ")", ";", "p", "!=", "header", ".", "TCPProtocolNumber", "{", "t", ".", "Errorf", "(", "\"", "\"", ",", "p", ",", "header", ".", "TCPProtocolNumber", ")", "\n", "}", "\n\n", "// Verify the checksum.", "tcp", ":=", "header", ".", "TCP", "(", "last", ".", "Payload", "(", ")", ")", "\n", "l", ":=", "uint16", "(", "len", "(", "tcp", ")", ")", "\n\n", "xsum", ":=", "header", ".", "Checksum", "(", "[", "]", "byte", "(", "first", ".", "SourceAddress", "(", ")", ")", ",", "0", ")", "\n", "xsum", "=", "header", ".", "Checksum", "(", "[", "]", "byte", "(", "first", ".", "DestinationAddress", "(", ")", ")", ",", "xsum", ")", "\n", "xsum", "=", "header", ".", "Checksum", "(", "[", "]", "byte", "{", "0", ",", "byte", "(", "last", ".", "TransportProtocol", "(", ")", ")", "}", ",", "xsum", ")", "\n", "xsum", "=", "header", ".", "Checksum", "(", "[", "]", "byte", "{", "byte", "(", "l", ">>", "8", ")", ",", "byte", "(", "l", ")", "}", ",", "xsum", ")", "\n", "xsum", "=", "header", ".", "Checksum", "(", "tcp", ",", "xsum", ")", "\n\n", "if", "xsum", "!=", "0", "&&", "xsum", "!=", "0xffff", "{", "t", ".", "Errorf", "(", "\"", "\"", ",", "xsum", ",", "tcp", ".", "Checksum", "(", ")", ")", "\n", "}", "\n\n", "// Run the transport checkers.", "for", "_", ",", "f", ":=", "range", "checkers", "{", "f", "(", "t", ",", "tcp", ")", "\n", "}", "\n", "if", "t", ".", "Failed", "(", ")", "{", "t", ".", "FailNow", "(", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "TCP", "creates", "a", "checker", "that", "checks", "that", "the", "transport", "protocol", "is", "TCP", "and", "potentially", "additional", "transport", "header", "fields", "." ]

[ "func", "UDP", "(", "checkers", "...", "TransportChecker", ")", "NetworkChecker", "{", "return", "func", "(", "t", "*", "testing", ".", "T", ",", "h", "[", "]", "header", ".", "Network", ")", "{", "t", ".", "Helper", "(", ")", "\n\n", "last", ":=", "h", "[", "len", "(", "h", ")", "-", "1", "]", "\n\n", "if", "p", ":=", "last", ".", "TransportProtocol", "(", ")", ";", "p", "!=", "header", ".", "UDPProtocolNumber", "{", "t", ".", "Errorf", "(", "\"", "\"", ",", "p", ",", "header", ".", "UDPProtocolNumber", ")", "\n", "}", "\n\n", "udp", ":=", "header", ".", "UDP", "(", "last", ".", "Payload", "(", ")", ")", "\n", "for", "_", ",", "f", ":=", "range", "checkers", "{", "f", "(", "t", ",", "udp", ")", "\n", "}", "\n", "if", "t", ".", "Failed", "(", ")", "{", "t", ".", "FailNow", "(", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "UDP", "creates", "a", "checker", "that", "checks", "that", "the", "transport", "protocol", "is", "UDP", "and", "potentially", "additional", "transport", "header", "fields", "." ]

[ "func", "SrcPort", "(", "port", "uint16", ")", "TransportChecker", "{", "return", "func", "(", "t", "*", "testing", ".", "T", ",", "h", "header", ".", "Transport", ")", "{", "t", ".", "Helper", "(", ")", "\n\n", "if", "p", ":=", "h", ".", "SourcePort", "(", ")", ";", "p", "!=", "port", "{", "t", ".", "Errorf", "(", "\"", "\"", ",", "p", ",", "port", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "SrcPort", "creates", "a", "checker", "that", "checks", "the", "source", "port", "." ]

[ "func", "DstPort", "(", "port", "uint16", ")", "TransportChecker", "{", "return", "func", "(", "t", "*", "testing", ".", "T", ",", "h", "header", ".", "Transport", ")", "{", "if", "p", ":=", "h", ".", "DestinationPort", "(", ")", ";", "p", "!=", "port", "{", "t", ".", "Errorf", "(", "\"", "\"", ",", "p", ",", "port", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "DstPort", "creates", "a", "checker", "that", "checks", "the", "destination", "port", "." ]

[ "func", "SeqNum", "(", "seq", "uint32", ")", "TransportChecker", "{", "return", "func", "(", "t", "*", "testing", ".", "T", ",", "h", "header", ".", "Transport", ")", "{", "t", ".", "Helper", "(", ")", "\n\n", "tcp", ",", "ok", ":=", "h", ".", "(", "header", ".", "TCP", ")", "\n", "if", "!", "ok", "{", "return", "\n", "}", "\n\n", "if", "s", ":=", "tcp", ".", "SequenceNumber", "(", ")", ";", "s", "!=", "seq", "{", "t", ".", "Errorf", "(", "\"", "\"", ",", "s", ",", "seq", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "SeqNum", "creates", "a", "checker", "that", "checks", "the", "sequence", "number", "." ]

[ "func", "AckNum", "(", "seq", "uint32", ")", "TransportChecker", "{", "return", "func", "(", "t", "*", "testing", ".", "T", ",", "h", "header", ".", "Transport", ")", "{", "t", ".", "Helper", "(", ")", "\n", "tcp", ",", "ok", ":=", "h", ".", "(", "header", ".", "TCP", ")", "\n", "if", "!", "ok", "{", "return", "\n", "}", "\n\n", "if", "s", ":=", "tcp", ".", "AckNumber", "(", ")", ";", "s", "!=", "seq", "{", "t", ".", "Errorf", "(", "\"", "\"", ",", "s", ",", "seq", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "AckNum", "creates", "a", "checker", "that", "checks", "the", "ack", "number", "." ]

[ "func", "Window", "(", "window", "uint16", ")", "TransportChecker", "{", "return", "func", "(", "t", "*", "testing", ".", "T", ",", "h", "header", ".", "Transport", ")", "{", "tcp", ",", "ok", ":=", "h", ".", "(", "header", ".", "TCP", ")", "\n", "if", "!", "ok", "{", "return", "\n", "}", "\n\n", "if", "w", ":=", "tcp", ".", "WindowSize", "(", ")", ";", "w", "!=", "window", "{", "t", ".", "Errorf", "(", "\"", "\"", ",", "w", ",", "window", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Window", "creates", "a", "checker", "that", "checks", "the", "tcp", "window", "." ]

[ "func", "TCPFlags", "(", "flags", "uint8", ")", "TransportChecker", "{", "return", "func", "(", "t", "*", "testing", ".", "T", ",", "h", "header", ".", "Transport", ")", "{", "t", ".", "Helper", "(", ")", "\n\n", "tcp", ",", "ok", ":=", "h", ".", "(", "header", ".", "TCP", ")", "\n", "if", "!", "ok", "{", "return", "\n", "}", "\n\n", "if", "f", ":=", "tcp", ".", "Flags", "(", ")", ";", "f", "!=", "flags", "{", "t", ".", "Errorf", "(", "\"", "\"", ",", "f", ",", "flags", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "TCPFlags", "creates", "a", "checker", "that", "checks", "the", "tcp", "flags", "." ]

[ "func", "TCPFlagsMatch", "(", "flags", ",", "mask", "uint8", ")", "TransportChecker", "{", "return", "func", "(", "t", "*", "testing", ".", "T", ",", "h", "header", ".", "Transport", ")", "{", "tcp", ",", "ok", ":=", "h", ".", "(", "header", ".", "TCP", ")", "\n", "if", "!", "ok", "{", "return", "\n", "}", "\n\n", "if", "f", ":=", "tcp", ".", "Flags", "(", ")", ";", "(", "f", "&", "mask", ")", "!=", "(", "flags", "&", "mask", ")", "{", "t", ".", "Errorf", "(", "\"", "\"", ",", "f", ",", "flags", ",", "mask", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "TCPFlagsMatch", "creates", "a", "checker", "that", "checks", "that", "the", "tcp", "flags", "masked", "by", "the", "given", "mask", "match", "the", "supplied", "flags", "." ]

[ "func", "TCPSACKBlockChecker", "(", "sackBlocks", "[", "]", "header", ".", "SACKBlock", ")", "TransportChecker", "{", "return", "func", "(", "t", "*", "testing", ".", "T", ",", "h", "header", ".", "Transport", ")", "{", "t", ".", "Helper", "(", ")", "\n", "tcp", ",", "ok", ":=", "h", ".", "(", "header", ".", "TCP", ")", "\n", "if", "!", "ok", "{", "return", "\n", "}", "\n", "var", "gotSACKBlocks", "[", "]", "header", ".", "SACKBlock", "\n\n", "opts", ":=", "[", "]", "byte", "(", "tcp", ".", "Options", "(", ")", ")", "\n", "limit", ":=", "len", "(", "opts", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "limit", ";", "{", "switch", "opts", "[", "i", "]", "{", "case", "header", ".", "TCPOptionEOL", ":", "i", "=", "limit", "\n", "case", "header", ".", "TCPOptionNOP", ":", "i", "++", "\n", "case", "header", ".", "TCPOptionSACK", ":", "if", "i", "+", "2", ">", "limit", "{", "// Malformed SACK block.", "t", ".", "Errorf", "(", "\"", "\"", ",", "opts", ")", "\n", "}", "\n", "sackOptionLen", ":=", "int", "(", "opts", "[", "i", "+", "1", "]", ")", "\n", "if", "i", "+", "sackOptionLen", ">", "limit", "||", "(", "sackOptionLen", "-", "2", ")", "%", "8", "!=", "0", "{", "// Malformed SACK block.", "t", ".", "Errorf", "(", "\"", "\"", ",", "opts", ")", "\n", "}", "\n", "numBlocks", ":=", "sackOptionLen", "/", "8", "\n", "for", "j", ":=", "0", ";", "j", "<", "numBlocks", ";", "j", "++", "{", "start", ":=", "binary", ".", "BigEndian", ".", "Uint32", "(", "opts", "[", "i", "+", "2", "+", "j", "*", "8", ":", "]", ")", "\n", "end", ":=", "binary", ".", "BigEndian", ".", "Uint32", "(", "opts", "[", "i", "+", "2", "+", "j", "*", "8", "+", "4", ":", "]", ")", "\n", "gotSACKBlocks", "=", "append", "(", "gotSACKBlocks", ",", "header", ".", "SACKBlock", "{", "Start", ":", "seqnum", ".", "Value", "(", "start", ")", ",", "End", ":", "seqnum", ".", "Value", "(", "end", ")", ",", "}", ")", "\n", "}", "\n", "i", "+=", "sackOptionLen", "\n", "default", ":", "// We don't recognize this option, just skip over it.", "if", "i", "+", "2", ">", "limit", "{", "break", "\n", "}", "\n", "l", ":=", "int", "(", "opts", "[", "i", "+", "1", "]", ")", "\n", "if", "l", "<", "2", "||", "i", "+", "l", ">", "limit", "{", "break", "\n", "}", "\n", "i", "+=", "l", "\n", "}", "\n", "}", "\n\n", "if", "!", "reflect", ".", "DeepEqual", "(", "gotSACKBlocks", ",", "sackBlocks", ")", "{", "t", ".", "Errorf", "(", "\"", "\"", ",", "gotSACKBlocks", ",", "sackBlocks", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "TCPSACKBlockChecker", "creates", "a", "checker", "that", "verifies", "that", "the", "segment", "does", "contain", "the", "specified", "SACK", "blocks", "in", "the", "TCP", "options", "." ]

[ "func", "Payload", "(", "want", "[", "]", "byte", ")", "TransportChecker", "{", "return", "func", "(", "t", "*", "testing", ".", "T", ",", "h", "header", ".", "Transport", ")", "{", "if", "got", ":=", "h", ".", "Payload", "(", ")", ";", "!", "reflect", ".", "DeepEqual", "(", "got", ",", "want", ")", "{", "t", ".", "Errorf", "(", "\"", "\"", ",", "got", ",", "want", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Payload", "creates", "a", "checker", "that", "checks", "the", "payload", "." ]

[ "func", "(", "h", "*", "fragHeap", ")", "reassemble", "(", ")", "(", "buffer", ".", "VectorisedView", ",", "error", ")", "{", "curr", ":=", "heap", ".", "Pop", "(", "h", ")", ".", "(", "fragment", ")", "\n", "views", ":=", "curr", ".", "vv", ".", "Views", "(", ")", "\n", "size", ":=", "curr", ".", "vv", ".", "Size", "(", ")", "\n\n", "if", "curr", ".", "offset", "!=", "0", "{", "return", "buffer", ".", "VectorisedView", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "curr", ".", "offset", ")", "\n", "}", "\n\n", "for", "h", ".", "Len", "(", ")", ">", "0", "{", "curr", ":=", "heap", ".", "Pop", "(", "h", ")", ".", "(", "fragment", ")", "\n", "if", "int", "(", "curr", ".", "offset", ")", "<", "size", "{", "curr", ".", "vv", ".", "TrimFront", "(", "size", "-", "int", "(", "curr", ".", "offset", ")", ")", "\n", "}", "else", "if", "int", "(", "curr", ".", "offset", ")", ">", "size", "{", "return", "buffer", ".", "VectorisedView", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "size", ",", "curr", ".", "offset", ")", "\n", "}", "\n", "size", "+=", "curr", ".", "vv", ".", "Size", "(", ")", "\n", "views", "=", "append", "(", "views", ",", "curr", ".", "vv", ".", "Views", "(", ")", "...", ")", "\n", "}", "\n", "return", "buffer", ".", "NewVectorisedView", "(", "size", ",", "views", ")", ",", "nil", "\n", "}" ]

[ "reassamble", "empties", "the", "heap", "and", "returns", "a", "VectorisedView", "containing", "a", "reassambled", "version", "of", "the", "fragments", "inside", "the", "heap", "." ]

[ "func", "(", "e", "*", "endpoint", ")", "HandlePacket", "(", "r", "*", "stack", ".", "Route", ",", "vv", "buffer", ".", "VectorisedView", ")", "{", "headerView", ":=", "vv", ".", "First", "(", ")", "\n", "h", ":=", "header", ".", "IPv6", "(", "headerView", ")", "\n", "if", "!", "h", ".", "IsValid", "(", "vv", ".", "Size", "(", ")", ")", "{", "return", "\n", "}", "\n\n", "vv", ".", "TrimFront", "(", "header", ".", "IPv6MinimumSize", ")", "\n", "vv", ".", "CapLength", "(", "int", "(", "h", ".", "PayloadLength", "(", ")", ")", ")", "\n\n", "p", ":=", "h", ".", "TransportProtocol", "(", ")", "\n", "if", "p", "==", "header", ".", "ICMPv6ProtocolNumber", "{", "e", ".", "handleICMP", "(", "r", ",", "headerView", ",", "vv", ")", "\n", "return", "\n", "}", "\n\n", "r", ".", "Stats", "(", ")", ".", "IP", ".", "PacketsDelivered", ".", "Increment", "(", ")", "\n", "e", ".", "dispatcher", ".", "DeliverTransportPacket", "(", "r", ",", "p", ",", "headerView", ",", "vv", ")", "\n", "}" ]

[ "HandlePacket", "is", "called", "by", "the", "link", "layer", "when", "new", "ipv6", "packets", "arrive", "for", "this", "endpoint", "." ]

[ "func", "(", "p", "*", "protocol", ")", "NewEndpoint", "(", "nicid", "tcpip", ".", "NICID", ",", "addr", "tcpip", ".", "Address", ",", "linkAddrCache", "stack", ".", "LinkAddressCache", ",", "dispatcher", "stack", ".", "TransportDispatcher", ",", "linkEP", "stack", ".", "LinkEndpoint", ")", "(", "stack", ".", "NetworkEndpoint", ",", "*", "tcpip", ".", "Error", ")", "{", "return", "&", "endpoint", "{", "nicid", ":", "nicid", ",", "id", ":", "stack", ".", "NetworkEndpointID", "{", "LocalAddress", ":", "addr", "}", ",", "linkEP", ":", "linkEP", ",", "linkAddrCache", ":", "linkAddrCache", ",", "dispatcher", ":", "dispatcher", ",", "}", ",", "nil", "\n", "}" ]

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

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

[ "SourceAddress", "returns", "the", "MAC", "source", "field", "of", "the", "ethernet", "frame", "header", "." ]