Datasets:

---

iNeil77

/

the-vault-function

like 0

[ "BSD-3-Clause" ]

[ "EchoCharacter", "Purpose", ":", "Echoes", "a", "character", "to", "the", "terminal", ".", "-", "character", "to", "echo", "none" ]

[ "static", "void", "EchoCharacter", "(", "INT8", "c", ")", "{", "if", "(", "IS_ECHO_ON", "(", ")", ")", "{", "if", "(", "c", "==", "(", "INT8", ")", "'", "\\n", "'", ")", "{", "putcUART", "(", "'", "\\r", "'", ")", ";", "}", "putcUART", "(", "c", ")", ";", "}", "}" ]

[ "EchoCharacter", "Purpose", ":", "Echoes", "a", "character", "to", "the", "terminal", "." ]

[ "/* output cr then lf for lf */" ]

[ { "param": "c", "type": "INT8" } ]

[ "BSD-3-Clause" ]

[ "CursorRight_N", "Purpose", ":", "Moves", "the", "cursor", "left", "N", "characters", "to", "the", "right", "-", "number", "of", "characters", "to", "move", "the", "cursor", "to", "the", "left", "This", "sequence", "only", "takes", "a", "single", "digit", "of", "length", "so", "may", "need", "to", "do", "the", "move", "in", "steps", "none" ]

[ "void", "CursorRight_N", "(", "UINT8", "n", ")", "{", "INT8", "sequence_string", "[", "sizeof", "(", "cursorRightEscapeSequence", ")", "+", "2", "]", ";", "if", "(", "n", ">", "0u", ")", "{", "SET_CURSOR", "(", "GET_CURSOR", "(", ")", "+", "n", ")", ";", "sequence_string", "[", "0", "]", "=", "cursorRightEscapeSequence", "[", "0", "]", ";", "sequence_string", "[", "1", "]", "=", "cursorRightEscapeSequence", "[", "1", "]", ";", "if", "(", "n", "<", "10u", ")", "{", "sequence_string", "[", "2", "]", "=", "n", "+", "'", "'", ";", "sequence_string", "[", "3", "]", "=", "cursorRightEscapeSequence", "[", "3", "]", ";", "sequence_string", "[", "4", "]", "=", "'", "\\0", "'", ";", "}", "else", "{", "sequence_string", "[", "2", "]", "=", "(", "n", "/", "10", ")", "+", "'", "'", ";", "sequence_string", "[", "3", "]", "=", "(", "n", "%", "10", ")", "+", "'", "'", ";", "sequence_string", "[", "4", "]", "=", "cursorRightEscapeSequence", "[", "3", "]", ";", "sequence_string", "[", "5", "]", "=", "'", "\\0", "'", ";", "}", "putsUART", "(", "(", "char", "*", ")", "sequence_string", ")", ";", "}", "}" ]

[ "CursorRight_N", "Purpose", ":", "Moves", "the", "cursor", "left", "N", "characters", "to", "the", "right" ]

[ "/* null and extra digit */", "// ASSERT(n <= (strlen(g_ConsoleContext.buf) + CMD_LINE_PROMPT_LENGTH));", "/* ESC */", "/* '[' */", "/* ascii digit */", "/* 'C' */", "/* first ascii digit */", "/* second ascii digit */", "/* 'C' */" ]

[ { "param": "n", "type": "UINT8" } ]

[ "BSD-3-Clause" ]

[ "CursorLeft_N", "Purpose", ":", "Moves", "the", "cursor", "left", "N", "characters", "to", "the", "left", "-", "number", "of", "characters", "to", "move", "the", "cursor", "to", "the", "left", "This", "sequence", "only", "takes", "a", "single", "digit", "of", "length", "so", "may", "need", "to", "do", "the", "move", "in", "steps", "none" ]

[ "void", "CursorLeft_N", "(", "UINT8", "n", ")", "{", "INT8", "sequence_string", "[", "sizeof", "(", "cursorLeftEscapeSequence", ")", "+", "2", "]", ";", "if", "(", "n", ">", "0u", ")", "{", "SET_CURSOR", "(", "GET_CURSOR", "(", ")", "-", "n", ")", ";", "sequence_string", "[", "0", "]", "=", "cursorLeftEscapeSequence", "[", "0", "]", ";", "sequence_string", "[", "1", "]", "=", "cursorLeftEscapeSequence", "[", "1", "]", ";", "if", "(", "n", "<", "10u", ")", "{", "sequence_string", "[", "2", "]", "=", "n", "+", "'", "'", ";", "sequence_string", "[", "3", "]", "=", "cursorLeftEscapeSequence", "[", "3", "]", ";", "sequence_string", "[", "4", "]", "=", "'", "\\0", "'", ";", "}", "else", "{", "sequence_string", "[", "2", "]", "=", "(", "n", "/", "10", ")", "+", "'", "'", ";", "sequence_string", "[", "3", "]", "=", "(", "n", "%", "10", ")", "+", "'", "'", ";", "sequence_string", "[", "4", "]", "=", "cursorLeftEscapeSequence", "[", "3", "]", ";", "sequence_string", "[", "5", "]", "=", "'", "\\0", "'", ";", "}", "putsUART", "(", "(", "char", "*", ")", "sequence_string", ")", ";", "}", "}" ]

[ "CursorLeft_N", "Purpose", ":", "Moves", "the", "cursor", "left", "N", "characters", "to", "the", "left" ]

[ "/* null and extra digit */", "// ASSERT(n <= g_ConsoleContext.cursorIndex + CMD_LINE_PROMPT_LENGTH);", "/* ESC */", "/* '[' */", "/* ascii digit */", "/* 'D' */", "/* first ascii digit */", "/* second ascii digit */", "/* 'D' */" ]

[ { "param": "n", "type": "UINT8" } ]

[ "BSD-3-Clause" ]

[ "Used", "for", "re", "-", "directing", "printf", "when", "uart", "2", "is", "used", "by", "CEA2045", "Remap", "UART", "in", "HardwareProfile", ".", "h" ]

[ "void", "_mon_putc", "(", "char", "c", ")", "{", "unsigned", "int", "ci", ";", "ci", "=", "(", "unsigned", "int", ")", "c", ";", "putcUART", "(", "ci", ")", ";", "}" ]

[ "Used", "for", "re", "-", "directing", "printf", "when", "uart", "2", "is", "used", "by", "CEA2045", "Remap", "UART", "in", "HardwareProfile", ".", "h" ]

[]

[ { "param": "c", "type": "char" } ]

[ "BSD-3-Clause" ]

[ "This", "routine", "initializes", "the", "hardware", ".", "It", "is", "a", "generic", "initialization", "routine", "for", "many", "of", "the", "Microchip", "development", "boards", "using", "definitions", "in", "HardwareProfile", ".", "h", "to", "determine", "specific", "initialization", ".", "None", "None", "None", "None" ]

[ "static", "void", "InitializeBoard", "(", "void", ")", "{", "SI7005_TRIS", "=", "0", ";", "SI7005_IO", "=", "1", ";", "SI7005_IO", "=", "0", ";", "SI7005_IO", "=", "1", ";", "InitI2C", "(", "I2C_BUS", ",", "I2C_CLOCK_FREQ", ")", ";", "SYSTEMConfigPerformance", "(", "GetSystemClock", "(", ")", ")", ";", "mOSCSetPBDIV", "(", "OSC_PB_DIV_1", ")", ";", "DelayMs", "(", "50", ")", ";", "DDPCONbits", ".", "JTAGEN", "=", "0", ";", "LEDS_OFF", "(", ")", ";", "LED0_TRIS", "=", "0", ";", "LED1_TRIS", "=", "0", ";", "LED2_TRIS", "=", "0", ";", "#ifdef", "DC_CEA2045", "SPI_ATTN_INACTIVE", "", "#endif", "SW0_TRIS", "=", "1", ";", "TRISBCLR", "=", "BIT_4", ";", "LATBSET", "=", "BIT_4", ";", "TRISBCLR", "=", "BIT_9", ";", "LATBSET", "=", "BIT_9", ";", "AD1PCFG", "=", "0xFFFF", ";", "CNEN", "=", "0x00000000", ";", "CNCON", "=", "0x00000000", ";", "#ifdef", "AC_CEA2045", "UARTiConfigure", "(", "UART1", ",", "19200", ")", ";", "#endif", "UARTiConfigure", "(", "UART2", ",", "19200", ")", ";", "IFS0CLR", "=", "0xffffffff", ";", "IFS1CLR", "=", "0xffffffff", ";", "IFS2CLR", "=", "0xffffffff", ";", "#ifdef", "DC_CEA2045", "LATCCLR", "=", "BIT_1", ";", "TRISCbits", ".", "TRISC1", "=", "0", ";", "SPI_CS_TRIS", "=", "1", ";", "CN_TURN_ON", "SPI_CS_INT_ENABLE", "", "INTSetVectorPriority", "(", "INT_CHANGE_NOTICE_VECTOR", ",", "INT_PRIORITY_LEVEL_6", ")", ";", "INTSetVectorSubPriority", "(", "INT_CHANGE_NOTICE_VECTOR", ",", "INT_SUB_PRIORITY_LEVEL_0", ")", ";", "INTClearFlag", "(", "INT_CN", ")", ";", "INTEnable", "(", "INT_CN", ",", "INT_ENABLED", ")", ";", "#endif", "#if", "defined", "(", "AC_CEA2045", ")", "\n", "INTSetVectorPriority", "(", "INT_UART_1_VECTOR", ",", "INT_PRIORITY_LEVEL_5", ")", ";", "INTSetVectorSubPriority", "(", "INT_UART_1_VECTOR", ",", "INT_SUB_PRIORITY_LEVEL_0", ")", ";", "INTEnable", "(", "INT_SOURCE_UART_RX", "(", "UART1", ")", ",", "INT_ENABLED", ")", ";", "#endif", "#if", "defined", "(", "DC_CEA2045", ")", "||", "defined", "(", "INTWINE_CONNECTED_OUTLET", ")", "||", "defined", "(", "INTWINE_CONNECTED_LOAD_CONTROL", ")", "\n", "INTSetVectorPriority", "(", "INT_SPI_3_VECTOR", ",", "INT_PRIORITY_LEVEL_4", ")", ";", "INTSetVectorSubPriority", "(", "INT_SPI_3_VECTOR", ",", "INT_SUB_PRIORITY_LEVEL_0", ")", ";", "INTClearFlag", "(", "INT_SPI3RX", ")", ";", "INTClearFlag", "(", "INT_SPI3TX", ")", ";", "INTClearFlag", "(", "INT_SPI3E", ")", ";", "#endif", "TimeMonitorInit", "(", ")", ";", "INTSetVectorPriority", "(", "INT_TIMER_2_VECTOR", ",", "INT_PRIORITY_LEVEL_1", ")", ";", "INTSetVectorSubPriority", "(", "INT_TIMER_2_VECTOR", ",", "INT_SUB_PRIORITY_LEVEL_0", ")", ";", "INTConfigureSystem", "(", "INT_SYSTEM_CONFIG_MULT_VECTOR", ")", ";", "INTEnableSystemMultiVectoredInt", "(", ")", ";", "INTEnableInterrupts", "(", ")", ";", "#ifdef", "AC_CEA2045", "TRISDCLR", "=", "BIT_14", ";", "LATDSET", "=", "BIT_14", ";", "LATDSET", "=", "BIT_15", ";", "TRISFCLR", "=", "BIT_8", ";", "LATFSET", "=", "BIT_8", ";", "#endif", "#ifdef", "DC_CEA2045", "SPI_Driver_Task", "(", ")", ";", "#endif", "SI7005_IO", "=", "0", ";", "DelayMs", "(", "15", ")", ";", "#ifdef", "putrsUART", "putrsUART", "(", "\"", "\\r", "\\n", "\\r", "\\n", "\\r", "\\n", "\\r", "\\n", "\"", ")", ";", "#endif", "}" ]

[ "Function", ":", "static", "void", "InitializeBoard", "(", "void", ")" ]

[ "// Si7005 Temp/Humidity on I2C2", "// Pulse Si7005 CS inactive per data sheet.", "// Si7005 CS inactive. Power down", "// Enable optimal performance", "// Use 1:1 CPU Core:Peripheral clocks", "// Disable JTAG port so we get our I/O pins back, but first", "// wait 50ms so if you want to reprogram the part with", "// JTAG, you'll still have a tiny window before JTAG goes away.", "// The PIC32 Starter Kit debuggers use JTAG and therefore must not", "// disable JTAG.", "// LEDs", "//SPI ATTN", "// Push Button", "// Flash Control", "// HOLD#", "// WP#", "// all PORTB = Digital (as opposed to analog)", "// Shutdown Change Notice?? Can't really find good documentation on this", "// Note: Interrupt priority, 1 is lowest priority to 7 which is highest priority", "// Enable the interrupt sources", "// IPL6 = SPI3 CHIP SELECT (DC_CEA2045)", "// IPL5 = UART2 (AC_CEA2045)", "// IPL4 = SPI3 (DC_CEA2045)", "// IPL3 = SPI1 (MRF24WG) See StackInit()", "// IPL2 = Timer1 See TickInit()", "// IPL1 = Timer2 TimeMonitor", "// Note: WiFi Module hardware Initialization handled by StackInit() Library Routine", "// Note: Timer1 Initialization handled by TickInit() Library Routine", "// Note: Timer2 Initialization handled by TimeMonitorInit()", "// Drive Module Detect line low to tell the SGD that the UCM is present", "// Configure change notification interrupts for SPI CSn line", "//turn on CN module", "//configure SPI chip select pin for CN interrupts ", "// Enable multi-vectored interrupts", "/****************************************************************************\n Bits RF4 and RF4 are multifunction:\n 1. UART1 on AC_CEA2045\n 2. RED and GREEN LEDs on ICO\n 3. Tri-stated on TSTAT\n****************************************************************************/", "// Set RS-485 DE enable to inactive low", "// TX inactive high", "// Initialize SPI I/Os and state machine", "// Enable Si7005 and delay 15 ms" ]

[]

[ "BSD-3-Clause" ]

[ "isMacAddress", "RETURNS", ":", "True", "if", "valid", "MAC", "address", "else", "False", "p_string", "--", "string", "to", "check", "p_Address", "--", "Array", "where", "MAC", "values", "will", "be", "written", "Determines", "if", "the", "input", "string", "is", "a", "valid", "MAC", "address", ".", "If", "it", "is", "then", "returns", "an", "array", "of", "6", "bytes", "for", "each", "of", "the", "values", "." ]

[ "static", "BOOL", "isMacAddress", "(", "INT8", "*", "p_string", ",", "UINT8", "*", "p_Address", ")", "{", "UINT8", "i", ";", "UINT16", "tmp", ";", "if", "(", "strlen", "(", "(", "char", "*", ")", "p_string", ")", "!=", "17u", ")", "{", "return", "FALSE", ";", "}", "for", "(", "i", "=", "2", ";", "i", "<", "17u", ";", "i", "+=", "3", ")", "{", "if", "(", "p_string", "[", "i", "]", "==", "(", "INT8", ")", "'", "'", ")", "{", "p_string", "[", "i", "]", "=", "'", "\\0", "'", ";", "}", "else", "{", "return", "FALSE", ";", "}", "}", "for", "(", "i", "=", "0", ";", "i", "<", "6u", ";", "++", "i", ")", "{", "if", "(", "!", "ConvertASCIIHexToBinary", "(", "&", "p_string", "[", "i", "*", "3", "]", ",", "&", "tmp", ")", ")", "{", "return", "FALSE", ";", "}", "p_Address", "[", "i", "]", "=", "(", "UINT8", ")", "(", "tmp", "&", "0xFF", ")", ";", "}", "return", "TRUE", ";", "}" ]

[ "FUNCTION", ":", "isMacAddress", "RETURNS", ":", "True", "if", "valid", "MAC", "address", "else", "False" ]

[ "// ensure the ':' is in the right place, and if so, set them to 0", "// now extract each hex number string" ]

[ { "param": "p_string", "type": "INT8" }, { "param": "p_Address", "type": "UINT8" } ]

[ "BSD-3-Clause" ]

[ "None", "Responds", "to", "the", "user", "invoking", "ifconfig", "with", "no", "parameters" ]

[ "static", "void", "IfconfigDisplayStatus", "(", "void", ")", "{", "sprintf", "(", "(", "char", "*", ")", "g_ConsoleContext", ".", "txBuf", ",", "\"", "\\t", "\"", ",", "AppConfig", ".", "MyIPAddr", ".", "v", "[", "0", "]", ",", "AppConfig", ".", "MyIPAddr", ".", "v", "[", "1", "]", ",", "AppConfig", ".", "MyIPAddr", ".", "v", "[", "2", "]", ",", "AppConfig", ".", "MyIPAddr", ".", "v", "[", "3", "]", ")", ";", "WFConsolePrintRamStr", "(", "(", "char", "*", ")", "g_ConsoleContext", ".", "txBuf", ",", "TRUE", ")", ";", "sprintf", "(", "(", "char", "*", ")", "g_ConsoleContext", ".", "txBuf", ",", "\"", "\\t", "\"", ",", "AppConfig", ".", "MyMACAddr", ".", "v", "[", "0", "]", ",", "AppConfig", ".", "MyMACAddr", ".", "v", "[", "1", "]", ",", "AppConfig", ".", "MyMACAddr", ".", "v", "[", "2", "]", ",", "AppConfig", ".", "MyMACAddr", ".", "v", "[", "3", "]", ",", "AppConfig", ".", "MyMACAddr", ".", "v", "[", "4", "]", ",", "AppConfig", ".", "MyMACAddr", ".", "v", "[", "5", "]", ")", ";", "WFConsolePrintRamStr", "(", "(", "char", "*", ")", "g_ConsoleContext", ".", "txBuf", ",", "TRUE", ")", ";", "sprintf", "(", "(", "char", "*", ")", "g_ConsoleContext", ".", "txBuf", ",", "\"", "\\t", "\"", ",", "AppConfig", ".", "MyMask", ".", "v", "[", "0", "]", ",", "AppConfig", ".", "MyMask", ".", "v", "[", "1", "]", ",", "AppConfig", ".", "MyMask", ".", "v", "[", "2", "]", ",", "AppConfig", ".", "MyMask", ".", "v", "[", "3", "]", ")", ";", "WFConsolePrintRamStr", "(", "(", "char", "*", ")", "g_ConsoleContext", ".", "txBuf", ",", "TRUE", ")", ";", "sprintf", "(", "(", "char", "*", ")", "g_ConsoleContext", ".", "txBuf", ",", "\"", "\\t", "\"", ",", "AppConfig", ".", "MyGateway", ".", "v", "[", "0", "]", ",", "AppConfig", ".", "MyGateway", ".", "v", "[", "1", "]", ",", "AppConfig", ".", "MyGateway", ".", "v", "[", "2", "]", ",", "AppConfig", ".", "MyGateway", ".", "v", "[", "3", "]", ")", ";", "WFConsolePrintRamStr", "(", "(", "char", "*", ")", "g_ConsoleContext", ".", "txBuf", ",", "TRUE", ")", ";", "#if", "defined", "(", "STACK_USE_DHCP_CLIENT", ")", "\n", "if", "(", "DHCPIsEnabled", "(", "0", ")", ")", "WFConsolePrintRomStr", "(", "\"", "\\t", "\"", ",", "TRUE", ")", ";", "else", "WFConsolePrintRomStr", "(", "\"", "\\t", "\"", ",", "TRUE", ")", ";", "#endif", "}" ]

[ "FUNCTION", ":", "IfconfigDisplayStatus", "RETURNS", ":", "None" ]

[]

[]

[ "BSD-3-Clause" ]

[ "None", "This", "function", "is", "called", "from", "WFProcess", ".", "It", "does", "the", "following", ":", "1", ")", "checks", "for", "and", "processes", "MRF24W", "external", "interrupt", "events", "2", ")", "checks", "for", "and", "processes", "received", "management", "messages", "from", "the", "MRF24W", "3", ")", "maintains", "the", "PS", "-", "Poll", "state", "(", "if", "applicable", ")" ]

[ "void", "WFProcess", "(", "void", ")", "{", "#if", "defined", "(", "__18CXX", ")", "\n", "static", "UINT16", "len", ";", "#else", "UINT16", "len", ";", "#endif", "if", "(", "g_ExIntNeedsServicing", "==", "TRUE", ")", "{", "g_ExIntNeedsServicing", "=", "FALSE", ";", "ProcessInterruptServiceResult", "(", ")", ";", "}", "else", "if", "(", "g_MgmtReadMsgReady", "==", "TRUE", ")", "{", "RawGetMgmtRxBuffer", "(", "&", "len", ")", ";", "g_MgmtReadMsgReady", "=", "FALSE", ";", "ProcessMgmtRxMsg", "(", ")", ";", "WF_EintEnable", "(", ")", ";", "}", "}" ]

[ "FUNCTION", ":", "WFProcess", "RETURNS", ":", "None" ]

[ "//----------------------------------------------------------", "// if there is a MRF24W External interrupt (EINT) to process", "//----------------------------------------------------------", "//----------------------------------------", "// else if there is management msg to read", "//----------------------------------------", "// handle received managment message", "// reenable interrupts" ]

[]

[ "BSD-3-Clause" ]

[ "Read8BitWFRegister", "RETURNS", ":", "register", "value", "-", "ID", "of", "8", "-", "bit", "register", "being", "read", "Reads", "WF", "8", "-", "bit", "register" ]

[ "UINT8", "Read8BitWFRegister", "(", "UINT8", "regId", ")", "{", "g_txBuf", "[", "0", "]", "=", "regId", "|", "WF_READ_REGISTER_MASK", ";", "WF_SpiEnableChipSelect", "(", ")", ";", "WFSpiTxRx", "(", "g_txBuf", ",", "1", ",", "g_rxBuf", ",", "2", ")", ";", "WF_SpiDisableChipSelect", "(", ")", ";", "return", "g_rxBuf", "[", "1", "]", ";", "}" ]

[ "FUNCTION", ":", "Read8BitWFRegister", "RETURNS", ":", "register", "value" ]

[ "/* register value returned in the second byte clocking */" ]

[ { "param": "regId", "type": "UINT8" } ]

[ "BSD-3-Clause" ]

[ "Read16BitWFRegister", "RETURNS", ":", "register", "value", "-", "ID", "of", "16", "-", "bit", "register", "being", "read", "Reads", "WF", "16", "-", "bit", "register" ]

[ "UINT16", "Read16BitWFRegister", "(", "UINT8", "regId", ")", "{", "g_txBuf", "[", "0", "]", "=", "regId", "|", "WF_READ_REGISTER_MASK", ";", "WF_SpiEnableChipSelect", "(", ")", ";", "WFSpiTxRx", "(", "g_txBuf", ",", "1", ",", "g_rxBuf", ",", "3", ")", ";", "WF_SpiDisableChipSelect", "(", ")", ";", "return", "(", "(", "(", "UINT16", ")", "g_rxBuf", "[", "1", "]", ")", "<<", "8", ")", "|", "(", "(", "UINT16", ")", "(", "g_rxBuf", "[", "2", "]", ")", ")", ";", "}" ]

[ "FUNCTION", ":", "Read16BitWFRegister", "RETURNS", ":", "register", "value" ]

[]

[ { "param": "regId", "type": "UINT8" } ]

[ "BSD-3-Clause" ]

[ "Writes", "a", "data", "block", "to", "specified", "raw", "register" ]

[ "void", "WriteWFArray", "(", "UINT8", "regId", ",", "UINT8", "*", "p_Buf", ",", "UINT16", "length", ")", "{", "g_txBuf", "[", "0", "]", "=", "regId", ";", "WF_SpiEnableChipSelect", "(", ")", ";", "WFSpiTxRx", "(", "g_txBuf", ",", "1", ",", "g_rxBuf", ",", "1", ")", ";", "WFSpiTxRx", "(", "p_Buf", ",", "length", ",", "g_rxBuf", ",", "1", ")", ";", "WF_SpiDisableChipSelect", "(", ")", ";", "}" ]

[ "FUNCTION", ":", "WriteWFArray", "RETURNS", ":", "None" ]

[ "/* output cmd byte */", "/* output data array bytes */" ]

[ { "param": "regId", "type": "UINT8" }, { "param": "p_Buf", "type": "UINT8" }, { "param": "length", "type": "UINT16" } ]

[ "BSD-3-Clause" ]

[ "N", "/", "A", "Performs", "the", "necessary", "SPI", "operations", "to", "cause", "the", "MRF24W", "to", "do", "a", "soft", "reset", ".", "This", "function", "waits", "for", "the", "MRF24WG", "to", "complete", "its", "initialization", "before", "returning", "to", "the", "caller", ".", "The", "largest", "part", "of", "the", "wait", "is", "for", "the", "MRF24WG", "to", "download", "any", "patch", "code", "in", "FLASH", "into", "its", "RAM", "." ]

[ "static", "void", "ChipReset", "(", "void", ")", "{", "UINT16", "value", ";", "UINT32", "timeoutPeriod", ";", "UINT32", "startTickCount", ";", "Write16BitWFRegister", "(", "WF_PSPOLL_H_REG", ",", "0x0000", ")", ";", "Write16BitWFRegister", "(", "WF_HOST_RESET_REG", ",", "Read16BitWFRegister", "(", "WF_HOST_RESET_REG", ")", "|", "WF_HOST_RESET_MASK", ")", ";", "Write16BitWFRegister", "(", "WF_HOST_RESET_REG", ",", "Read16BitWFRegister", "(", "WF_HOST_RESET_REG", ")", "&", "~", "WF_HOST_RESET_MASK", ")", ";", "timeoutPeriod", "=", "TICKS_PER_SECOND", "*", "3", ";", "startTickCount", "=", "(", "UINT32", ")", "TickGet", "(", ")", ";", "do", "{", "Write16BitWFRegister", "(", "WF_INDEX_ADDR_REG", ",", "WF_HW_STATUS_REG", ")", ";", "value", "=", "Read16BitWFRegister", "(", "WF_INDEX_DATA_REG", ")", ";", "if", "(", "TickGet", "(", ")", "-", "startTickCount", ">=", "timeoutPeriod", ")", "{", "WF_ASSERT", "(", "FALSE", ")", ";", "}", "}", "while", "(", "(", "value", "&", "WF_HW_STATUS_NOT_IN_RESET_MASK", ")", "==", "0", ")", ";", "WF_ASSERT", "(", "value", "!=", "0xffff", ")", ";", "startTickCount", "=", "(", "UINT32", ")", "TickGet", "(", ")", ";", "do", "{", "value", "=", "Read16BitWFRegister", "(", "WF_HOST_WFIFO_BCNT0_REG", ")", "&", "0x0fff", ";", "if", "(", "TickGet", "(", ")", "-", "startTickCount", ">=", "timeoutPeriod", ")", "{", "WF_ASSERT", "(", "FALSE", ")", ";", "}", "}", "while", "(", "value", "==", "0", ")", ";", "}" ]

[ "FUNCTION", ":", "ChipReset", "RETURNS", ":", "N", "/", "A" ]

[ "/* clear the power bit to disable low power mode on the MRF24W */", "/* Set HOST_RESET bit in register to put device in reset */", "/* Clear HOST_RESET bit in register to take device out of reset */", "/* after reset is started poll register to determine when HW reset has completed */", "/* 3000 ms */", "/* if SPI not connected will read all 1's */", "/* now that chip has come out of HW reset, poll the FIFO byte count register */", "/* which will be set to a non-zero value when the MRF24W initialization is */", "/* complete. */" ]

[]

[ "BSD-3-Clause" ]

[ "The", "bit", "mask", "to", "be", "modified", ".", "state", "-", "One", "of", "WF_INT_DISABLE", "WF_INT_ENABLE", "where", "Disable", "implies", "clearing", "the", "bits", "and", "enable", "sets", "the", "bits", ".", "Initializes", "the", "16", "-", "bit", "Host", "Interrupt", "register", "on", "the", "WiFi", "device", "with", "the", "specified", "mask", "value", "either", "setting", "or", "clearing", "the", "mask", "register", "as", "determined", "by", "the", "input", "parameter", "state", "." ]

[ "static", "void", "HostInterrupt2RegInit", "(", "UINT16", "hostIntMaskRegMask", ",", "UINT8", "state", ")", "{", "UINT16", "int2MaskValue", ";", "int2MaskValue", "=", "Read16BitWFRegister", "(", "WF_HOST_INTR2_MASK_REG", ")", ";", "if", "(", "state", "==", "WF_INT_DISABLE", ")", "{", "int2MaskValue", "&=", "~", "hostIntMaskRegMask", ";", "}", "else", "{", "int2MaskValue", "|=", "hostIntMaskRegMask", ";", "}", "Write16BitWFRegister", "(", "WF_HOST_INTR2_MASK_REG", ",", "int2MaskValue", ")", ";", "Write16BitWFRegister", "(", "WF_HOST_INTR2_REG", ",", "hostIntMaskRegMask", ")", ";", "}" ]

[ "FUNCTION", ":", "HostInterrupt2RegInit", "RETURNS", ":", "N", "/", "A" ]

[ "/* Host Int Register is a status register where each bit indicates a specific event */", "/* has occurred. In addition, writing a 1 to a bit location in this register clears */", "/* the event. */", "/* Host Int Mask Register is used to enable those events activated in Host Int Register */", "/* to cause an interrupt to the host */", "/* read current state of int2 mask reg */", "/* if caller is disabling a set of interrupts */", "/* zero out that set of interrupts in the interrupt mask copy */", "/* else caller is enabling a set of interrupts */", "/* set to 1 that set of interrupts in the interrupt mask copy */", "/* write out new interrupt mask value */", "/* ensure that pending interrupts from those updated interrupts are cleared */" ]

[ { "param": "hostIntMaskRegMask", "type": "UINT16" }, { "param": "state", "type": "UINT8" } ]

[ "BSD-3-Clause" ]

[ "The", "bit", "mask", "to", "be", "modified", ".", "state", "-", "one", "of", "WF_EXINT_DISABLE", "WF_EXINT_ENABLE", "where", "Disable", "implies", "clearing", "the", "bits", "and", "enable", "sets", "the", "bits", ".", "Initializes", "the", "8", "-", "bit", "Host", "Interrupt", "register", "on", "the", "MRF24W", "with", "the", "specified", "mask", "value", "either", "setting", "or", "clearing", "the", "mask", "register", "as", "determined", "by", "the", "input", "parameter", "state", ".", "The", "process", "requires", "2", "spi", "operations", "which", "are", "performed", "in", "a", "blocking", "fashion", ".", "The", "function", "does", "not", "return", "until", "both", "spi", "operations", "have", "completed", "." ]

[ "static", "void", "HostInterruptRegInit", "(", "UINT8", "hostIntrMaskRegMask", ",", "UINT8", "state", ")", "{", "UINT8", "hostIntMaskValue", ";", "hostIntMaskValue", "=", "Read8BitWFRegister", "(", "WF_HOST_MASK_REG", ")", ";", "if", "(", "state", "==", "WF_INT_DISABLE", ")", "{", "hostIntMaskValue", "=", "(", "hostIntMaskValue", "&", "~", "hostIntrMaskRegMask", ")", ";", "}", "else", "{", "hostIntMaskValue", "=", "(", "hostIntMaskValue", "&", "~", "hostIntrMaskRegMask", ")", "|", "hostIntrMaskRegMask", ";", "}", "Write8BitWFRegister", "(", "WF_HOST_MASK_REG", ",", "hostIntMaskValue", ")", ";", "Write8BitWFRegister", "(", "WF_HOST_INTR_REG", ",", "hostIntrMaskRegMask", ")", ";", "}" ]

[ "FUNCTION", ":", "HostInterruptRegInit", "RETURNS", ":", "N", "/", "A" ]

[ "/* Host Int Register is a status register where each bit indicates a specific event */", "/* has occurred. In addition, writing a 1 to a bit location in this register clears */", "/* the event. */", "/* Host Int Mask Register is used to enable those events activated in Host Int Register */", "/* to cause an interrupt to the host */", "/* read current state of Host Interrupt Mask register */", "/* if caller is disabling a set of interrupts */", "/* zero out that set of interrupts in the interrupt mask copy */", "/* else caller is enabling a set of interrupts */", "/* set to 1 that set of interrupts in the interrupt mask copy */", "/* write out new interrupt mask value */", "/* ensure that pending interrupts from those updated interrupts are cleared */" ]

[ { "param": "hostIntrMaskRegMask", "type": "UINT8" }, { "param": "state", "type": "UINT8" } ]

[ "BSD-3-Clause" ]

[ "N", "/", "A", "This", "function", "must", "be", "called", "once", "each", "time", "an", "external", "interrupt", "is", "received", "from", "the", "WiFi", "device", ".", "The", "WiFi", "Driver", "will", "schedule", "any", "subsequent", "SPI", "communication", "to", "process", "the", "interrupt", ".", "IMPORTANT", "NOTE", ":", "This", "function", "and", "functions", "that", "are", "called", "by", "this", "function", "must", "NOT", "use", "local", "variables", ".", "The", "PIC18", "or", "any", "other", "processor", "that", "uses", "overlay", "memory", "will", "corrupt", "the", "logical", "stack", "within", "overlay", "memory", "if", "the", "interrupt", "uses", "local", "variables", ".", "If", "local", "variables", "are", "used", "within", "an", "interrupt", "routine", "the", "toolchain", "cannot", "properly", "determine", "how", "not", "to", "overwrite", "local", "variables", "in", "non", "-", "interrupt", "releated", "functions", "specifically", "the", "function", "that", "was", "interrupted", "." ]

[ "void", "WFEintHandler", "(", "void", ")", "{", "if", "(", "RawMoveState", ".", "waitingForRawMoveCompleteInterrupt", ")", "{", "g_EintHostIntRegValue", "=", "Read8BitWFRegister", "(", "WF_HOST_INTR_REG", ")", ";", "g_EintHostIntMaskRegValue", "=", "Read8BitWFRegister", "(", "WF_HOST_MASK_REG", ")", ";", "g_EintHostInt", "=", "g_EintHostIntRegValue", "&", "g_EintHostIntMaskRegValue", ";", "if", "(", "g_EintHostInt", "&", "(", "WF_HOST_INT_MASK_RAW_0_INT_0", "|", "WF_HOST_INT_MASK_RAW_1_INT_0", "|", "WF_HOST_INT_MASK_INT2", ")", ")", "{", "RawMoveState", ".", "rawInterrupt", "=", "g_EintHostInt", ";", "RawMoveState", ".", "waitingForRawMoveCompleteInterrupt", "=", "FALSE", ";", "if", "(", "(", "g_EintHostInt", "&", "~", "(", "WF_HOST_INT_MASK_RAW_0_INT_0", "|", "WF_HOST_INT_MASK_RAW_1_INT_0", "|", "WF_HOST_INT_MASK_INT2", ")", ")", "==", "0", ")", "{", "Write8BitWFRegister", "(", "WF_HOST_INTR_REG", ",", "(", "WF_HOST_INT_MASK_RAW_0_INT_0", "|", "WF_HOST_INT_MASK_RAW_1_INT_0", "|", "WF_HOST_INT_MASK_INT2", ")", ")", ";", "Write16BitWFRegister", "(", "WF_HOST_INTR2_REG", ",", "(", "WF_HOST_INT_MASK_RAW_2_INT_0", "|", "WF_HOST_INT_MASK_RAW_3_INT_0", "|", "WF_HOST_INT_MASK_RAW_4_INT_0", "|", "WF_HOST_INT_MASK_RAW_5_INT_0", ")", ")", ";", "WF_EintEnable", "(", ")", ";", "return", ";", "}", "else", "{", "Write16BitWFRegister", "(", "WF_HOST_INTR2_REG", ",", "(", "WF_HOST_INT_MASK_RAW_2_INT_0", "|", "WF_HOST_INT_MASK_RAW_3_INT_0", "|", "WF_HOST_INT_MASK_RAW_4_INT_0", "|", "WF_HOST_INT_MASK_RAW_5_INT_0", ")", ")", ";", "g_HostIntSaved", "|=", "(", "g_EintHostInt", "&", "~", "(", "WF_HOST_INT_MASK_RAW_0_INT_0", "|", "WF_HOST_INT_MASK_RAW_1_INT_0", "|", "WF_HOST_INT_MASK_INT2", ")", ")", ";", "Write8BitWFRegister", "(", "WF_HOST_INTR_REG", ",", "g_EintHostInt", ")", ";", "}", "}", "else", "{", "g_HostIntSaved", "|=", "g_EintHostInt", ";", "Write8BitWFRegister", "(", "WF_HOST_INTR_REG", ",", "g_EintHostInt", ")", ";", "WF_EintEnable", "(", ")", ";", "}", "}", "g_ExIntNeedsServicing", "=", "TRUE", ";", "}" ]

[ "FUNCTION", ":", "WFEintHandler", "RETURNS", ":", "N", "/", "A" ]

[ "/*--------------------------------------------------------*/", "/* if driver is waiting for a RAW Move Complete interrupt */", "/*--------------------------------------------------------*/", "/* read hostInt register and hostIntMask register to determine cause of interrupt */", "// AND the two registers together to determine which active, enabled interrupt has occurred", "/* if a RAW0/RAW1 Move Complete interrupt occurred or a level 2 interrupt occurred, indicating */", "/* that a RAW2-5 Move Complete interrupt occurred */", "/* save the copy of the active interrupts */", "/* if no other interrupts occurred other than a RAW0/RAW1/RAW2/RAW3/RAW4 Raw Move Complete */", "/* clear the RAW interrupts, re-enable interrupts, and exit */", "/* else we got a RAW0/RAW1/RAW2/RAW3/RAW4/RAW5 Raw Move Completet interrupt, but, there is also at */", "/* least one other interrupt present */", "// save the other interrupts and clear them, along with the Raw Move Complete interrupts", "// keep interrupts disabled", "/*--------------------------------------------------------------------------------------------------*/", "/* else we did not get a 'RAW Move Complete' interrupt, but we did get at least one other interrupt */", "/*--------------------------------------------------------------------------------------------------*/", "// Once we're in here, external interrupts have already been disabled so no need to call WF_EintDisable() in here", "/* notify state machine that an interrupt occurred */" ]

[]

[ "BSD-3-Clause" ]

[ "WFHardwareInit", "RETURNS", ":", "error", "code", "None", "Initializes", "CPU", "Host", "hardware", "interfaces", "(", "SPI", "External", "Interrupt", ")", ".", "Also", "resets", "the", "MRF24W", "." ]

[ "void", "WFHardwareInit", "(", "void", ")", "{", "UINT8", "mask8", ";", "UINT16", "mask16", ";", "g_MgmtReadMsgReady", "=", "FALSE", ";", "g_ExIntNeedsServicing", "=", "FALSE", ";", "RawMoveState", ".", "rawInterrupt", "=", "0", ";", "RawMoveState", ".", "waitingForRawMoveCompleteInterrupt", "=", "FALSE", ";", "WF_SpiInit", "(", ")", ";", "WF_SetCE_N", "(", "WF_HIGH", ")", ";", "WF_SetCE_N", "(", "WF_LOW", ")", ";", "WF_SetRST_N", "(", "WF_LOW", ")", ";", "WF_SetRST_N", "(", "WF_HIGH", ")", ";", "ResetPll", "(", ")", ";", "ChipReset", "(", ")", ";", "HostInterrupt2RegInit", "(", "WF_HOST_2_INT_MASK_ALL_INT", ",", "(", "UINT16", ")", "WF_INT_DISABLE", ")", ";", "HostInterruptRegInit", "(", "WF_HOST_INT_MASK_ALL_INT", ",", "WF_INT_DISABLE", ")", ";", "WF_EintInit", "(", ")", ";", "WF_EintEnable", "(", ")", ";", "mask8", "=", "(", "WF_HOST_INT_MASK_FIFO_1_THRESHOLD", "|", "WF_HOST_INT_MASK_FIFO_0_THRESHOLD", "|", "WF_HOST_INT_MASK_RAW_0_INT_0", "|", "WF_HOST_INT_MASK_RAW_1_INT_0", "|", "WF_HOST_INT_MASK_INT2", ")", ";", "HostInterruptRegInit", "(", "mask8", ",", "WF_INT_ENABLE", ")", ";", "mask16", "=", "(", "WF_HOST_INT_MASK_RAW_2_INT_0", "|", "WF_HOST_INT_MASK_RAW_3_INT_0", "|", "WF_HOST_INT_MASK_RAW_4_INT_0", "|", "WF_HOST_INT_MASK_RAW_5_INT_0", "|", "WF_HOST_INT_MASK_MAIL_BOX_0_WRT", ")", ";", "HostInterrupt2RegInit", "(", "mask16", ",", "WF_INT_ENABLE", ")", ";", "WFConfigureLowPowerMode", "(", "WF_LOW_POWER_MODE_OFF", ")", ";", "}" ]

[ "FUNCTION", ":", "WFHardwareInit", "RETURNS", ":", "error", "code" ]

[ "/* not waiting for RAW move complete */", "/* initialize the SPI interface */", "/* Toggle the module into and then out of hibernate */", "/* disable module */", "/* enable module */", "/* Toggle the module into and out of reset */", "// put module into reset", "// take module out of of reset", "/* Silicon work-around -- needed for A1 silicon to initialize PLL values correctly */", "/* Soft reset the MRF24W (using SPI bus to write/read MRF24W registers */", "/* disable the interrupts gated by the 16-bit host int register */", "/* disable the interrupts gated the by main 8-bit host int register */", "/* Initialize the External Interrupt for the MRF24W allowing the MRF24W to interrupt */", "/* the Host from this point forward. */", "/* enable the following MRF24W interrupts in the INT1 8-bit register */", "/* Mgmt Rx Msg interrupt */", "/* Data Rx Msg interrupt */", "/* RAW0 Move Complete (Data Rx) interrupt */", "/* RAW1 Move Complete (Data Tx) interrupt */", "/* Interrupt 2 interrupt */", "/* enable the following MRF24W interrupts in the INT2 16-bit register */", "/* RAW2 Move Complete (Mgmt Rx) interrupt */", "/* RAW3 Move Complete (Mgmt Tx) interrupt */", "/* RAW4 Move Complete (Scratch) interrupt */", "/* RAW5 Move Complete (Scratch) interrupt */", "/* Disable PS-Poll mode */" ]

[]

[ "BSD-3-Clause" ]

[ "When", "bit", "-", "banging", "determines", "which", "SPI", "port", "to", "use", "based", "on", "the", "type", "of", "register", "we", "are", "accessing" ]

[ "static", "UINT8", "GetSpiPortWithBitBang", "(", "UINT8", "regType", ")", "{", "if", "(", "regType", "==", "ANALOG_PORT_3_REG_TYPE", ")", "{", "return", "2", ";", "}", "else", "if", "(", "regType", "==", "ANALOG_PORT_2_REG_TYPE", ")", "{", "return", "3", ";", "}", "else", "if", "(", "regType", "==", "ANALOG_PORT_1_REG_TYPE", ")", "{", "return", "1", ";", "}", "else", "if", "(", "regType", "==", "ANALOG_PORT_0_REG_TYPE", ")", "{", "return", "0", ";", "}", "else", "{", "return", "0xff", ";", "}", "}" ]

[ "When", "bit", "-", "banging", "determines", "which", "SPI", "port", "to", "use", "based", "on", "the", "type", "of", "register", "we", "are", "accessing" ]

[ "// should never happen" ]

[ { "param": "regType", "type": "UINT8" } ]

[ "BSD-3-Clause" ]

[ "Initializes", "the", "TimeMonitor", "functionality", "Configures", "and", "starts", "Timer", "2", "for", "a", "1ms", "interrupt", ".", "None", "None", "None", "This", "function", "is", "called", "only", "one", "during", "lifetime", "of", "the", "application", "." ]

[ "void", "TimeMonitorInit", "(", "void", ")", "{", "int", "i", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "MAX_TIMER_CALLBACKS", ";", "i", "++", ")", "{", "tmTickDownTimeI", "[", "i", "]", "=", "0", ";", "tmCallbackFunctionI", "[", "i", "]", "=", "NULL", ";", "}", "T2CONbits", ".", "T32", "=", "0", ";", "T2CONbits", ".", "TCKPS", "=", "0", ";", "PR2", "=", "GetPeripheralClock", "(", ")", "/", "TIME_MONITOR_TICK_PER_SECOND", ";", "TMR2", "=", "0", ";", "IFS0CLR", "=", "_IFS0_T2IF_MASK", ";", "IEC0SET", "=", "_IEC0_T2IE_MASK", ";", "T2CONbits", ".", "TON", "=", "1", ";", "}" ]

[ "Function", ":", "void", "TimeMonitorInit", "(", "void", ")" ]

[ "// TimeMonitor will use T2Interrupt/Timer 2", "// TRISGbits.TRISG6 = 0; // Test output", "// 16 bit timer", "// from 1:1 (0=1:1 (in use), 3=1:8, 6=1:64, 7=1:256)", "// Default is 1ms is 40,000 ticks at 40MHz (dfeined in HardwareProfile.h)", "// Clear any pending interrupt", "// Enable the interrupt", "// Ship it!" ]

[]

[ "BSD-3-Clause" ]

[ "Allows", "user", "to", "register", "for", "a", "callback", "at", "a", "given", "time", "User", "passes", "in", "the", "desired", "callback", "time", "in", "ms", "and", "the", "function", "to", "call", "when", "that", "time", "expires", ".", "Given", "the", "fact", "that", "the", "timer", "(", "currently", "1ms", ")", "may", "be", "just", "ready", "to", "interrupt", "or", "has", "just", "interrupted", "the", "first", "tick", "after", "registration", "may", "be", "anywhere", "from", "0ms", "to", "1ms", ".", "Thus", "one", "interrupt", "period", "is", "always", "added", "to", "the", "registration", "time", ".", "Thus", "the", "registration", "time", "can", "be", "considered", "as", "the", "minimum", "time", "before", "callback", ".", "Therefore", "a", "registration", "for", "40ms", "will", "truly", "callback", "between", "40ms", "and", "41ms", ".", "None", "None", "None", "None" ]

[ "void", "TimeMonitorRegisterI", "(", "int", "index", ",", "unsigned", "int", "callback_time_ms", ",", "void", "(", "*", "callback_function", ")", "(", "void", ")", ")", "{", "TimeMonitorDisableInterrupt", "(", ")", ";", "tmTickDownTimeI", "[", "index", "]", "=", "callback_time_ms", "+", "tmMillisecondsPerTick", ";", "if", "(", "index", "==", "0", ")", "{", "tmTickDownTimeIndex0", "=", "tmTickDownTimeI", "[", "index", "]", ";", "}", "tmCallbackFunctionI", "[", "index", "]", "=", "callback_function", ";", "TimeMonitorEnableInterrupt", "(", ")", ";", "}" ]

[ "Function", ":", "TimeMonitorRegister" ]

[ "// Steps to registering for a callback", "// 1) Disable interrupt", "// 2) Set callback time - add 1 tick time for interrupt aliasing", "// 3) Set callback function", "// 4) Enable interrupt", "// 1)", "// 2)", "// 3)", "// 4)" ]

[ { "param": "index", "type": "int" }, { "param": "callback_time_ms", "type": "unsigned int" }, { "param": "callback_function", "type": "void" } ]

[ "BSD-3-Clause" ]

[ "Allows", "user", "to", "cancel", "a", "previously", "scheduled", "callback", "Clears", "the", "callback", "time", "and", "function", "There", "may", "be", "a", "small", "window", "prior", "to", "disabling", "the", "interrupt", "that", "the", "callback", "may", "still", "fire", ".", "None", "None", "None", "None" ]

[ "void", "TimeMonitorCancelI", "(", "int", "index", ")", "{", "TimeMonitorDisableInterrupt", "(", ")", ";", "tmTickDownTimeI", "[", "index", "]", "=", "0", ";", "tmCallbackFunctionI", "[", "index", "]", "=", "NULL", ";", "TimeMonitorEnableInterrupt", "(", ")", ";", "}" ]

[ "Function", ":", "TimeMonitorCancel" ]

[ "// Steps to canceling for a callback", "// 1) Disable interrupt", "// 2) Clear callback time", "// 3) Clear callback function pointer", "// 4) Enable interrupt", "// 1)", "// 2)", "// 3)", "// 4)" ]

[ { "param": "index", "type": "int" } ]

[ "BSD-3-Clause" ]

[ "Fills", "the", "resource", "-", "records", "with", "the", "information", "received", "from", "sd", "structure", "-", "instance", "in", "which", "the", "information", "is", "filled", "from", "user", "input", ".", "This", "function", "is", "used", "to", "fill", "the", "resource", "-", "records", "according", "to", "format", "specified", "in", "RFC", "1035", ".", "In", "this", "context", "Service", "-", "Instance", "+", "Service", "-", "Type", "is", "called", "fully", "qualified", "name", ".", "For", "ex", ":", "Dummy", "HTTP", "Web", "-", "Server", ".", "_http", ".", "_tcp", ".", "local", "where", "Dummy", "HTTP", "Web", "-", "Server", "is", "Service", "-", "instance", "name", "and", "_http", ".", "_tcp", ".", "local", "is", "Service", "-", "Type", "Each", "service", "-", "instance", "that", "needs", "to", "be", "advertised", "contains", "three", "resource", "-", "reocrds", ".", "None", "Service", "-", "Discovery", "structure", "instance", "for", "which", "Resource", "records", "to", "be", "filled", ".", "None" ]

[ "void", "mDNSSDFillResRecords", "(", "mDNSProcessCtx_sd", "*", "sd", ")", "{", "size_t", "srv_name_len", ",", "srv_type_len", ",", "qual_len", ";", "mDNSResourceRecord", "*", "rr_list", "=", "&", "(", "gResponderCtx", ".", "rr_list", "[", "QTYPE_PTR_INDEX", "]", ")", ";", "srv_name_len", "=", "strlen", "(", "(", "char", "*", ")", "sd", "->", "srv_name", ")", ";", "srv_type_len", "=", "strlen", "(", "(", "char", "*", ")", "sd", "->", "srv_type", ")", ";", "memset", "(", "&", "(", "gResponderCtx", ".", "rr_list", "[", "QTYPE_PTR_INDEX", "]", ")", ",", "0", ",", "(", "sizeof", "(", "mDNSResourceRecord", ")", ")", ")", ";", "memset", "(", "&", "(", "gResponderCtx", ".", "rr_list", "[", "QTYPE_SRV_INDEX", "]", ")", ",", "0", ",", "(", "sizeof", "(", "mDNSResourceRecord", ")", ")", ")", ";", "memset", "(", "&", "(", "gResponderCtx", ".", "rr_list", "[", "QTYPE_TXT_INDEX", "]", ")", ",", "0", ",", "(", "sizeof", "(", "mDNSResourceRecord", ")", ")", ")", ";", "strncpy", "(", "(", "char", "*", ")", "sd", "->", "sd_qualified_name", ",", "(", "char", "*", ")", "sd", "->", "srv_name", ",", "sizeof", "(", "sd", "->", "sd_qualified_name", ")", ")", ";", "qual_len", "=", "mDNSSDFormatServiceInstance", "(", "sd", "->", "sd_qualified_name", ",", "sizeof", "(", "sd", "->", "sd_qualified_name", ")", ")", ";", "strncpy_m", "(", "(", "char", "*", ")", "sd", "->", "sd_qualified_name", "+", "qual_len", ",", "sizeof", "(", "sd", "->", "sd_qualified_name", ")", "-", "qual_len", ",", "2", ",", "\"", "\"", ",", "sd", "->", "srv_type", ")", ";", "DEBUG_MDNS_MESG", "(", "zeroconf_dbg_msg", ",", "\"", "\\r", "\\n", "\"", ",", "sd", "->", "sd_qualified_name", ")", ";", "DEBUG_MDNS_PRINT", "(", "zeroconf_dbg_msg", ")", ";", "rr_list", "->", "type", ".", "Val", "=", "QTYPE_PTR", ";", "rr_list", "->", "name", "=", "(", "BYTE", "*", ")", "(", "sd", "->", "srv_type", ")", ";", "rr_list", "->", "rdata", "=", "(", "BYTE", "*", ")", "(", "sd", "->", "sd_qualified_name", ")", ";", "strncpy_m", "(", "(", "char", "*", ")", "rr_list", "->", "rdata", "+", "srv_name_len", ",", "sizeof", "(", "sd", "->", "sd_qualified_name", ")", "-", "srv_name_len", ",", "2", ",", "\"", "\"", ",", "sd", "->", "srv_type", ")", ";", "rr_list", "->", "rdlength", ".", "Val", "=", "srv_name_len", "+", "srv_type_len", "+", "3", ";", "rr_list", "->", "ttl", ".", "Val", "=", "RESOURCE_RECORD_TTL_VAL", ";", "rr_list", "->", "pOwnerCtx", "=", "(", "mDNSProcessCtx_common", "*", ")", "sd", ";", "rr_list", "->", "valid", "=", "1", ";", "rr_list", "=", "&", "gResponderCtx", ".", "rr_list", "[", "QTYPE_SRV_INDEX", "]", ";", "rr_list", "->", "name", "=", "(", "BYTE", "*", ")", "(", "sd", "->", "sd_qualified_name", ")", ";", "rr_list", "->", "type", ".", "Val", "=", "QTYPE_SRV", ";", "rr_list", "->", "ttl", ".", "Val", "=", "RESOURCE_RECORD_TTL_VAL", ";", "rr_list", "->", "srv", ".", "priority", ".", "Val", "=", "0", ";", "rr_list", "->", "srv", ".", "weight", ".", "Val", "=", "0", ";", "rr_list", "->", "srv", ".", "port", ".", "Val", "=", "sd", "->", "sd_port", ";", "rr_list", "->", "rdata", "=", "(", "BYTE", "*", ")", "gHostCtx", ".", "szHostName", ";", "rr_list", "->", "rdlength", ".", "Val", "=", "strlen", "(", "(", "char", "*", ")", "rr_list", "->", "rdata", ")", "+", "2", "+", "6", ";", "rr_list", "->", "pOwnerCtx", "=", "(", "mDNSProcessCtx_common", "*", ")", "sd", ";", "rr_list", "->", "valid", "=", "1", ";", "rr_list", "=", "&", "gResponderCtx", ".", "rr_list", "[", "QTYPE_TXT_INDEX", "]", ";", "rr_list", "->", "type", ".", "Val", "=", "QTYPE_TXT", ";", "rr_list", "->", "name", "=", "(", "BYTE", "*", ")", "(", "sd", "->", "sd_qualified_name", ")", ";", "rr_list", "->", "rdata", "=", "(", "BYTE", "*", ")", "(", "sd", "->", "sd_txt_rec", ")", ";", "rr_list", "->", "rdlength", ".", "Val", "=", "gSDCtx", ".", "sd_txt_rec_len", "+", "1", ";", "rr_list", "->", "ttl", ".", "Val", "=", "RESOURCE_RECORD_TTL_VAL", ";", "rr_list", "->", "pOwnerCtx", "=", "(", "mDNSProcessCtx_common", "*", ")", "sd", ";", "rr_list", "->", "valid", "=", "1", ";", "}" ]

[ "Function", ":", "void", "mDNSSDFillResRecords", "(", "mdnsd_struct", "*", "sd", ")" ]

[ "/* Formatting Service-Instance name.\n * And preparing a fully qualified \n * Service-instance name. */", "// SOFTAP_ZEROCONF_SUPPORT", "// Overwritten with zeros inside the gSDCtx and the mDNS will start advertizing on port 0 instead of the normal port", "//strncpy_m((char *)sd->sd_qualified_name + qual_len, sizeof(sd->sd_qualified_name), 2, \".\", sd->srv_type); ", "/* Fill-up PTR Record */", "/* Res Record Name is \n * Service_Instance_name._srv-type._proto.domain */", "/* 3 bytes extra. One for dot added between\n * Serv-Name and Serv-Type. One for length byte.\n * added for first-label in fully qualified name\n * Other one for NULL terminator */", "/* Save back ptr */", "/* Mark as valid */", "/* Move onto next entry */", "/* Fill-up SRV Record */", "//rdlength is calculated/assigned last", "/* Res Record Name is \n * Service_Instance_name._srv-type._proto.domain */", "/* 2 bytes extra. One for Prefix Length for first-label.\n * Other one for NULL terminator */", "// then, add 6-byte extra: for priority, weight, and port", "/* Save back ptr */", "/* Mark as valid */", "/* Move onto next entry */", "/* Fill-up TXT Record with NULL data*/", "/* Res Record data is what defined by the user */", "/* Extra byte for Length-Byte of TXT string */", "/* Save back ptr */", "/* Mark as valid */" ]

[ { "param": "sd", "type": "mDNSProcessCtx_sd" } ]

[ "BSD-3-Clause" ]

[ "DNS", "-", "Service", "Discovery", "API", "for", "end", "-", "user", "to", "update", "the", "service", "advertisement", "which", "was", "previously", "registered", "with", "mDNSServiceRegister", "This", "API", "is", "used", "by", "end", "-", "user", "application", "to", "update", "its", "service", "which", "was", "previously", "registered", ".", "With", "this", "API", "end", "-", "user", "app", "update", "the", "port", "number", "on", "which", "the", "service", "is", "running", ".", "It", "can", "update", "the", "additional", "information", "of", "service", ".", "For", "example", ":", "the", "default", "page", "can", "be", "updated", "to", "new", "page", "and", "corresponding", "page", "name", "can", "be", "input", "to", "this", "API", "to", "update", "all", "peer", "machines", ".", "The", "modified", "service", "will", "be", "announced", "with", "new", "contents", "on", "local", "network", ".", "This", "is", "an", "optional", "API", "and", "should", "be", "invoked", "only", "if", "it", "is", "necessary", ".", "mDNSServiceRegister", "must", "be", "invoked", "before", "this", "call", ".", "port", "-", "Port", "number", "on", "which", "service", "is", "running", "txt_len", "-", "For", "additional", "information", "about", "service", "like", "default", "page", "for", "HTTP", "-", "service", ".", "Length", "of", "such", "additional", "information", "txt_record", "-", "String", "of", "additional", "information", "for", "HTTP", "-", "service", ".", "Returns", "Error", "-", "code", "to", "indicate", "registration", "is", "success", "or", "not", ".", "1", ")", "MDNSD_SUCCESS", "-", "returns", "on", "success", "of", "call", "2", ")", "MDNSD_ERR_INVAL", "-", "When", "the", "input", "parameters", "are", "invalid", "or", "if", "the", "API", "is", "invoked", "in", "invalid", "state" ]

[ "MDNSD_ERR_CODE", "mDNSServiceUpdate", "(", "WORD", "port", ",", "const", "BYTE", "*", "txt_record", ")", "{", "mDNSProcessCtx_sd", "*", "sd", "=", "&", "gSDCtx", ";", "if", "(", "sd", "->", "used", ")", "{", "sd", "->", "service_registered", "=", "0", ";", "sd", "->", "sd_port", "=", "port", ";", "gResponderCtx", ".", "rr_list", "[", "QTYPE_SRV_INDEX", "]", ".", "srv", ".", "port", ".", "Val", "=", "port", ";", "if", "(", "txt_record", "!=", "NULL", ")", "{", "sd", "->", "sd_txt_rec_len", "=", "strncpy_m", "(", "(", "char", "*", ")", "sd", "->", "sd_txt_rec", ",", "sizeof", "(", "sd", "->", "sd_txt_rec", ")", ",", "1", ",", "(", "BYTE", "*", ")", "txt_record", ")", ";", "mDNSSDFillResRecords", "(", "sd", ")", ";", "sd", "->", "common", ".", "state", "=", "MDNS_STATE_NOT_READY", ";", "}", "sd", "->", "service_registered", "=", "1", ";", "return", "MDNSD_SUCCESS", ";", "}", "else", "return", "MDNSD_ERR_INVAL", ";", "}" ]

[ "Function", ":", "MDNSD_ERR_CODE", "mDNSServiceUpdate", "(", "WORD", "port", "WORD", "txt_len", "const", "BYTE", "*", "txt_record", ")" ]

[ "/* Update Port Value in SRV Resource-record */", "/* Update Resource-records for this \n * Service-instance, in MDNS-SD state-\n * -machine */", "/* Notify MDNS Stack about Service-Registration\n * to get a time-slot for its own processing */" ]

[ { "param": "port", "type": "WORD" }, { "param": "txt_record", "type": "BYTE" } ]

[ "BSD-3-Clause" ]

[ "DNS", "-", "Service", "Discovery", "API", "for", "end", "-", "user", "to", "De", "-", "register", "a", "service", "-", "advertisement", "which", "was", "previously", "registered", "with", "mDNSServiceRegister", "API", ".", "This", "API", "is", "used", "by", "end", "-", "user", "application", "to", "de", "-", "register", "its", "service", "-", "advertisement", "on", "local", "network", ".", "When", "this", "gets", "invoked", "by", "end", "-", "user", "DNS", "-", "SD", "stack", "sends", "out", "Good", "-", "Bye", "packets", "to", "update", "all", "peer", "machines", "that", "service", "will", "no", "longer", "be", "present", ".", "All", "peer", "machines", "remove", "the", "corresponding", "entry", "from", "Browser", "list", ".", "This", "is", "the", "last", "API", "that", "needs", "to", "be", "invoked", "by", "end", "-", "user", "application", "to", "free", "-", "up", "the", "DNS", "-", "SD", "stack", "for", "some", "other", "app", ".", "mDNSServiceRegister", "must", "be", "invoked", "before", "this", "call", ".", "None", "Returns", "Error", "-", "code", "to", "indicate", "registration", "is", "success", "or", "not", ".", "1", ")", "MDNSD_SUCCESS", "-", "returns", "on", "success", "of", "call", "2", ")", "MDNSD_ERR_INVAL", "-", "When", "the", "input", "parameters", "are", "invalid", "or", "if", "the", "API", "is", "invoked", "in", "invalid", "state" ]

[ "MDNSD_ERR_CODE", "mDNSServiceDeRegister", "(", ")", "{", "mDNSProcessCtx_sd", "*", "sd", "=", "&", "gSDCtx", ";", "if", "(", "sd", "->", "used", ")", "{", "if", "(", "sd", "->", "sd_service_advertised", "==", "1", ")", "{", "gResponderCtx", ".", "rr_list", "[", "QTYPE_PTR_INDEX", "]", ".", "ttl", ".", "Val", "=", "0", ";", "gResponderCtx", ".", "rr_list", "[", "QTYPE_SRV_INDEX", "]", ".", "ttl", ".", "Val", "=", "0", ";", "gResponderCtx", ".", "rr_list", "[", "QTYPE_SRV_INDEX", "]", ".", "ttl", ".", "Val", "=", "0", ";", "mDNSSendRR", "(", "&", "gResponderCtx", ".", "rr_list", "[", "QTYPE_PTR_INDEX", "]", ",", "0", ",", "0x00", ",", "3", ",", "TRUE", ",", "FALSE", ")", ";", "mDNSSendRR", "(", "&", "gResponderCtx", ".", "rr_list", "[", "QTYPE_SRV_INDEX", "]", ",", "0", ",", "0x80", ",", "3", ",", "FALSE", ",", "FALSE", ")", ";", "mDNSSendRR", "(", "&", "gResponderCtx", ".", "rr_list", "[", "QTYPE_SRV_INDEX", "]", ",", "0", ",", "0x80", ",", "3", ",", "FALSE", ",", "TRUE", ")", ";", "}", "sd", "->", "service_registered", "=", "0", ";", "memset", "(", "sd", ",", "0", ",", "sizeof", "(", "mDNSProcessCtx_sd", ")", ")", ";", "return", "MDNSD_SUCCESS", ";", "}", "else", "return", "MDNSD_ERR_INVAL", ";", "}" ]

[ "Function", ":", "MDNSD_ERR_CODE", "mDNSServiceDeRegister", "()" ]

[ "/* Send GoodBye Packet */", "/* Clear gSDCtx struct */", "/* Invalid Parameter */" ]

[]

[ "BSD-3-Clause" ]

[ "DNS", "-", "Service", "Discovery", "API", "for", "end", "-", "user", "to", "register", "for", "a", "service", "-", "advertisement", ".", "This", "API", "is", "used", "by", "end", "-", "user", "application", "to", "announce", "its", "service", "on", "local", "network", ".", "All", "peer", "machines", "that", "are", "compliant", "with", "Multicast", "-", "DNS", "&", "DNS", "-", "Service", "Discovery", "protocol", "can", "detect", "the", "announcement", "and", "lists", "out", "an", "entry", "in", "Service", "-", "Browser", "list", ".", "End", "-", "User", "selects", "an", "entry", "to", "connect", "to", "this", "service", ".", "So", "ultimately", "this", "is", "an", "aid", "to", "end", "-", "user", "to", "discover", "any", "services", "that", "he", "is", "interested", "in", "on", "a", "local", "network", ".", "This", "is", "the", "first", "API", "that", "needs", "to", "be", "invoked", "by", "end", "-", "user", "application", ".", "Presently", "only", "Multicast", "-", "DNS", "&", "Service", "-", "discovery", "stack", "supports", "only", "single", "service", "-", "advertisement", ".", "Once", "the", "application", "wants", "to", "terminate", "the", "service", "it", "has", "to", "invoke", "mDNSServiceDeRegister", "()", "API", "to", "free", "-", "up", "the", "DNS", "-", "SD", "stack", "for", "some", "other", "application", ".", "None", "port", "-", "Port", "number", "on", "which", "service", "is", "running", "txt_len", "-", "For", "additional", "information", "about", "service", "like", "default", "page", "for", "HTTP", "-", "service", ".", "Length", "of", "such", "additional", "information", "txt_record", "-", "String", "of", "additional", "information", "for", "HTTP", "-", "service", ".", "auto_rename", "-", "A", "flag", "to", "indicate", "DNS", "-", "SD", "stack", "whether", "to", "rename", "the", "service", "automatically", "or", "not", ".", "If", "this", "is", "set", "to", "'", "0", "'", "Callback", "parameter", "will", "be", "used", "to", "indicate", "the", "conflict", "error", "and", "user", "has", "to", "select", "different", "name", "and", "re", "-", "register", "with", "this", "API", ".", "If", "this", "is", "set", "to", "'", "1", "'", "service", "-", "name", "will", "be", "automatically", "renamed", "with", "numerical", "suffix", ".", "callback", "-", "Callback", "function", "which", "is", "user", "-", "application", "defined", ".", "This", "callback", "gets", "invoked", "on", "completion", "of", "service", "advertisement", ".", "If", "an", "service", "name", "-", "conflit", "error", "is", "detected", "and", "auto_rename", "is", "set", "to", "'", "0", "'", "callback", "gets", "invoked", "with", "MDNSD_ERR_CONFLICT", "as", "error", "-", "code", ".", "context", "-", "Opaque", "context", "(", "pointer", "to", "opaque", "data", ")", "which", "needs", "to", "be", "used", "in", "callback", "function", ".", "Returns", "Error", "-", "code", "to", "indicate", "registration", "is", "success", "or", "not", ".", "1", ")", "MDNSD_SUCCESS", "-", "returns", "on", "success", "of", "call", "2", ")", "MDNSD_ERR_BUSY", "-", "When", "already", "some", "other", "service", "is", "being", "advertised", "using", "this", "DNS", "-", "SD", "stack" ]

[ "MDNSD_ERR_CODE", "mDNSServiceRegister", "(", "const", "char", "*", "srv_name", ",", "const", "char", "*", "srv_type", ",", "WORD", "port", ",", "const", "BYTE", "*", "txt_record", ",", "BYTE", "auto_rename", ",", "void", "(", "*", "call_back", ")", "(", "char", "*", "name", ",", "MDNSD_ERR_CODE", "err", ",", "void", "*", "context", ")", ",", "void", "*", "context", ")", "{", "if", "(", "gSDCtx", ".", "used", ")", "{", "WARN_MDNS_PRINT", "(", "\"", "\"", "\"", "\\r", "\\n", "\"", ")", ";", "return", "MDNSD_ERR_BUSY", ";", "}", "if", "(", "(", "srv_name", "==", "NULL", ")", "||", "(", "srv_type", "==", "NULL", ")", "||", "(", "txt_record", "==", "NULL", ")", ")", "{", "return", "MDNSD_ERR_INVAL", ";", "}", "memset", "(", "&", "gSDCtx", ",", "0", ",", "sizeof", "(", "mDNSProcessCtx_sd", ")", ")", ";", "gSDCtx", ".", "used", "=", "1", ";", "gSDCtx", ".", "sd_auto_rename", "=", "auto_rename", ";", "gSDCtx", ".", "sd_port", "=", "port", ";", "gSDCtx", ".", "sd_service_advertised", "=", "0", ";", "strncpy", "(", "(", "char", "*", ")", "gSDCtx", ".", "srv_name", ",", "(", "char", "*", ")", "srv_name", ",", "sizeof", "(", "gSDCtx", ".", "srv_name", ")", ")", ";", "strncpy", "(", "(", "char", "*", ")", "gSDCtx", ".", "srv_type", ",", "(", "char", "*", ")", "srv_type", ",", "sizeof", "(", "gSDCtx", ".", "srv_type", ")", ")", ";", "gSDCtx", ".", "sd_call_back", "=", "call_back", ";", "gSDCtx", ".", "sd_context", "=", "context", ";", "gSDCtx", ".", "sd_txt_rec_len", "=", "strncpy_m", "(", "(", "char", "*", ")", "gSDCtx", ".", "sd_txt_rec", ",", "sizeof", "(", "gSDCtx", ".", "sd_txt_rec", ")", ",", "1", ",", "(", "BYTE", "*", ")", "txt_record", ")", ";", "mDNSSDFillResRecords", "(", "&", "gSDCtx", ")", ";", "gSDCtx", ".", "common", ".", "type", "=", "MDNS_CTX_TYPE_SD", ";", "gSDCtx", ".", "common", ".", "state", "=", "MDNS_STATE_NOT_READY", ";", "gSDCtx", ".", "common", ".", "nInstanceId", "=", "0", ";", "gSDCtx", ".", "service_registered", "=", "1", ";", "return", "MDNSD_SUCCESS", ";", "}" ]

[ "Function", ":", "MDNSD_ERR_CODE", "mDNSServiceRegister", "(", "...", ")" ]

[ "// Invalid Parameter", "/* Clear the State-Machine */", "/* Mark it as used */", "/* Fill up Resource-records for this \n * Service-instance, in MDNS-SD state-\n * -machine */", "/* Notify MDNS Stack about Service-Registration\n * to get a time-slot for its own processing */" ]

[ { "param": "srv_name", "type": "char" }, { "param": "srv_type", "type": "char" }, { "param": "port", "type": "WORD" }, { "param": "txt_record", "type": "BYTE" }, { "param": "auto_rename", "type": "BYTE" }, { "param": "call_back", "type": "void" }, { "param": "name", "type": "char" }, { "param": "err", "type": "MDNSD_ERR_CODE" }, { "param": "context", "type": "void" } ]

[ "BSD-3-Clause" ]

[ "Sends", "out", "Multicast", "-", "DNS", "SD", "packet", "with", "SRV", "Resource", "-", "Record", ".", "This", "function", "is", "used", "to", "send", "out", "DNS", "-", "SD", "SRV", "resource", "-", "record", "Announce", "packet", "for", "announcing", "the", "service", "-", "name", "on", "local", "network", ".", "This", "announcement", "updates", "DNS", "-", "caches", "of", "neighbor", "machines", "on", "the", "local", "network", ".", "None", "Service", "Discovery", "structure", "instance", "None" ]

[ "void", "mDNSAnnounce", "(", "mDNSResourceRecord", "*", "pRR", ")", "{", "if", "(", "FALSE", "==", "mDNSSendRR", "(", "pRR", ",", "0", ",", "0x80", ",", "1", ",", "TRUE", ",", "TRUE", ")", ")", "{", "WARN_MDNS_PRINT", "(", "\"", "\\r", "\\n", "\"", ")", ";", "}", "}" ]

[ "Function", ":", "void", "mDNSSDAnnounce", "(", "mdnsd_struct", "*", "sd", ")" ]

[]

[ { "param": "pRR", "type": "mDNSResourceRecord" } ]

[ "BSD-3-Clause" ]

[ "Initialization", "routine", "for", "Multicast", "-", "DNS", "(", "mDNS", ")", "state", "-", "machine", ".", "This", "is", "initialization", "function", "for", "mDNS", "and", "invoked", "from", "init", "portion", "of", "Main", "-", "function", ".", "This", "initalizes", "the", "Multicast", "-", "DNS", "Responder", "(", "mDNSResponder", ")", "by", "opening", "up", "Multicast", "UDP", "socket", "on", "which", "mDNSResponder", "keeps", "on", "listening", "for", "incoming", "queries", "/", "responses", "from", "neighbor", "machines", ".", "The", "host", "-", "name", "chosen", "is", "initially", "seeded", "from", "DEFUALT_HOST_NAME", "defined", "in", "TCPIPConfig", ".", "h", ".", "None", "None", "None" ]

[ "void", "mDNSFillHostRecord", "(", "void", ")", "{", "BYTE", "i", ";", "gResponderCtx", ".", "rr_list", "[", "QTYPE_A_INDEX", "]", ".", "name", "=", "gHostCtx", ".", "szHostName", ";", "gResponderCtx", ".", "rr_list", "[", "QTYPE_A_INDEX", "]", ".", "type", ".", "Val", "=", "QTYPE_A", ";", "gResponderCtx", ".", "rr_list", "[", "QTYPE_A_INDEX", "]", ".", "ttl", ".", "Val", "=", "RESOURCE_RECORD_TTL_VAL", ";", "gResponderCtx", ".", "rr_list", "[", "QTYPE_A_INDEX", "]", ".", "rdlength", ".", "Val", "=", "4u", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "3", ";", "i", "++", ")", "gResponderCtx", ".", "rr_list", "[", "QTYPE_A_INDEX", "]", ".", "ip", ".", "v", "[", "i", "]", "=", "AppConfig", ".", "MyIPAddr", ".", "v", "[", "i", "]", ";", "gResponderCtx", ".", "rr_list", "[", "QTYPE_A_INDEX", "]", ".", "valid", "=", "1", ";", "gResponderCtx", ".", "rr_list", "[", "QTYPE_A_INDEX", "]", ".", "pOwnerCtx", "=", "(", "mDNSProcessCtx_common", "*", ")", "&", "gHostCtx", ";", "}" ]

[ "Function", ":", "void", "mDNSInitialize", "(", "void", ")" ]

[ "// Fill the type A resource record", "// 4-byte for IP address" ]

[]

[ "BSD-3-Clause" ]

[ "None", "None", "Side", "Effects", ":", "None", "Checks", "for", "incomming", "traffic", "on", "port", "69", ".", "Resets", "the", "PIC", "if", "a", "'", "R", "'", "is", "received", ".", "This", "module", "is", "primarily", "for", "use", "with", "the", "Ethernet", "bootloader", ".", "By", "resetting", "the", "Ethernet", "bootloader", "can", "take", "control", "for", "a", "second", "and", "let", "a", "firmware", "upgrade", "take", "place", "." ]

[ "void", "RebootTask", "(", "void", ")", "{", "static", "UDP_SOCKET", "MySocket", "=", "INVALID_UDP_SOCKET", ";", "struct", "{", "BYTE", "vMACAddress", "[", "6", "]", ";", "DWORD", "dwIPAddress", ";", "WORD", "wChecksum", ";", "}", "BootloaderAddress", ";", "if", "(", "MySocket", "==", "INVALID_UDP_SOCKET", ")", "MySocket", "=", "UDPOpenEx", "(", "0", ",", "UDP_OPEN_SERVER", ",", "REBOOT_PORT", ",", "INVALID_UDP_PORT", ")", ";", "if", "(", "MySocket", "==", "INVALID_UDP_SOCKET", ")", "return", ";", "if", "(", "!", "UDPIsGetReady", "(", "MySocket", ")", ")", "return", ";", "#if", "defined", "(", "REBOOT_SAME_SUBNET_ONLY", ")", "\n", "if", "(", "(", "remoteNode", ".", "IPAddr", ".", "Val", "&", "AppConfig", ".", "MyMask", ".", "Val", ")", "!=", "(", "AppConfig", ".", "MyIPAddr", ".", "Val", "&", "AppConfig", ".", "MyMask", ".", "Val", ")", ")", "{", "UDPDiscard", "(", ")", ";", "return", ";", "}", "#endif", "memcpy", "(", "(", "void", "*", ")", "&", "BootloaderAddress", ".", "vMACAddress", "[", "0", "]", ",", "(", "void", "*", ")", "&", "AppConfig", ".", "MyMACAddr", ".", "v", "[", "0", "]", ",", "sizeof", "(", "AppConfig", ".", "MyMACAddr", ")", ")", ";", "BootloaderAddress", ".", "dwIPAddress", "=", "AppConfig", ".", "MyIPAddr", ".", "Val", ";", "BootloaderAddress", ".", "wChecksum", "=", "CalcIPChecksum", "(", "(", "BYTE", "*", ")", "&", "BootloaderAddress", ",", "sizeof", "(", "BootloaderAddress", ")", "-", "sizeof", "(", "BootloaderAddress", ".", "wChecksum", ")", ")", ";", "#if", "defined", "(", "USE_LCD", ")", "\n", "strcpypgm2ram", "(", "(", "char", "*", ")", "LCDText", ",", "\"", "\"", ")", ";", "LCDUpdate", "(", ")", ";", "#endif", "RCONbits", ".", "POR", "=", "0", ";", "#if", "defined", "(", "__18CXX", ")", "\n", "{", "WORD_VAL", "wvPROD", ";", "wvPROD", ".", "Val", "=", "(", "(", "WORD", ")", "&", "BootloaderAddress", ")", ";", "PRODH", "=", "wvPROD", ".", "v", "[", "1", "]", ";", "PRODL", "=", "wvPROD", ".", "v", "[", "0", "]", ";", "}", "#endif", "Reset", "(", ")", ";", "}" ]

[ "Function", ":", "void", "RebootTask", "(", "void", ")", "PreCondition", ":", "Stack", "is", "initialized", "()" ]

[ "//\t\tMySocket = UDPOpen(REBOOT_PORT, NULL, INVALID_UDP_PORT);", "// Do nothing if no data is waiting", "// Respond only to name requests sent to us from nodes on the same subnet", "// Get our MAC address, IP address, and compute a checksum of them ", "// To enter the bootloader, we need to clear the /POR bit in RCON.", "// Otherwise, the bootloader will immediately hand off execution ", "// to us." ]

[]

[ "BSD-3-Clause" ]

[ "void", "ARCFOURInitialize", "(", "ARCFOUR_CTX", "*", "ctx", "BYTE", "*", "key", "WORD", "len", ")", "Initializes", "an", "ARCFOUR", "encryption", "stream", ".", "This", "function", "initializes", "an", "ARCFOUR", "encryption", "stream", ".", "Call", "this", "function", "to", "set", "up", "the", "initial", "state", "of", "the", "encryption", "context", "and", "the", "S", "-", "box", ".", "The", "stream", "will", "be", "initialized", "to", "its", "zero", "state", "with", "the", "supplied", "key", ".", "This", "function", "can", "be", "used", "to", "initialize", "for", "encryption", "and", "decryption", ".", "None", "A", "pointer", "to", "the", "allocated", "encryption", "context", "structure", "key", "-", "A", "pointer", "to", "the", "key", "to", "be", "used", "len", "-", "The", "length", "of", "the", "data", "in", "key", "None", "For", "security", "the", "key", "should", "be", "destroyed", "after", "this", "call", "." ]

[ "void", "ARCFOURInitialize", "(", "ARCFOUR_CTX", "*", "ctx", ",", "BYTE", "*", "key", ",", "WORD", "len", ")", "{", "BYTE", "temp", ",", "i", ",", "j", ",", "*", "Sbox", ";", "i", "=", "0", ";", "j", "=", "0", ";", "Sbox", "=", "ctx", "->", "Sbox", ";", "do", "{", "Sbox", "[", "i", "]", "=", "i", ";", "i", "++", ";", "}", "while", "(", "i", "!=", "0u", ")", ";", "do", "{", "j", "=", "j", "+", "Sbox", "[", "i", "]", "+", "key", "[", "i", "%", "len", "]", ";", "temp", "=", "Sbox", "[", "i", "]", ";", "Sbox", "[", "i", "]", "=", "Sbox", "[", "j", "]", ";", "Sbox", "[", "j", "]", "=", "temp", ";", "i", "++", ";", "}", "while", "(", "i", "!=", "0u", ")", ";", "ctx", "->", "i", "=", "0", ";", "ctx", "->", "j", "=", "0", ";", "}" ]

[ "Function", ":", "void", "ARCFOURInitialize", "(", "ARCFOUR_CTX", "*", "ctx", "BYTE", "*", "key", "WORD", "len", ")" ]

[ "// Initialize the context indicies", "// Initialize each S-box element with its index", "// Fill in the S-box", "// Reset the context indicies" ]

[ { "param": "ctx", "type": "ARCFOUR_CTX" }, { "param": "key", "type": "BYTE" }, { "param": "len", "type": "WORD" } ]

[ "BSD-3-Clause" ]

[ "void", "ARCFOURCrypt", "(", "ARCFOUR_CTX", "*", "ctx", "BYTE", "*", "data", "WORD", "len", ")", "Processes", "an", "array", "of", "data", "with", "the", "ARCFOUR", "algorithm", ".", "This", "function", "uses", "the", "current", "ARCFOUR", "context", "to", "either", "encrypt", "or", "decrypt", "data", "in", "place", ".", "The", "algorithm", "is", "the", "same", "for", "both", "processes", "so", "this", "function", "can", "perform", "either", "procedure", ".", "The", "encryption", "context", "ctx", "has", "been", "initialized", "with", "ARCFOURInitialize", ".", "A", "pointer", "to", "the", "initialized", "encryption", "context", "structure", "data", "-", "The", "data", "to", "be", "encrypted", "or", "decrypted", "(", "in", "place", ")", "len", "-", "The", "length", "of", "data", "None" ]

[ "void", "ARCFOURCrypt", "(", "ARCFOUR_CTX", "*", "ctx", ",", "BYTE", "*", "data", ",", "WORD", "len", ")", "{", "BYTE", "temp", ",", "temp2", ",", "i", ",", "j", ",", "*", "Sbox", ";", "i", "=", "ctx", "->", "i", ";", "j", "=", "ctx", "->", "j", ";", "Sbox", "=", "ctx", "->", "Sbox", ";", "while", "(", "len", "--", ")", "{", "i", "++", ";", "temp", "=", "Sbox", "[", "i", "]", ";", "j", "+=", "temp", ";", "temp2", "=", "Sbox", "[", "j", "]", ";", "Sbox", "[", "i", "]", "=", "temp2", ";", "Sbox", "[", "j", "]", "=", "temp", ";", "temp", "+=", "temp2", ";", "temp2", "=", "Sbox", "[", "temp", "]", ";", "*", "data", "++", "^=", "temp2", ";", "}", "ctx", "->", "i", "=", "i", ";", "ctx", "->", "j", "=", "j", ";", "}" ]

[ "Function", ":", "void", "ARCFOURCrypt", "(", "ARCFOUR_CTX", "*", "ctx", "BYTE", "*", "data", "WORD", "len", ")" ]

[ "// Buffer context variables in local RAM for faster access", "// Loop over each byte. Extract its key and XOR", "// Save the new context" ]

[ { "param": "ctx", "type": "ARCFOUR_CTX" }, { "param": "data", "type": "BYTE" }, { "param": "len", "type": "WORD" } ]

[ "BSD-3-Clause" ]

[ "WFProcessMgmtIndicateMsg", "RETURNS", ":", "error", "code", "None", "Processes", "a", "management", "indicate", "message" ]

[ "void", "WFProcessMgmtIndicateMsg", "(", ")", "{", "tMgmtIndicateHdr", "hdr", ";", "UINT8", "buf", "[", "6", "]", ";", "UINT8", "event", "=", "0xff", ";", "UINT16", "eventInfo", ";", "#if", "defined", "(", "MRF24WG", ")", "\n", "tMgmtIndicatePassphraseReady", "passphraseReady", ";", "tMgmtIndicateSoftAPEvent", "softAPEvent", ";", "#endif", "UINT8", "*", "extra", "=", "NULL", ";", "RawRead", "(", "RAW_MGMT_RX_ID", ",", "0", ",", "sizeof", "(", "tMgmtIndicateHdr", ")", ",", "(", "UINT8", "*", ")", "&", "hdr", ")", ";", "switch", "(", "hdr", ".", "subType", ")", "{", "case", "WF_EVENT_CONNECTION_ATTEMPT_STATUS_SUBTYPE", ":", "#if", "defined", "(", "MRF24WG", ")", "\n", "RawRead", "(", "RAW_MGMT_RX_ID", ",", "sizeof", "(", "tMgmtIndicateHdr", ")", ",", "2", ",", "buf", ")", ";", "if", "(", "buf", "[", "0", "]", "==", "CONNECTION_ATTEMPT_SUCCESSFUL", ")", "{", "event", "=", "WF_EVENT_CONNECTION_SUCCESSFUL", ";", "eventInfo", "=", "WF_NO_ADDITIONAL_INFO", ";", "SignalWiFiConnectionChanged", "(", "TRUE", ")", ";", "#if", "defined", "(", "STACK_USE_DHCP_CLIENT", ")", "\n", "#if", "!", "defined", "(", "CONFIG_WPA_ENTERPRISE", ")", "\n", "RenewDhcp", "(", ")", ";", "#endif", "#endif", "SetLogicalConnectionState", "(", "TRUE", ")", ";", "#if", "defined", "(", "CONFIG_WPA_ENTERPRISE", ")", "\n", "g_EapConnEvent", "=", "EAP_EVT_SUCCESS", ";", "#endif", "}", "else", "{", "event", "=", "WF_EVENT_CONNECTION_FAILED", ";", "eventInfo", "=", "(", "UINT16", ")", "(", "buf", "[", "0", "]", "<<", "8", "|", "buf", "[", "1", "]", ")", ";", "SetLogicalConnectionState", "(", "FALSE", ")", ";", "#if", "defined", "(", "CONFIG_WPA_ENTERPRISE", ")", "\n", "g_EapConnEvent", "=", "EAP_EVT_FAILURE", ";", "#endif", "}", "#else", "RawRead", "(", "RAW_MGMT_RX_ID", ",", "sizeof", "(", "tMgmtIndicateHdr", ")", ",", "1", ",", "buf", ")", ";", "if", "(", "buf", "[", "0", "]", "==", "CONNECTION_ATTEMPT_SUCCESSFUL", ")", "{", "event", "=", "WF_EVENT_CONNECTION_SUCCESSFUL", ";", "eventInfo", "=", "WF_NO_ADDITIONAL_INFO", ";", "SignalWiFiConnectionChanged", "(", "TRUE", ")", ";", "#if", "defined", "(", "STACK_USE_DHCP_CLIENT", ")", "\n", "RenewDhcp", "(", ")", ";", "#endif", "SetLogicalConnectionState", "(", "TRUE", ")", ";", "}", "else", "{", "event", "=", "WF_EVENT_CONNECTION_FAILED", ";", "eventInfo", "=", "(", "UINT16", ")", "buf", "[", "0", "]", ";", "SetLogicalConnectionState", "(", "FALSE", ")", ";", "}", "#endif", "break", ";", "case", "WF_EVENT_CONNECTION_LOST_SUBTYPE", ":", "RawRead", "(", "RAW_MGMT_RX_ID", ",", "sizeof", "(", "tMgmtIndicateHdr", ")", ",", "2", ",", "buf", ")", ";", "if", "(", "buf", "[", "0", "]", "==", "CONNECTION_TEMPORARILY_LOST", ")", "{", "event", "=", "WF_EVENT_CONNECTION_TEMPORARILY_LOST", ";", "eventInfo", "=", "(", "UINT16", ")", "buf", "[", "1", "]", ";", "SignalWiFiConnectionChanged", "(", "FALSE", ")", ";", "}", "else", "if", "(", "buf", "[", "0", "]", "==", "CONNECTION_PERMANENTLY_LOST", ")", "{", "event", "=", "WF_EVENT_CONNECTION_PERMANENTLY_LOST", ";", "eventInfo", "=", "(", "UINT16", ")", "buf", "[", "1", "]", ";", "SetLogicalConnectionState", "(", "FALSE", ")", ";", "SignalWiFiConnectionChanged", "(", "FALSE", ")", ";", "#if", "defined", "(", "CONFIG_WPA_ENTERPRISE", ")", "\n", "g_EapConnEvent", "=", "EAP_EVT_FAILURE", ";", "#endif", "}", "else", "if", "(", "buf", "[", "0", "]", "==", "CONNECTION_REESTABLISHED", ")", "{", "event", "=", "WF_EVENT_CONNECTION_REESTABLISHED", ";", "eventInfo", "=", "(", "UINT16", ")", "buf", "[", "1", "]", ";", "#if", "defined", "(", "STACK_USE_DHCP_CLIENT", ")", "\n", "RenewDhcp", "(", ")", ";", "#endif", "SignalWiFiConnectionChanged", "(", "TRUE", ")", ";", "SetLogicalConnectionState", "(", "TRUE", ")", ";", "}", "else", "{", "WF_ASSERT", "(", "FALSE", ")", ";", "}", "break", ";", "case", "WF_EVENT_SCAN_RESULTS_READY_SUBTYPE", ":", "RawRead", "(", "RAW_MGMT_RX_ID", ",", "sizeof", "(", "tMgmtIndicateHdr", ")", ",", "1", ",", "buf", ")", ";", "event", "=", "WF_EVENT_SCAN_RESULTS_READY", ";", "eventInfo", "=", "(", "UINT16", ")", "buf", "[", "0", "]", ";", "break", ";", "case", "WF_EVENT_SCAN_IE_RESULTS_READY_SUBTYPE", ":", "event", "=", "WF_EVENT_IE_RESULTS_READY", ";", "RawRead", "(", "RAW_MGMT_RX_ID", ",", "sizeof", "(", "tMgmtIndicateHdr", ")", ",", "2", ",", "(", "UINT8", "*", ")", "&", "eventInfo", ")", ";", "eventInfo", "=", "WFSTOHS", "(", "eventInfo", ")", ";", "break", ";", "#if", "defined", "(", "MRF24WG", ")", "\n", "case", "WF_EVENT_KEY_CALCULATION_REQUEST_SUBTYPE", ":", "event", "=", "WF_EVENT_KEY_CALCULATION_REQUEST", ";", "RawRead", "(", "RAW_MGMT_RX_ID", ",", "sizeof", "(", "tMgmtIndicateHdr", ")", ",", "sizeof", "(", "tMgmtIndicatePassphraseReady", ")", ",", "(", "UINT8", "*", ")", "&", "passphraseReady", ")", ";", "extra", "=", "(", "UINT8", "*", ")", "&", "passphraseReady", ";", "break", ";", "case", "WF_EVENT_SOFT_AP_EVENT_SUBTYPE", ":", "event", "=", "WF_EVENT_SOFT_AP_EVENT", ";", "RawRead", "(", "RAW_MGMT_RX_ID", ",", "sizeof", "(", "tMgmtIndicateHdr", ")", ",", "sizeof", "(", "tMgmtIndicateSoftAPEvent", ")", ",", "(", "UINT8", "*", ")", "&", "softAPEvent", ")", ";", "extra", "=", "(", "UINT8", "*", ")", "&", "softAPEvent", ";", "break", ";", "#endif", "default", ":", "WF_ASSERT", "(", "FALSE", ")", ";", "break", ";", "}", "DeallocateMgmtRxBuffer", "(", ")", ";", "#if", "defined", "(", "HOST_CM_TEST", ")", "\n", "g_event", "=", "event", ";", "#endif", "if", "(", "isNotifyApp", "(", "event", ")", ")", "{", "WF_ProcessEvent", "(", "event", ",", "eventInfo", ",", "extra", ")", ";", "}", "}" ]

[ "FUNCTION", ":", "WFProcessMgmtIndicateMsg", "RETURNS", ":", "error", "code" ]

[ "/* read 2-byte header of management message */", "/* Determine which event occurred and handle it */", "/*-----------------------------------------------------------------*/", "/*-----------------------------------------------------------------*/", "/* There is one data byte with this message */", "/* read first 2 bytes after header */", "/* if connection attempt successful */", "/* else connection attempt failed */", "/* contains connection failure code */", "/* !defined(MRF24WG) */", "/* There is one data byte with this message */", "/* read first byte after header */", "/* if connection attempt successful */", "/* else connection attempt failed */", "/* contains connection failure code */", "/* defined(MRF24WG) */", "/*-----------------------------------------------------------------*/", "/*-----------------------------------------------------------------*/", "/* read index 2 and 3 from message and store in buf[0] and buf[1]\n buf[0] -- 1: Connection temporarily lost 2: Connection permanently lost 3: Connection Reestablished \n buf[1] -- 0: Beacon Timeout 1: Deauth from AP */", "/* lost due to beacon timeout or deauth */", "/* lost due to beacon timeout or deauth */", "/* originally lost due to beacon timeout or deauth */", "/* invalid parameter in message */", "/*-----------------------------------------------------------------*/", "/*-----------------------------------------------------------------*/", "/* read index 2 of mgmt indicate to get the number of scan results */", "/* number of scan results */", "/*-----------------------------------------------------------------*/", "/*-----------------------------------------------------------------*/", "/* read indexes 2 and 3 containing the 16-bit value of IE bytes */", "/* fix endianess of 16-bit value */", "/* Valid only with 3108 or the later module FW version */", "/*-----------------------------------------------------------------*/", "/*-----------------------------------------------------------------*/", "/* free mgmt buffer */", "/* if the application wants to be notified of the event */" ]

[]

[ "BSD-3-Clause" ]

[ "Retrieves", "the", "packet", "length", "and", "actual", "pdu", "length", ".", "Checks", "current", "packet", "and", "returns", "total", "length", "value", "as", "well", "as", "actual", "length", "bytes", ".", "We", "do", "not", "support", "any", "length", "byte", "count", "of", "more", "than", "2", "i", ".", "e", ".", "total", "length", "value", "must", "not", "be", "more", "than", "16", "-", "bit", ".", "None", "Pointer", "to", "memory", "where", "actual", "length", "is", "stored", ".", "Return", "Values", ":", "lengthBytes", "-", "Total", "length", "bytes", "are", "0x80", "itself", "plus", "tempData", ".", "None", "." ]

[ "BYTE", "IsValidLength", "(", "WORD", "*", "len", ")", "{", "BYTE", "tempData", ";", "WORD_VAL", "tempLen", ";", "BYTE", "lengthBytes", ";", "tempLen", ".", "Val", "=", "0", ";", "lengthBytes", "=", "0", ";", "tempData", "=", "_SNMPGet", "(", ")", ";", "tempLen", ".", "v", "[", "0", "]", "=", "tempData", ";", "if", "(", "tempData", "&", "0x80", ")", "{", "tempData", "&=", "0x7F", ";", "if", "(", "tempData", ">", "2u", ")", "return", "FALSE", ";", "lengthBytes", "=", "tempData", "+", "1", ";", "while", "(", "tempData", "--", ")", "tempLen", ".", "v", "[", "tempData", "]", "=", "_SNMPGet", "(", ")", ";", "}", "else", "lengthBytes", "=", "1", ";", "*", "len", "=", "tempLen", ".", "Val", ";", "return", "lengthBytes", ";", "}" ]

[ "Function", ":", "BYTE", "IsValidLength", "(", "WORD", "*", "len", ")" ]

[ "// Initialize length value.", "// We do not support any length byte count of more than 2", "// i.e. total length value must not be more than 16-bit.", "// Total length bytes are 0x80 itself plus tempData.", "// Get upto 2 bytes of length value." ]

[ { "param": "len", "type": "WORD" } ]

[ "BSD-3-Clause" ]

[ "static", "BOOL", "IsValidCommunity", "(", "char", "*", "community", "BYTE", "*", "len", ")", "Verifies", "for", "the", "community", "string", "datatype", "and", "the", "max", "community", "name", "and", "length", "this", "agent", "can", "process", ".", "This", "routine", "populates", "and", "validates", "the", "community", "datatype", "community", "name", "and", "length", "from", "the", "received", "snmp", "request", "pdu", ".", "Community", "name", "is", "used", "for", "accessing", "public", "and", "private", "memebrs", "of", "the", "mib", ".", "Pointer", "to", "memory", "where", "community", "string", "will", "be", "stored", ".", "len", "-", "Pointer", "to", "memory", "where", "comunity", "length", "gets", "stored", ".", "Return", "Values", ":", "TRUE", "-", "If", "valid", "community", "received", ".", "FALSE", "-", "If", "community", "is", "not", "valid", ".", "None", "." ]

[ "static", "BOOL", "IsValidCommunity", "(", "char", "*", "community", ",", "BYTE", "*", "len", ")", "{", "BYTE", "tempData", ";", "BYTE", "tempLen", ";", "tempData", "=", "_SNMPGet", "(", ")", ";", "if", "(", "!", "IS_OCTET_STRING", "(", "tempData", ")", ")", "return", "FALSE", ";", "tempLen", "=", "_SNMPGet", "(", ")", ";", "*", "len", "=", "tempLen", ";", "if", "(", "tempLen", ">", "SNMP_COMMUNITY_MAX_LEN", ")", "return", "FALSE", ";", "while", "(", "tempLen", "--", ")", "{", "tempData", "=", "_SNMPGet", "(", ")", ";", "*", "community", "++", "=", "tempData", ";", "}", "*", "community", "=", "'", "\\0", "'", ";", "return", "TRUE", ";", "}" ]

[ "Function", ":", "static", "BOOL", "IsValidCommunity", "(", "char", "*", "community", "BYTE", "*", "len", ")" ]

[]

[ { "param": "community", "type": "char" }, { "param": "len", "type": "BYTE" } ]

[ "BSD-3-Clause" ]

[ "Verifies", "variable", "datatype", "as", "INT", "and", "retrieves", "its", "value", ".", "This", "routine", "populates", "and", "validates", "the", "received", "variable", "for", "the", "data", "type", "as", "\"", "ASN_INT", "\"", "and", "the", "data", "length", "for", "max", "4", "bytes", ".", "Pointer", "to", "memory", "where", "int", "var", "value", "will", "be", "stored", ".", "TRUE", "-", "If", "valid", "integer", "type", "and", "value", "is", "received", ".", "FALSE", "-", "Other", "than", "integer", "data", "type", "and", "value", "received", ".", "None", "." ]

[ "BOOL", "IsValidInt", "(", "DWORD", "*", "val", ")", "{", "DWORD_VAL", "tempData", ";", "DWORD_VAL", "tempLen", ";", "tempLen", ".", "Val", "=", "0", ";", "if", "(", "!", "IS_ASN_INT", "(", "_SNMPGet", "(", ")", ")", ")", "return", "FALSE", ";", "if", "(", "!", "IsValidLength", "(", "&", "tempLen", ".", "w", "[", "0", "]", ")", ")", "return", "FALSE", ";", "if", "(", "tempLen", ".", "Val", ">", "4u", ")", "return", "FALSE", ";", "tempData", ".", "Val", "=", "0", ";", "while", "(", "tempLen", ".", "v", "[", "0", "]", "--", ")", "tempData", ".", "v", "[", "tempLen", ".", "v", "[", "0", "]", "]", "=", "_SNMPGet", "(", ")", ";", "*", "val", "=", "tempData", ".", "Val", ";", "return", "TRUE", ";", "}" ]

[ "Function", ":", "BOOL", "IsValidInt", "(", "DWORD", "*", "val", ")" ]

[ "// Get variable type", "// Integer length of more than 32-bit is not supported." ]

[ { "param": "val", "type": "DWORD" } ]

[ "BSD-3-Clause" ]

[ "Verifies", "for", "the", "snmp", "request", "type", ".", "This", "routine", "populates", "and", "verifies", "for", "the", "received", "snmp", "request", "pdu", "type", ".", "Pointer", "to", "memory", "where", "received", "snmp", "request", "type", "is", "stored", ".", "Return", "Values", ":", "TRUE", "-", "If", "this", "snmp", "request", "can", "be", "processed", "by", "the", "agent", ".", "FALSE", "-", "If", "the", "request", "can", "not", "be", "processed", ".", "None", "." ]

[ "BOOL", "IsValidPDU", "(", "SNMP_ACTION", "*", "pdu", ")", "{", "BYTE", "tempData", ";", "WORD", "tempLen", ";", "tempData", "=", "_SNMPGet", "(", ")", ";", "if", "(", "!", "IS_AGENT_PDU", "(", "tempData", ")", ")", "return", "FALSE", ";", "*", "pdu", "=", "tempData", ";", "return", "IsValidLength", "(", "&", "tempLen", ")", ";", "}" ]

[ "Function", ":", "BOOL", "IsValidPDU", "(", "SNMP_ACTION", "*", "pdu", ")" ]

[ "// Fetch pdu data type", "/* Now fetch pdu length. We don't need to remember pdu length.\n\t Do this to proceed to next pdu element of interest*/" ]

[ { "param": "pdu", "type": "SNMP_ACTION" } ]

[ "BSD-3-Clause" ]

[ "Verifies", "the", "value", "type", "as", "ASN_NULL", ".", "For", "Get", "Get_Next", "Get_Bulk", "snmp", "reuest", "the", "var", "bind", "the", "value", "data", "type", "should", "be", "ASN_NULL", "and", "value", "field", "must", "be", "NULL", "and", ".", "This", "routine", "verifies", "the", "data", "type", "and", "value", "fields", "in", "the", "received", "requests", ".", "The", "SET", "request", "the", "value", "data", "type", "can", "not", "be", "ASN_NULL", "otherwise", "the", "snmp", "request", "is", "not", "processed", ".", "None", "None", "Returns", "Values", "TRUE", "-", "If", "value", "type", "is", "ASN_NULL", "and", "value", "is", "NULL", ".", "FALSE", "-", "If", "data", "type", "and", "value", "is", "other", "than", "ASN_NULL", "and", "NULL", "resp", ".", "None", "." ]

[ "static", "BOOL", "IsASNNull", "(", "void", ")", "{", "BYTE", "a", ";", "a", "=", "_SNMPGet", "(", ")", ";", "if", "(", "!", "IS_ASN_NULL", "(", "a", ")", ")", "return", "FALSE", ";", "return", "(", "_SNMPGet", "(", ")", "==", "0u", ")", ";", "}" ]

[ "Function", ":", "BOOL", "IsASNNull", "(", "void", ")" ]

[ "// Fetch and verify that this is NULL data type.", "/*if ( !IS_ASN_NULL(_SNMPGet()) )\n\t\treturn FALSE;*/", "// Fetch and verify that length value is zero." ]

[]

[ "BSD-3-Clause" ]

[ "BOOL", "IsValidOID", "(", "BYTE", "*", "oid", "BYTE", "*", "len", ")", "Populates", "OID", "type", "length", "and", "oid", "string", "from", "the", "received", "pdu", ".", "In", "this", "routine", "OID", "data", "type", "\"", "ASN_OID", "\"", "is", "verified", "in", "the", "received", "pdu", ".", "If", "the", "data", "type", "is", "matched", "then", "only", "var", "bind", "is", "processed", ".", "OID", "length", "and", "OID", "is", "populated", ".", "The", "max", "OID", "length", "can", "be", "15", ".", "Pointer", "to", "memory", "to", "store", "the", "received", "OID", "string", "len", "-", "Pointer", "to", "memory", "to", "store", "OID", "length", "Return", "Values", ":", "TRUE", "-", "If", "value", "type", "is", "ASN_OID", "and", "oid", "length", "not", "more", "than", "15", ".", "FALSE", "-", "Otherwise", ".", "None", "." ]

[ "static", "BOOL", "IsValidOID", "(", "BYTE", "*", "oid", ",", "BYTE", "*", "len", ")", "{", "DWORD_VAL", "tempLen", ";", "if", "(", "!", "IS_OID", "(", "_SNMPGet", "(", ")", ")", ")", "return", "FALSE", ";", "if", "(", "!", "IsValidLength", "(", "&", "tempLen", ".", "w", "[", "0", "]", ")", ")", "return", "FALSE", ";", "if", "(", "tempLen", ".", "w", "[", "0", "]", ">", "(", "WORD", ")", "SNMP_MAX_OID_LEN_MEM_USE", ")", "return", "FALSE", ";", "*", "len", "=", "tempLen", ".", "v", "[", "0", "]", ";", "while", "(", "tempLen", ".", "v", "[", "0", "]", "--", ")", "{", "*", "oid", "++", "=", "_SNMPGet", "(", ")", ";", "}", "*", "oid", "=", "0xff", ";", "return", "TRUE", ";", "}" ]

[ "Function", ":", "BOOL", "IsValidOID", "(", "BYTE", "*", "oid", "BYTE", "*", "len", ")" ]

[ "// Fetch and verify that this is OID.", "// Retrieve OID length", "// Make sure that OID length is within our capability." ]

[ { "param": "oid", "type": "BYTE" }, { "param": "len", "type": "BYTE" } ]

[ "BSD-3-Clause" ]

[ "Decode", "variable", "length", "structure", ".", "This", "routine", "is", "used", "to", "verify", "whether", "the", "received", "varbind", "is", "of", "type", "STRUCTURE", "and", "to", "find", "out", "the", "variable", "binding", "structure", "length", ".", "Pointer", "to", "memory", "to", "store", "OID", "structure", "length", ".", "Return", "Values", ":", "headrbytes", "-", "Variable", "binding", "length", ".", "FALSE", "-", "If", "variable", "data", "structure", "is", "not", "type", "STRUCTURE", ".", "None", "." ]

[ "BYTE", "IsValidStructure", "(", "WORD", "*", "dataLen", ")", "{", "DWORD_VAL", "tempLen", ";", "BYTE", "headerBytes", ";", "if", "(", "!", "IS_STRUCTURE", "(", "_SNMPGet", "(", ")", ")", ")", "return", "FALSE", ";", "headerBytes", "=", "IsValidLength", "(", "&", "tempLen", ".", "w", "[", "0", "]", ")", ";", "if", "(", "!", "headerBytes", ")", "return", "FALSE", ";", "headerBytes", "++", ";", "*", "dataLen", "=", "tempLen", ".", "w", "[", "0", "]", ";", "return", "headerBytes", ";", "}" ]

[ "Function", ":", "BYTE", "IsValidStructure", "(", "WORD", "*", "dataLen", ")" ]

[ "// Retrieve structure length", "// Since we are using UDP as our transport and UDP are not fragmented,", "// this structure length cannot be more than 1500 bytes.", "// As a result, we will only use lower WORD of length value." ]

[ { "param": "dataLen", "type": "WORD" } ]

[ "BSD-3-Clause" ]

[ "Prepare", "for", "full", "duplex", "transfer", ".", "As", "we", "process", "SNMP", "variables", "we", "will", "prepare", "response", "on", "-", "the", "-", "fly", "creating", "full", "duplex", "transfer", ".", "Current", "MAC", "layer", "does", "not", "support", "full", "duplex", "transfer", "so", "SNMP", "needs", "to", "manage", "its", "own", "full", "duplex", "connection", ".", "Prepare", "for", "full", "duplex", "transfer", ".", "Set", "the", "Tx", "and", "Rx", "offset", "to", "start", "of", "the", "buffer", ".", "An", "active", "udp", "socket", "for", "which", "tx", "and", "rx", "offset", "to", "be", "set", ".", "None", ".", "This", "routine", "should", "be", "called", "for", "every", "new", "snmp", "packet", "received", "." ]

[ "void", "_SNMPDuplexInit", "(", "UDP_SOCKET", "socket", ")", "{", "while", "(", "!", "UDPIsPutReady", "(", "socket", ")", ")", ";", "SNMPRxOffset", "=", "0", ";", "SNMPTxOffset", "=", "0", ";", "}" ]

[ "Function", ":", "void", "_SNMPDuplexInit", "(", "UDP_SOCKET", "socket", ")" ]

[ "// In full duplex transfer, transport protocol must be ready to", "// accept new transmit packet.", "// Initialize buffer offsets." ]

[ { "param": "socket", "type": "UDP_SOCKET" } ]

[ "BSD-3-Clause" ]

[ "Initialize", "SNMP", "module", "internals", ".", "This", "function", "initializes", "the", "Snmp", "agent", ".", "One", "udp", "socket", "is", "intialized", "and", "opened", "at", "port", "161", ".", "Agent", "will", "receive", "and", "transmit", "all", "the", "snmp", "pdus", "on", "this", "udp", "socket", ".", "At", "least", "one", "UDP", "socket", "must", "be", "available", ".", "UDPInit", "()", "is", "already", "called", ".", "None", "None", "This", "function", "is", "called", "only", "once", "during", "lifetime", "of", "the", "application", ".", "One", "UDP", "socket", "will", "be", "used", "." ]

[ "void", "SNMPInit", "(", "void", ")", "{", "SNMPStatus", ".", "Val", "=", "0", ";", "SNMPAgentSocket", "=", "UDPOpenEx", "(", "0", ",", "UDP_OPEN_SERVER", ",", "SNMP_AGENT_PORT", ",", "INVALID_UDP_PORT", ")", ";", "#ifdef", "STACK_USE_SNMPV3_SERVER", "Snmpv3Init", "(", ")", ";", "#endif", "return", ";", "}" ]

[ "Function", ":", "void", "SNMPInit", "(", "void", ")" ]

[ "// Start with no error or flag set.", "//SNMPAgentSocket = UDPOpen(SNMP_AGENT_PORT, 0, INVALID_UDP_SOCKET);", "// SNMPAgentSocket must not be INVALID_UDP_SOCKET.", "// If it is, compile time value of UDP Socket numbers must be increased." ]

[]

[ "BSD-3-Clause" ]

[ "Collects", "trap", "notification", "info", "and", "send", "ARP", "to", "remote", "host", ".", "This", "function", "prepares", "SNMP", "module", "to", "send", "SNMP", "trap", "notification", "to", "remote", "host", ".", "It", "sends", "ARP", "request", "to", "remote", "host", "to", "learn", "remote", "host", "MAC", "address", ".", "SNMPInit", "()", "is", "already", "called", ".", "None", "This", "is", "first", "of", "series", "of", "functions", "to", "complete", "SNMP", "notification", "." ]

[ "void", "SNMPNotifyPrepare", "(", "IP_ADDR", "*", "remoteHost", ",", "char", "*", "community", ",", "BYTE", "communityLen", ",", "SNMP_ID", "agentIDVar", ",", "BYTE", "notificationCode", ",", "DWORD", "timestamp", ")", "{", "static", "IP_ADDR", "*", "remHostIpAddrPtr", ";", "remHostIpAddrPtr", "=", "remoteHost", ";", "strcpy", "(", "SNMPNotifyInfo", ".", "community", ",", "community", ")", ";", "SNMPNotifyInfo", ".", "communityLen", "=", "communityLen", ";", "SNMPNotifyInfo", ".", "agentIDVar", "=", "agentIDVar", ";", "SNMPNotifyInfo", ".", "notificationCode", "=", "notificationCode", ";", "SNMPNotifyInfo", ".", "timestamp", ".", "Val", "=", "timestamp", ";", "SNMPNotifyInfo", ".", "socket", "=", "INVALID_UDP_SOCKET", ";", "}" ]

[ "Function", ":", "void", "SNMPNotifyPrepare", "(", "IP_ADDR", "*", "remoteHost", "char", "*", "community", "BYTE", "communityLen", "SNMP_ID", "agentIDVar", "BYTE", "notificationCode", "DWORD", "timestamp", ")" ]

[ "// ARPResolve(remHostIpAddrPtr);" ]

[ { "param": "remoteHost", "type": "IP_ADDR" }, { "param": "community", "type": "char" }, { "param": "communityLen", "type": "BYTE" }, { "param": "agentIDVar", "type": "SNMP_ID" }, { "param": "notificationCode", "type": "BYTE" }, { "param": "timestamp", "type": "DWORD" } ]

[ "BSD-3-Clause" ]

[ "Resolves", "given", "remoteHost", "IP", "address", "into", "MAC", "address", ".", "This", "function", "resolves", "given", "remoteHost", "IP", "address", "into", "MAC", "address", "using", "ARP", "module", ".", "If", "remoteHost", "is", "not", "aviailable", "this", "function", "would", "never", "return", "TRUE", ".", "Application", "must", "implement", "timeout", "logic", "to", "handle", "\"", "remoteHost", "not", "avialable", "\"", "situation", ".", "SNMPNotifyPrepare", "()", "is", "already", "called", ".", "remoteHost", "-", "Pointer", "to", "remote", "Host", "IP", "address", "Return", "Values", ":", "TRUE", "-", "If", "remoteHost", "IP", "address", "is", "resolved", "and", "SNMPNotify", "may", "be", "called", ".", "FALSE", "-", "If", "remoteHost", "IP", "address", "is", "not", "resolved", ".", "This", "would", "fail", "if", "there", "were", "not", "UDP", "socket", "to", "open", "." ]

[ "BOOL", "SNMPIsNotifyReady", "(", "IP_ADDR", "*", "remoteHost", ")", "{", "NODE_INFO", "remoteNode", ";", "IP_ADDR", "*", "remHostIpAddrPtr", ";", "remHostIpAddrPtr", "=", "remoteHost", ";", "remoteNode", ".", "IPAddr", ".", "Val", "=", "remHostIpAddrPtr", "->", "Val", ";", "if", "(", "SNMPNotifyInfo", ".", "socket", "==", "INVALID_UDP_SOCKET", ")", "{", "SNMPNotifyInfo", ".", "socket", "=", "UDPOpenEx", "(", "remoteNode", ".", "IPAddr", ".", "Val", ",", "UDP_OPEN_IP_ADDRESS", ",", "AGENT_NOTIFY_PORT", ",", "SNMP_NMS_PORT", ")", ";", "snmpTrapTimer", "=", "TickGet", "(", ")", ";", "}", "if", "(", "UDPIsOpened", "(", "SNMPNotifyInfo", ".", "socket", ")", "!=", "TRUE", ")", "{", "return", "FALSE", ";", "}", "else", "{", "snmpTrapTimer", "=", "TickGet", "(", ")", ";", "return", "TRUE", ";", "}", "return", "FALSE", ";", "}" ]

[ "Function", ":", "BOOL", "SNMPIsNotifyReady", "(", "IP_ADDR", "*", "remoteHost", ")" ]

[]

[ { "param": "remoteHost", "type": "IP_ADDR" } ]

[ "BSD-3-Clause" ]

[ "Get", "complete", "notification", "variable", "OID", "string", "from", "MPFS", "using", "var", "id", ".", "This", "routine", "is", "called", "when", "a", "OID", "string", "is", "required", "to", "be", "searched", "from", "MPFS", "using", "agent", "id", ".", "The", "string", "is", "saved", "with", "agent", ".", "TRAP", "pdu", "is", "send", "with", "this", "OID", "corresponding", "to", "the", "SNMP_ID", "used", "by", "the", "agent", "application", "to", "send", "the", "pdu", ".", "id", "-", "System", "ID", "to", "use", "identify", "this", "agent", ".", "info", "-", "Pointer", "to", "SNMP", "MIB", "variable", "object", "information", "oidString", "-", "Pointer", "to", "store", "the", "string", "of", "OID", "serached", "len", "-", "Oid", "length", "Return", "Values", ":", "TRUE", "-", "If", "oid", "string", "is", "found", "for", "the", "variable", "id", "in", "MPFS", ".", "FLASE", "-", "Otherwise", ".", "This", "function", "is", "used", "only", "when", "TRAP", "is", "enabled", "." ]

[ "BOOL", "GetOIDStringByID", "(", "SNMP_ID", "id", ",", "OID_INFO", "*", "info", ",", "BYTE", "*", "oidString", ",", "BYTE", "*", "len", ")", "{", "DWORD", "hCurrent", ";", "hCurrent", "=", "0", ";", "while", "(", "1", ")", "{", "ReadMIBRecord", "(", "hCurrent", ",", "info", ")", ";", "if", "(", "!", "info", "->", "nodeInfo", ".", "Flags", ".", "bIsParent", ")", "{", "if", "(", "info", "->", "nodeInfo", ".", "Flags", ".", "bIsIDPresent", ")", "{", "if", "(", "info", "->", "id", "==", "id", ")", "return", "GetOIDStringByAddr", "(", "info", ",", "oidString", ",", "len", ")", ";", "}", "if", "(", "info", "->", "nodeInfo", ".", "Flags", ".", "bIsSibling", "||", "info", "->", "nodeInfo", ".", "Flags", ".", "bIsDistantSibling", ")", "MPFSSeek", "(", "hMPFS", ",", "info", "->", "hSibling", ",", "MPFS_SEEK_START", ")", ";", "else", "break", ";", "}", "hCurrent", "=", "MPFSTell", "(", "hMPFS", ")", ";", "}", "return", "FALSE", ";", "}" ]

[ "Function", ":", "BOOL", "GetOIDStringByID", "(", "SNMP_ID", "id", "OID_INFO", "*", "info", "BYTE", "*", "oidString", "BYTE", "*", "len", ")" ]

[ "//Read in the Mib record for the oid info" ]

[ { "param": "id", "type": "SNMP_ID" }, { "param": "info", "type": "OID_INFO" }, { "param": "oidString", "type": "BYTE" }, { "param": "len", "type": "BYTE" } ]

[ "BSD-3-Clause" ]

[ "Validates", "the", "received", "udp", "packet", "Get", "/", "Set", "request", "header", ".", "All", "the", "variables", "of", "snmp", "pdu", "request", "header", "are", "validated", "for", "their", "data", "types", ".", "Collects", "request_id", "for", "the", "snmp", "request", "pdu", ".", "Fetch", "validates", "error", "status", "error", "index", "and", "discard", "as", "they", "are", "need", "not", "to", "be", "processed", "as", "received", "in", "request", "pdu", ".", "Collects", "non", "repeaters", "and", "max", "repeaters", "values", "in", "case", "of", "Get_Bulk", "request", ".", "ProcessHeader", "()", "is", "called", "and", "returns", "pdu", "type", "and", "do", "not", "returns", "SNMP_ACTION_UNKNOWN", "pduDbPtr", "-", "Pointer", "to", "received", "pdu", "information", "database", ".", "Return", "Values", ":", "TRUE", "-", "If", "the", "received", "request", "header", "is", "validated", "and", "passed", ".", "FALSE", "-", "If", "rxed", "request", "header", "is", "not", "valid", ".", "The", "request", "pdu", "will", "be", "processed", "only", "if", "this", "routine", "returns", "TRUE" ]

[ "static", "BOOL", "ProcessGetSetHeader", "(", "PDU_INFO", "*", "pduDbPtr", ")", "{", "DWORD_VAL", "tempData", ";", "if", "(", "IsValidInt", "(", "&", "tempData", ".", "Val", ")", ")", "pduDbPtr", "->", "requestID", ".", "Val", "=", "tempData", ".", "Val", ";", "else", "return", "FALSE", ";", "if", "(", "(", "pduDbPtr", "->", "snmpVersion", "==", "(", "BYTE", ")", "SNMP_V1", "||", "pduDbPtr", "->", "snmpVersion", "==", "(", "BYTE", ")", "SNMP_V2C", ")", "&&", "(", "pduDbPtr", "->", "pduType", "!=", "GET_BULK_REQUEST", ")", ")", "{", "if", "(", "!", "IsValidInt", "(", "&", "tempData", ".", "Val", ")", ")", "return", "FALSE", ";", "return", "IsValidInt", "(", "&", "tempData", ".", "Val", ")", ";", "}", "else", "if", "(", "(", "pduDbPtr", "->", "snmpVersion", "==", "(", "BYTE", ")", "SNMP_V2C", ")", "&&", "pduDbPtr", "->", "pduType", "==", "GET_BULK_REQUEST", ")", "{", "if", "(", "IsValidInt", "(", "&", "tempData", ".", "Val", ")", ")", "pduDbPtr", "->", "nonRepeators", "=", "tempData", ".", "v", "[", "0", "]", ";", "else", "return", "FALSE", ";", "if", "(", "IsValidInt", "(", "&", "tempData", ".", "Val", ")", ")", "pduDbPtr", "->", "maxRepetitions", "=", "(", "BYTE", ")", "tempData", ".", "v", "[", "0", "]", ";", "else", "return", "FALSE", ";", "}", "else", "return", "FALSE", ";", "return", "TRUE", ";", "}" ]

[ "Function", ":", "BOOL", "ProcessGetSetHeader", "(", "PDU_INFO", "*", "pduDbPtr", ")" ]

[ "// Fetch and save request ID.", "/*|| pduDbPtr->snmpVersion == (BYTE)SNMP_V3*/", "// Fetch and discard error status", "// Fetch and disacard error index", "/*|| pduDbPtr->snmpVersion == (BYTE)SNMP_V3*/", "// Fetch non-repeaters value", "// Fetch Max-repetitions value" ]

[ { "param": "pduDbPtr", "type": "PDU_INFO" } ]

[ "BSD-3-Clause" ]

[ "To", "search", "and", "validate", "whether", "the", "requested", "OID", "is", "in", "the", "MIB", "database", ".", "The", "MIB", "database", "is", "stored", "with", "the", "agent", "in", "binary", "mib", "format", ".", "This", "is", "the", "binary", "mib", "format", ":", "...", ">", "]", "}", "ChildNode", "variable", "bind", "name", "is", "a", "dotted", "string", "of", "oid", ".", "Every", "oid", "is", "a", "node", "in", "the", "MIB", "tree", "and", "have", "varied", "information", ".", "This", "routine", "on", "reception", "of", "the", "snmp", "request", "will", "search", "for", "every", "oid", "in", "the", "var", "name", ".", "This", "routine", "will", "return", "information", "whether", "the", "requested", "var", "name", "is", "part", "of", "the", "MIB", "tree", "data", "structre", "of", "this", "agent", "or", "not", ".", "Valid", "snmp", "request", "with", "valid", "OID", "format", "is", "received", ".", "pduDbPtr", "-", "Pointer", "to", "received", "snmp", "pdu", "elements", "information", "oid", "-", "Pointer", "to", "the", "string", "of", "OID", "to", "be", "searched", "oidLen", "-", "Oid", "length", "rec", "-", "Pointer", "to", "SNMP", "MIB", "variable", "object", "information", "Return", "Values", ":", "TRUE", "-", "If", "the", "complete", "OID", "string", "is", "found", "in", "the", "mib", "FALSE", "-", "If", "complete", "OID", "do", "not", "match", ".", "Also", "different", "erros", "returned", "are", "SNMP_END_OF_MIB_VIEW", "SNMP_NO_SUCH_NAME", "SNMP_NO_SUCH_OBJ", "SNMP_NO_SUCH_INSTANCE", "Remarks", ":", "This", "routine", "works", "for", "the", "MPFS2", "mib", "storage", "format", ".", "It", "uses", "the", "MPFS2", "APIs", "to", "read", "search", "and", "collect", "information", "from", "the", "mib", "database", "." ]

[ "BYTE", "OIDLookup", "(", "PDU_INFO", "*", "pduDbPtr", ",", "BYTE", "*", "oid", ",", "BYTE", "oidLen", ",", "OID_INFO", "*", "rec", ")", "{", "BYTE", "idLen", "=", "1", ";", "BYTE", "savedOID", ",", "tempSavedOID", ";", "BYTE", "matchedCount", ";", "BYTE", "snmpVer", ";", "BYTE", "snmpReqType", ";", "BYTE", "tempLen", ";", "BYTE", "*", "reqOidPtr", ";", "BYTE", "comapreOidWithSibling", "=", "FALSE", ";", "WORD_VAL", "tempData", ";", "DWORD", "hNode", ",", "tempHNode", ";", "appendZeroToOID", "=", "TRUE", ";", "snmpVer", "=", "pduDbPtr", "->", "snmpVersion", ";", "snmpReqType", "=", "pduDbPtr", "->", "pduType", ";", "if", "(", "!", "SNMPStatus", ".", "Flags", ".", "bIsFileOpen", ")", "return", "FALSE", ";", "hNode", "=", "0", ";", "matchedCount", "=", "oidLen", ";", "tempLen", "=", "oidLen", ";", "reqOidPtr", "=", "oid", ";", "while", "(", "1", ")", "{", "MPFSSeek", "(", "hMPFS", ",", "hNode", ",", "MPFS_SEEK_START", ")", ";", "rec", "->", "hNode", "=", "MPFSTell", "(", "hMPFS", ")", ";", "MPFSGet", "(", "hMPFS", ",", "&", "savedOID", ")", ";", "if", "(", "comapreOidWithSibling", "==", "(", "BYTE", ")", "FALSE", ")", "{", "tempSavedOID", "=", "savedOID", ";", "tempHNode", "=", "hNode", ";", "}", "MPFSGet", "(", "hMPFS", ",", "&", "rec", "->", "nodeInfo", ".", "Val", ")", ";", "if", "(", "rec", "->", "nodeInfo", ".", "Flags", ".", "bIsIDPresent", ")", "{", "MPFSGet", "(", "hMPFS", ",", "&", "idLen", ")", ";", "if", "(", "idLen", "==", "1", ")", "{", "BYTE", "temp", ";", "MPFSGet", "(", "hMPFS", ",", "&", "temp", ")", ";", "rec", "->", "id", "=", "temp", "&", "0xFF", ";", "}", "else", "if", "(", "idLen", "==", "2", ")", "{", "BYTE", "temp", "[", "2", "]", ";", "MPFSGetArray", "(", "hMPFS", ",", "temp", ",", "2", ")", ";", "rec", "->", "id", "=", "0", ";", "rec", "->", "id", "=", "temp", "[", "0", "]", "&", "0xFF", ";", "rec", "->", "id", "<<=", "8", ";", "rec", "->", "id", "|=", "temp", "[", "1", "]", "&", "0xFF", ";", "}", "}", "if", "(", "rec", "->", "nodeInfo", ".", "Flags", ".", "bIsSibling", ")", "{", "MPFSGet", "(", "hMPFS", ",", "&", "tempData", ".", "v", "[", "0", "]", ")", ";", "MPFSGet", "(", "hMPFS", ",", "&", "tempData", ".", "v", "[", "1", "]", ")", ";", "rec", "->", "hSibling", "=", "tempData", ".", "Val", ";", "}", "if", "(", "savedOID", "!=", "*", "reqOidPtr", ")", "{", "if", "(", "matchedCount", "==", "oidLen", ")", "goto", "FoundIt", ";", "if", "(", "comapreOidWithSibling", "==", "(", "BYTE", ")", "TRUE", "&&", "!", "rec", "->", "nodeInfo", ".", "Flags", ".", "bIsSibling", ")", "goto", "DidNotFindIt", ";", "if", "(", "rec", "->", "nodeInfo", ".", "Flags", ".", "bIsSibling", ")", "{", "hNode", "=", "MPFSSeek", "(", "hMPFS", ",", "tempData", ".", "Val", ",", "MPFS_SEEK_START", ")", ";", "hNode", "=", "MPFSTell", "(", "hMPFS", ")", ";", "comapreOidWithSibling", "=", "TRUE", ";", "}", "else", "goto", "DidNotFindIt", ";", "}", "else", "{", "matchedCount", "--", ";", "reqOidPtr", "++", ";", "if", "(", "!", "rec", "->", "nodeInfo", ".", "Flags", ".", "bIsParent", ")", "{", "if", "(", "rec", "->", "nodeInfo", ".", "Flags", ".", "bIsDistantSibling", ")", "{", "MPFSGet", "(", "hMPFS", ",", "&", "tempData", ".", "v", "[", "0", "]", ")", ";", "MPFSGet", "(", "hMPFS", ",", "&", "tempData", ".", "v", "[", "1", "]", ")", ";", "rec", "->", "hSibling", "=", "tempData", ".", "Val", ";", "}", "rec", "->", "dataType", "=", "0", ";", "MPFSGet", "(", "hMPFS", ",", "(", "BYTE", "*", ")", "&", "rec", "->", "dataType", ")", ";", "rec", "->", "hData", "=", "MPFSTell", "(", "hMPFS", ")", ";", "if", "(", "snmpReqType", "==", "SNMP_GET", "&&", "matchedCount", "==", "0u", ")", "{", "appendZeroToOID", "=", "FALSE", ";", "goto", "DidNotFindIt", ";", "}", "else", "if", "(", "snmpReqType", "==", "(", "BYTE", ")", "SNMP_GET", "&&", "matchedCount", "==", "1u", "&&", "*", "reqOidPtr", "==", "0x00u", ")", "{", "appendZeroToOID", "=", "FALSE", ";", "}", "else", "if", "(", "snmpReqType", "==", "SNMP_GET_NEXT", "&&", "matchedCount", "==", "0u", ")", "{", "appendZeroToOID", "=", "TRUE", ";", "getZeroInstance", "=", "TRUE", ";", "}", "else", "if", "(", "snmpReqType", "==", "(", "BYTE", ")", "SNMP_V2C_GET_BULK", "&&", "matchedCount", "==", "1u", ")", "{", "appendZeroToOID", "=", "FALSE", ";", "}", "goto", "FoundIt", ";", "}", "else", "if", "(", "matchedCount", "==", "1u", "&&", "*", "reqOidPtr", "==", "0x00u", ")", "{", "appendZeroToOID", "=", "FALSE", ";", "if", "(", "rec", "->", "nodeInfo", ".", "Flags", ".", "bIsParent", ")", "{", "goto", "DidNotFindIt", ";", "}", "}", "else", "if", "(", "matchedCount", "==", "0u", ")", "{", "if", "(", "rec", "->", "nodeInfo", ".", "Flags", ".", "bIsParent", "||", "snmpReqType", "==", "SNMP_GET", ")", "{", "appendZeroToOID", "=", "FALSE", ";", "goto", "DidNotFindIt", ";", "}", "else", "goto", "FoundIt", ";", "}", "else", "{", "hNode", "=", "MPFSTell", "(", "hMPFS", ")", ";", "continue", ";", "}", "}", "}", "FoundIt", ":", "rec", "->", "index", "=", "savedOID", ";", "savedOID", "=", "*", "reqOidPtr", ";", "rec", "->", "indexLen", "=", "1", ";", "if", "(", "matchedCount", "==", "1u", ")", "{", "rec", "->", "index", "=", "*", "reqOidPtr", ";", "}", "else", "if", "(", "matchedCount", "==", "0u", ")", "{", "rec", "->", "index", "=", "0", ";", "}", "else", "if", "(", "matchedCount", ">", "1u", "||", "savedOID", "&", "0x80", ")", "{", "rec", "->", "indexLen", "=", "0xff", ";", "if", "(", "snmpReqType", "==", "SNMP_GET", "&&", "snmpVer", "==", "(", "BYTE", ")", "SNMP_V1", ")", "{", "return", "SNMP_NO_SUCH_NAME", ";", "}", "else", "if", "(", "snmpReqType", "==", "SNMP_GET", "&&", "snmpVer", "==", "(", "BYTE", ")", "SNMP_V2C", ")", "{", "if", "(", "matchedCount", "==", "oidLen", ")", "return", "SNMP_NO_SUCH_INSTANCE", ";", "else", "return", "SNMP_NO_SUCH_OBJ", ";", "}", "return", "FALSE", ";", "}", "if", "(", "getZeroInstance", ")", "{", "rec", "->", "index", "=", "SNMP_INDEX_INVALID", ";", "if", "(", "!", "SNMPGetNextIndex", "(", "rec", "->", "id", ",", "&", "rec", "->", "index", ")", ")", "{", "rec", "->", "index", "=", "0", ";", "}", "}", "return", "TRUE", ";", "DidNotFindIt", ":", "if", "(", "snmpReqType", "==", "SNMP_GET", ")", "{", "if", "(", "snmpVer", "==", "(", "BYTE", ")", "SNMP_V1", ")", "return", "SNMP_NO_SUCH_NAME", ";", "else", "if", "(", "snmpVer", "==", "(", "BYTE", ")", "SNMP_V2C", ")", "{", "if", "(", "matchedCount", "==", "oidLen", ")", "return", "SNMP_NO_SUCH_INSTANCE", ";", "else", "return", "SNMP_NO_SUCH_OBJ", ";", "}", "}", "else", "if", "(", "(", "snmpReqType", "==", "SNMP_GET_NEXT", "||", "snmpReqType", "==", "SNMP_V2C_GET_BULK", ")", "&&", "snmpVer", "==", "(", "BYTE", ")", "SNMP_V2C", ")", "{", "return", "SNMP_END_OF_MIB_VIEW", ";", "}", "return", "FALSE", ";", "}" ]

[ "Function", ":", "BYTE", "OIDLookup", "(", "PDU_INFO", "*", "pduDbPtr", "BYTE", "*", "oid", "BYTE", "oidLen", "OID_INFO", "*", "rec", ")" ]

[ "// MPFS hNode;", "// Remember offset of this node so that we can find its sibling", "// and child data.", "// hNode;", "// Read OID byte.", "// Read Node Info", "// Next byte will be node id, if this is a leaf node with variable data.", "//MPFSGet(hMPFS,(BYTE *)&rec->id);", "// Read sibling offset, if there is any.", "/*if very first OID byte does not match, it may be because it is\n 0, 1 or 2. In that case declare that there is a match.\n The command processor would detect OID type and continue or reject\n this OID as a valid argument.*/", "// One more oid byte matched.", "// A node is said to be matched if last matched node is a leaf node", "// or all but last OID string is matched and last byte of OID is '0'.", "// i.e. single index.", "// Read and discard Distant Sibling info if there is any.", "// Try to match following child node.", "// Convert index info from OID to regular value format.", "/*To Reach To The Next leaf Node */", "/*In this version, we only support 7-bit index*/", "// Current instnace spans across more than 7-bit.", "//No OBJECT IDNETIFIER Prefix match", "// Here to get the first available index with initializing rec->index to SNMP_INDEX_INVALID", "//No OBJECT IDNETIFIER Prefix match" ]

[ { "param": "pduDbPtr", "type": "PDU_INFO" }, { "param": "oid", "type": "BYTE" }, { "param": "oidLen", "type": "BYTE" }, { "param": "rec", "type": "OID_INFO" } ]

[ "BSD-3-Clause" ]

[ "Searches", "for", "the", "next", "leaf", "node", "in", "the", "MIP", "tree", ".", "This", "routine", "searches", "for", "the", "next", "leaf", "node", "from", "the", "current", "node", ".", "The", "input", "to", "this", "function", "is", "the", "node", "from", "where", "next", "leaf", "node", "is", "to", "be", "located", ".", "The", "next", "leaf", "node", "will", "be", "a", "silbing", "else", "distant", "sibling", "or", "leaf", "node", "of", "next", "branch", "if", "any", "present", ".", "The", "input", "parameter", "var", "pointer", "will", "be", "updated", "with", "the", "newly", "found", "leaf", "node", "OID", "info", ".", "rec", "-", "Pointer", "to", "SNMP", "MIB", "variable", "object", "information", "Return", "Values", ":", "TRUE", "-", "If", "next", "leaf", "node", "is", "found", ".", "FALSE", "-", "There", "is", "no", "next", "leaf", "node", ".", "None", "." ]

[ "BOOL", "GetNextLeaf", "(", "OID_INFO", "*", "rec", ")", "{", "WORD_VAL", "temp", ";", "BYTE", "idLen", "=", "1", ";", "if", "(", "!", "rec", "->", "nodeInfo", ".", "Flags", ".", "bIsParent", ")", "{", "if", "(", "rec", "->", "nodeInfo", ".", "Flags", ".", "bIsSibling", "||", "rec", "->", "nodeInfo", ".", "Flags", ".", "bIsDistantSibling", ")", "{", "MPFSSeek", "(", "hMPFS", ",", "rec", "->", "hSibling", ",", "MPFS_SEEK_START", ")", ";", "}", "else", "{", "return", "FALSE", ";", "}", "}", "while", "(", "1", ")", "{", "rec", "->", "hNode", "=", "MPFSTell", "(", "hMPFS", ")", ";", "MPFSGet", "(", "hMPFS", ",", "&", "rec", "->", "oid", ")", ";", "MPFSGet", "(", "hMPFS", ",", "&", "rec", "->", "nodeInfo", ".", "Val", ")", ";", "if", "(", "rec", "->", "nodeInfo", ".", "Flags", ".", "bIsIDPresent", ")", "{", "MPFSGet", "(", "hMPFS", ",", "&", "idLen", ")", ";", "if", "(", "idLen", "==", "1", ")", "{", "BYTE", "temp", ";", "MPFSGet", "(", "hMPFS", ",", "&", "temp", ")", ";", "rec", "->", "id", "=", "temp", "&", "0xFF", ";", "}", "else", "if", "(", "idLen", "==", "2", ")", "{", "BYTE", "temp", "[", "2", "]", ";", "MPFSGetArray", "(", "hMPFS", ",", "temp", ",", "2", ")", ";", "rec", "->", "id", "=", "0", ";", "rec", "->", "id", "=", "temp", "[", "0", "]", "&", "0xFF", ";", "rec", "->", "id", "<<=", "8", ";", "rec", "->", "id", "|=", "temp", "[", "1", "]", "&", "0xFF", ";", "}", "}", "if", "(", "rec", "->", "nodeInfo", ".", "Flags", ".", "bIsSibling", "||", "rec", "->", "nodeInfo", ".", "Flags", ".", "bIsDistantSibling", ")", "{", "MPFSGet", "(", "hMPFS", ",", "&", "temp", ".", "v", "[", "0", "]", ")", ";", "MPFSGet", "(", "hMPFS", ",", "&", "temp", ".", "v", "[", "1", "]", ")", ";", "rec", "->", "hSibling", "=", "temp", ".", "Val", ";", "}", "if", "(", "rec", "->", "nodeInfo", ".", "Flags", ".", "bIsParent", ")", "{", "continue", ";", "}", "rec", "->", "dataType", "=", "0", ";", "MPFSGet", "(", "hMPFS", ",", "(", "BYTE", "*", ")", "&", "rec", "->", "dataType", ")", ";", "rec", "->", "hData", "=", "MPFSTell", "(", "hMPFS", ")", ";", "rec", "->", "indexLen", "=", "1", ";", "rec", "->", "index", "=", "0", ";", "if", "(", "rec", "->", "nodeInfo", ".", "Flags", ".", "bIsSequence", ")", "{", "rec", "->", "index", "=", "SNMP_INDEX_INVALID", ";", "if", "(", "!", "SNMPGetNextIndex", "(", "rec", "->", "id", ",", "&", "rec", "->", "index", ")", ")", "rec", "->", "index", "=", "0", ";", "}", "return", "TRUE", ";", "}", "return", "FALSE", ";", "}" ]

[ "Function", ":", "BOOL", "GetNextLeaf", "(", "OID_INFO", "*", "rec", ")" ]

[ "// If current node is leaf, its next sibling (near or distant) is the next leaf.", "// Since this is a leaf node, it must have at least one distant or near", "// sibling to get next sibling.", "// Reposition at sibling.", "// Fetch node related information", "// There is no sibling to this leaf. This must be the very last node on the tree.", "//--MPFSClose();", "// Remember current MPFS position for this node.", "// Read OID byte.", "// Read Node Info", "// Next byte will be node id, if this is a leaf node with variable data.", "// Fetch index ID.", "//MPFSGet(hMPFS,(BYTE *) &rec->id);", "// Fetch sibling offset, if there is any.", "// If we have not reached a leaf yet, continue fetching next child in line.", "// Fetch data type.", "// Since we just found next leaf in line, it will always have zero index", "// to it.", "// Here to get the first available index with initializing rec->index to SNMP_INDEX_INVALID" ]

[ { "param": "rec", "type": "OID_INFO" } ]

[ "BSD-3-Clause" ]

[ "Get", "OID", "string", "from", "MPFS", "using", "the", "node", "address", ".", "This", "routine", "is", "called", "when", "a", "OID", "string", "is", "required", "to", "be", "searched", "from", "MPFS", "using", "node", "address", ".", "h", "-", "Node", "adderess", "whose", "oid", "is", "to", "be", "read", ".", "rec", "-", "Pointer", "to", "store", "SNMP", "MIB", "variable", "object", "information", "None", ".", "None", "." ]

[ "static", "void", "ReadMIBRecord", "(", "DWORD", "h", ",", "OID_INFO", "*", "rec", ")", "{", "MIB_INFO", "nodeInfo", ";", "WORD_VAL", "tempVal", ";", "BYTE", "idLen", "=", "1", ";", "MPFSSeek", "(", "hMPFS", ",", "h", ",", "MPFS_SEEK_START", ")", ";", "rec", "->", "hNode", "=", "h", ";", "MPFSGet", "(", "hMPFS", ",", "&", "rec", "->", "oid", ")", ";", "MPFSGet", "(", "hMPFS", ",", "&", "rec", "->", "nodeInfo", ".", "Val", ")", ";", "nodeInfo", "=", "rec", "->", "nodeInfo", ";", "if", "(", "nodeInfo", ".", "Flags", ".", "bIsIDPresent", ")", "{", "MPFSGet", "(", "hMPFS", ",", "&", "idLen", ")", ";", "if", "(", "idLen", "==", "1", ")", "{", "BYTE", "temp", "=", "0", ";", "MPFSGet", "(", "hMPFS", ",", "&", "temp", ")", ";", "rec", "->", "id", "=", "temp", "&", "0xFF", ";", "}", "else", "if", "(", "idLen", "==", "2", ")", "{", "BYTE", "temp", "[", "2", "]", ";", "MPFSGetArray", "(", "hMPFS", ",", "temp", ",", "2", ")", ";", "rec", "->", "id", "=", "0", ";", "rec", "->", "id", "=", "temp", "[", "0", "]", "&", "0xFF", ";", "rec", "->", "id", "<<=", "8", ";", "rec", "->", "id", "|=", "temp", "[", "1", "]", "&", "0xFF", ";", "}", "}", "if", "(", "nodeInfo", ".", "Flags", ".", "bIsSibling", ")", "{", "MPFSGet", "(", "hMPFS", ",", "&", "tempVal", ".", "v", "[", "0", "]", ")", ";", "MPFSGet", "(", "hMPFS", ",", "&", "tempVal", ".", "v", "[", "1", "]", ")", ";", "rec", "->", "hSibling", "=", "tempVal", ".", "Val", ";", "}", "if", "(", "nodeInfo", ".", "Flags", ".", "bIsParent", ")", "rec", "->", "hChild", "=", "MPFSTell", "(", "hMPFS", ")", ";", "else", "{", "if", "(", "nodeInfo", ".", "Flags", ".", "bIsDistantSibling", ")", "{", "MPFSGet", "(", "hMPFS", ",", "&", "tempVal", ".", "v", "[", "0", "]", ")", ";", "MPFSGet", "(", "hMPFS", ",", "&", "tempVal", ".", "v", "[", "1", "]", ")", ";", "rec", "->", "hSibling", "=", "tempVal", ".", "Val", ";", "}", "rec", "->", "dataType", "=", "0", ";", "MPFSGet", "(", "hMPFS", ",", "(", "BYTE", "*", ")", "&", "rec", "->", "dataType", ")", ";", "rec", "->", "hData", "=", "MPFSTell", "(", "hMPFS", ")", ";", "}", "}" ]

[ "Function", ":", "void", "ReadMIBRecord", "(", "DWORD", "h", "OID_INFO", "*", "rec", ")" ]

[ "// Remember location of this record.", "// Read OID", "// Read nodeInfo", "// Read id, if there is any: Only leaf node with dynamic data will have id.", "// Fetch index ID.", "//MPFSGet(hMPFS, &rec->id);", "// Read Sibling offset if there is any - any node may have sibling", "// All rest of the parameters are applicable to leaf node only.", "// Read Distant Sibling if there is any - only leaf node will have distant sibling", "// Save data type for this node." ]

[ { "param": "h", "type": "DWORD" }, { "param": "rec", "type": "OID_INFO" } ]

[ "BSD-3-Clause" ]

[ "void", "SetErrorStatus", "(", "WORD", "errorStatusOffset", "WORD", "errorIndexOffset", "SNMP_ERR_STATUS", "errorStatus", "BYTE", "errorIndex", ")", "Summary", ":", "Set", "snmp", "error", "status", "in", "the", "response", "pdu", ".", "This", "routine", "processes", "the", "received", "snmp", "Get", "request", "pdu", "for", "the", "variable", "binding", "in", "the", "request", "and", "also", "creates", "the", "response", "pdu", ".", "Offset", "to", "update", "error", "status", "in", "Response", "Tx", "pdu", "errorIndexOffset", "-", "Offset", "to", "update", "error", "index", "errorStatus", "-", "Snmp", "process", "error", "to", "be", "updated", "in", "response", ".", "errorIndex", "-", "Index", "of", "the", "request", "varbind", "in", "the", "var", "bind", "list", "for", "which", "error", "status", "is", "to", "be", "updated", ".", "None", ".", "None", "." ]

[ "void", "SetErrorStatus", "(", "WORD", "errorStatusOffset", ",", "WORD", "errorIndexOffset", ",", "SNMP_ERR_STATUS", "errorStatus", ",", "BYTE", "errorIndex", ")", "{", "WORD", "prevOffset", ";", "prevOffset", "=", "_SNMPGetTxOffset", "(", ")", ";", "_SNMPSetTxOffset", "(", "errorStatusOffset", ")", ";", "_SNMPPut", "(", "(", "BYTE", ")", "errorStatus", ")", ";", "_SNMPSetTxOffset", "(", "errorIndexOffset", ")", ";", "_SNMPPut", "(", "errorIndex", ")", ";", "_SNMPSetTxOffset", "(", "prevOffset", ")", ";", "}" ]

[ "Function", ":", "void", "SetErrorStatus", "(", "WORD", "errorStatusOffset", "WORD", "errorIndexOffset", "SNMP_ERR_STATUS", "errorStatus", "BYTE", "errorIndex", ")", "Summary", ":", "Set", "snmp", "error", "status", "in", "the", "response", "pdu", "." ]

[]

[ { "param": "errorStatusOffset", "type": "WORD" }, { "param": "errorIndexOffset", "type": "WORD" }, { "param": "errorStatus", "type": "SNMP_ERR_STATUS" }, { "param": "errorIndex", "type": "BYTE" } ]

[ "BSD-3-Clause" ]

[ "Finds", "number", "of", "varbinds", "in", "the", "varbind", "list", "received", "in", "a", "pdu", ".", "This", "routine", "is", "used", "to", "find", "the", "number", "of", "OIDs", "requested", "in", "the", "received", "snmp", "pdu", ".", "Precondition", ":", "ProcessVariables", "()", "is", "called", ".", "pdulen", "-", "Length", "of", "snmp", "pdu", "request", "received", ".", "Return", "Values", ":", "varCount", "-", "Number", "of", "OIDs", "found", "in", "a", "pdu", "request", ".", "None", "." ]

[ "static", "BYTE", "FindOIDsInRequest", "(", "WORD", "pdulen", ")", "{", "BYTE", "structureLen", ";", "BYTE", "varCount", "=", "0", ";", "WORD", "prevUDPRxOffset", ";", "WORD", "varBindLen", ";", "WORD", "snmpPduLen", ";", "snmpPduLen", "=", "pdulen", ";", "prevUDPRxOffset", "=", "SNMPRxOffset", ";", "while", "(", "snmpPduLen", ")", "{", "structureLen", "=", "IsValidStructure", "(", "&", "varBindLen", ")", ";", "if", "(", "!", "structureLen", ")", "return", "FALSE", ";", "SNMPRxOffset", "=", "SNMPRxOffset", "+", "varBindLen", ";", "varCount", "++", ";", "snmpPduLen", "=", "snmpPduLen", "-", "structureLen", "-", "varBindLen", ";", "}", "SNMPRxOffset", "=", "prevUDPRxOffset", ";", "return", "varCount", ";", "}" ]

[ "Function", ":", "BYTE", "FindOIDsInRequest", "(", "WORD", "pdulen", ")" ]

[ "//\tif(!IsValidStructure(&varBindLen))", "//\treturn FALSE;", "// 1 byte for STRUCTURE identifier + 0x82 or ox81+1+1 byte(s) for varbind length ", "//-1 //1 byte for STRUCTURE identifier", "//-1//1 byte for varbind length ", "//\t-varBindLen;" ]

[ { "param": "pdulen", "type": "WORD" } ]

[ "BSD-3-Clause" ]

[ "To", "find", "whether", "requested", "OID", "is", "only", "for", "private", "access", ".", "This", "routine", "is", "used", "to", "find", "whether", "requested", "object", "belongs", "to", "the", "private", "object", "group", "of", "the", "mib", "of", "agent", ".", "If", "yes", "then", "that", "mib", "object", "can", "be", "accessed", "only", "with", "private", "community", "(", "supported", "in", "SNMPv2c", ")", ".", "Precondition", ":", "ProcessVariables", "()", "is", "called", ".", "OIDValuePtr", "-", "Pointer", "to", "memory", "stored", "with", "received", "OID", ".", "Return", "Values", ":", "TRUE", "-", "If", "the", "requested", "object", "is", "of", "private", "branch", "of", "the", "mib", ".", "FLASE", "-", "If", "the", "requested", "object", "is", "publically", "accessible", ".", "None", "." ]

[ "static", "BOOL", "SNMPCheckIfPvtMibObjRequested", "(", "BYTE", "*", "OIDValuePtr", ")", "{", "BYTE", "cnt", "=", "0", ";", "BYTE", "pvtObjIdentifier", "[", "4", "]", "=", "{", "0x2b", ",", "0x06", ",", "0x01", ",", "0x04", "}", ";", "while", "(", "cnt", "<", "4u", ")", "{", "if", "(", "pvtObjIdentifier", "[", "cnt", "]", "==", "OIDValuePtr", "[", "cnt", "]", ")", "{", "cnt", "++", ";", "}", "else", "{", "cnt", "=", "0", ";", "return", "FALSE", ";", "}", "if", "(", "cnt", "==", "0x04u", ")", "return", "TRUE", ";", "}", "return", "FALSE", ";", "}" ]

[ "Function", ":", "BOOL", "SNMPCheckIfPvtMibObjRequested", "(", "BYTE", "*", "OIDValuePtr", ")" ]

[ "/*dod*/", "/*internet*/", "/*private*/", "//check whether requested oid is for pvt obj" ]

[ { "param": "OIDValuePtr", "type": "BYTE" } ]

[ "BSD-3-Clause" ]

[ "Construct", "and", "send", "a", "MCI", "packet", "via", "the", "UART", "blocking", ".", "@param", "msgtype1", "Msg", "type", "byte", "MSB", "@param", "msgtype2", "msg", "type", "byte", "LSB", "@param", "payload", "the", "message", "payload" ]

[ "MCIResponse", "MCISend", "(", "unsigned", "char", "*", "msg", ")", "{", "DelayMs", "(", "20", ")", ";", "if", "(", "MCI_IsSending", "(", ")", ")", "return", "NullRSBuf", ";", "MCISendAsync", "(", "msg", ")", ";", "while", "(", "TxMsgState", "!=", "TX_IDLE", ")", ";", "return", "AsyncTxRSBuf", ";", "}" ]

[ "Construct", "and", "send", "a", "MCI", "packet", "via", "the", "UART", "blocking", "." ]

[ "// Message Sequence:\r", "// 1. Wait until 20ms have elapsed since previous message\r", "// 2. Send command via MCISendAsync\r", "// 3. Block till TX_IDLE\r" ]

[ { "param": "msg", "type": "unsigned char" } ]

[ "BSD-3-Clause" ]

[ "Construct", "and", "send", "a", "MCI", "packet", "via", "the", "UART", "non", "-", "blocking", "Call", "is", "non", "-", "blocking", "with", "timeouts", "specified", "MCI", "2", ".", "0", "spec", ".", "@param", "msgtype1", "Msg", "type", "byte", "MSB", "@param", "msgtype2", "msg", "type", "byte", "LSB", "@param", "payload", "the", "message", "payload" ]

[ "void", "MCISendAsync", "(", "unsigned", "char", "*", "msg", ")", "{", "int", "i", "=", "0", ";", "if", "(", "RxMsgState", "!=", "RX_IDLE", ")", "return", ";", "if", "(", "TxMsgState", "==", "TX_IDLE", ")", "{", "AsyncTxRSBuf", ".", "numTries", "=", "1", ";", "AsyncTxRSBuf", ".", "numBytesReceived", "=", "0", ";", "AsyncTxRSBuf", ".", "LLResponseValid", "=", "0", ";", "AsyncTxRSBuf", ".", "AppResponseValid", "=", "0", ";", "}", "else", "AsyncTxRSBuf", ".", "numTries", "++", ";", "TxMsgState", "=", "TX_SEND_CMD", ";", "int", "payloadLen", "=", "msg", "[", "2", "]", "*", "256", "+", "msg", "[", "3", "]", ";", "for", "(", "i", "=", "0", ";", "i", "<", "payloadLen", "+", "4", ";", "i", "++", ")", "{", "txmessage", "[", "i", "]", "=", "msg", "[", "i", "]", ";", "}", "MakeChecksum", "(", "txmessage", ",", "(", "payloadLen", "+", "4", ")", ")", ";", "EPRI_UART_write", "(", "txmessage", ",", "(", "payloadLen", "+", "6", ")", ")", ";", "TimeMonitorRegisterI", "(", "1", ",", "DLL_ACK_NAK_MAX_TIME_OUT_MS", ",", "Message_Timeout_Callback", ")", ";", "TxMsgState", "=", "TX_WAIT_LL_ACK", ";", "}" ]

[ "Construct", "and", "send", "a", "MCI", "packet", "via", "the", "UART", "non", "-", "blocking", "Call", "is", "non", "-", "blocking", "with", "timeouts", "specified", "MCI", "2", ".", "0", "spec", "." ]

[ "// Message Sequence:\r", "// 1. Set TxMsgState, then Send command\r", "// Handled by callbacks:\r", "// 2. Link Layer ACK/NAK received in MCI_Sync_Callback. \r", "// 3. Application Layer ACK/NAK received in MCI_Sync_Callback.\r", "// 4. Wait delay, send Link Layer ACK/NAK from MCI_Wait_Callback\r", "// 5. Wait intermessage delay then return to TX_IDLE from MCI_Wait_Callback\r", "// 6. Retry message if bad or no link-layer ack\r", "// First Try - clear buffer\r", "// 2nd two bytes of message are length of payload\r", "// add 4 to payload length to get message length\r", "// Send initial message to start Tx State Machine\r", "// Set timeout also\r" ]

[ { "param": "msg", "type": "unsigned char" } ]

[ "BSD-3-Clause" ]

[ "Check", "the", "checksum", "of", "a", "received", "message", ".", "@param", "message", "[]", "the", "entire", "message", "including", "checksum", "bits", ".", "@param", "len", "the", "length", "of", "the", "string", ".", "@return", "1", "for", "good", "checksum", "0", "for", "bad", "checksum" ]

[ "int", "ChecksumDecode", "(", "unsigned", "char", "*", "message", ",", "int", "len", ")", "{", "int", "check1", "=", "0xAA", ";", "int", "check2", "=", "0", ";", "int", "checktemp", "=", "0", ";", "int", "count", "=", "0", ";", "while", "(", "count", "<", "len", ")", "{", "checktemp", "=", "message", "[", "count", "]", "&", "0xFF", ";", "check1", "=", "(", "check1", "+", "checktemp", ")", "%", "255", ";", "check2", "=", "(", "check2", "+", "check1", ")", "%", "255", ";", "count", "++", ";", "}", "if", "(", "(", "check1", "==", "0", ")", "&&", "(", "check2", "==", "0", ")", ")", "{", "return", "1", ";", "}", "else", "{", "return", "0", ";", "}", "}" ]

[ "Check", "the", "checksum", "of", "a", "received", "message", "." ]

[ "// see MCI-V1-6.pdf page 68 for explanation\r", "// yay\r", "// nay\r" ]

[ { "param": "message", "type": "unsigned char" }, { "param": "len", "type": "int" } ]

[ "BSD-3-Clause" ]

[ "Compute", "the", "checksum", "of", "an", "outgoing", "message", ".", "It", "is", "up", "to", "the", "user", "to", "append", "the", "Int", "returned", "to", "the", "end", "of", "the", "string", ".", "@param", "message", "[]", "the", "message", "type", "bytes", "and", "payload", ".", "@param", "lan", "string", "length", ".", "@return", "checksum", "as", "two", "byte", "(", "integer", ")", "value" ]

[ "UINT16", "MakeChecksum", "(", "unsigned", "char", "*", "message", ",", "int", "len", ")", "{", "int", "check1", "=", "0xAA", ";", "int", "check2", "=", "0", ";", "int", "checktemp", "=", "0", ";", "int", "msb", "=", "0", ";", "int", "lsb", "=", "0", ";", "int", "count", "=", "0", ";", "while", "(", "count", "<", "len", ")", "{", "checktemp", "=", "message", "[", "count", "]", "&", "0xFF", ";", "check1", "=", "(", "check1", "+", "checktemp", ")", "%", "255", ";", "check2", "=", "(", "check2", "+", "check1", ")", "%", "255", ";", "count", "++", ";", "}", "msb", "=", "255", "-", "(", "(", "check1", "+", "check2", ")", "%", "255", ")", ";", "lsb", "=", "255", "-", "(", "(", "check1", "+", "msb", ")", "%", "255", ")", ";", "message", "[", "len", "]", "=", "(", "char", ")", "msb", ";", "message", "[", "len", "+", "1", "]", "=", "(", "char", ")", "lsb", ";", "return", "(", "msb", "<<", "8", ")", "|", "lsb", ";", "}" ]

[ "Compute", "the", "checksum", "of", "an", "outgoing", "message", "." ]

[ "// see MCI-V1-6.pdf page 68 for explanation\r", "//putsUART(\"in MakeChecksum \\r\\n\");\r" ]

[ { "param": "message", "type": "unsigned char" }, { "param": "len", "type": "int" } ]

[ "BSD-3-Clause" ]

[ "Message", "Sync", "indicator", "Indicates", "message", "receive", "is", "complete", "by", "20ms", "with", "no", "received", "characters", "Callback", "initiated", "from", "UART1InterruptServiceRoutine", "RxBuf", "copied", "into", "rxmessage", "as", "doubled", "-", "buffered", ".", "Must", "be", "done", "processing", "rxmessage", "before", "next", "callback", "." ]

[ "void", "MCI_Sync_Callback", "(", ")", "{", "int", "i", ";", "numBytes", "=", "position_counter", ";", "for", "(", "i", "=", "0", ";", "i", "<", "position_counter", ";", "i", "++", ")", "{", "rxmessage", "[", "i", "]", "=", "RxBuf", "[", "i", "]", ";", "RxBuf", "[", "i", "]", "=", "0", ";", "}", "rxmessage", "[", "i", "]", "=", "0", ";", "numBytes", "=", "position_counter", ";", "position_counter", "=", "0", ";", "RxBytesReceived", "=", "1", ";", "switch", "(", "TxMsgState", ")", "{", "case", "TX_WAIT_LL_ACK", ":", "TimeMonitorCancelI", "(", "1", ")", ";", "rxMessageHandler", "(", "&", "AsyncTxRSBuf", ")", ";", "if", "(", "AsyncTxRSBuf", ".", "LLResponseValid", "&&", "AsyncTxRSBuf", ".", "LLResponse", "[", "0", "]", "==", "0x06", "&&", "AsyncTxRSBuf", ".", "LLResponse", "[", "1", "]", "==", "0x00", ")", "{", "TxMsgState", "=", "TX_WAIT_APP_ACK", ";", "TimeMonitorRegisterI", "(", "1", ",", "AL_RESPONSE_MAX_TIME_OUT_MS", ",", "Message_Timeout_Callback", ")", ";", "}", "else", "{", "TimeMonitorRegisterI", "(", "1", ",", "9", ",", "Message_Timeout_Callback", ")", ";", "}", "break", ";", "case", "TX_WAIT_APP_ACK", ":", "TimeMonitorCancelI", "(", "1", ")", ";", "TxMsgState", "=", "TX_WAIT_LL_ACK_DLY", ";", "TimeMonitorRegisterI", "(", "3", ",", "DLL_ACK_NAK_MIN_TIME_OUT_MS", ",", "MCI_Wait_Callback", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "TxMsgState", "==", "TX_IDLE", ")", "{", "switch", "(", "RxMsgState", ")", "{", "case", "RX_IDLE", ":", "AsyncRxRSBuf", ".", "numBytesReceived", "=", "0", ";", "AsyncRxRSBuf", ".", "LLResponseValid", "=", "0", ";", "AsyncRxRSBuf", ".", "AppResponseValid", "=", "0", ";", "RxMsgState", "=", "RX_CMD_RECEIVED", ";", "rxMessageHandler", "(", "&", "AsyncRxRSBuf", ")", ";", "RxMsgState", "=", "RX_WAIT_LL_ACK_DLY", ";", "TimeMonitorRegisterI", "(", "1", ",", "AL_RESPONSE_MAX_TIME_OUT_MS", ",", "Message_Timeout_Callback", ")", ";", "TimeMonitorRegisterI", "(", "3", ",", "DLL_ACK_NAK_MIN_TIME_OUT_MS", ",", "MCI_Wait_Callback", ")", ";", "break", ";", "case", "RX_RECEIVE_LL_ACK", ":", "TimeMonitorCancelI", "(", "1", ")", ";", "RxMsgState", "=", "RX_IDLE", ";", "break", ";", "default", ":", "break", ";", "}", "}", "return", ";", "}" ]

[ "Message", "Sync", "indicator", "Indicates", "message", "receive", "is", "complete", "by", "20ms", "with", "no", "received", "characters", "Callback", "initiated", "from", "UART1InterruptServiceRoutine", "RxBuf", "copied", "into", "rxmessage", "as", "doubled", "-", "buffered", "." ]

[ "// Cancel Message_Timeout_Callback\r", "// Link-Layer ACK OK. Wait for Application ACK\r", "// LL NAK or worse. Set quick timeout for end-of-message clean-up \r", "// Cancel Message_Timeout_Callback\r", "// send ACK/NAK\r", "// Cancel Message_Timeout_Callback\r" ]

[]

[ "BSD-3-Clause" ]

[ "MCI", "delayed", "callback", ".", "Used", "for", "delaying", "LL", "ACK", "/", "NAK", "and", "App", "ACK", "/", "NAK" ]

[ "void", "MCI_Wait_Callback", "(", ")", "{", "switch", "(", "TxMsgState", ")", "{", "case", "TX_WAIT_LL_ACK_DLY", ":", "TxMsgState", "=", "TX_SEND_LL_ACK", ";", "rxMessageHandler", "(", "&", "AsyncTxRSBuf", ")", ";", "TxMsgState", "=", "TX_IDLE", ";", "break", ";", "case", "TX_WAIT_RETRY_DLY", ":", "MCISendAsync", "(", "txmessage", ")", ";", "break", ";", "default", ":", "break", ";", "}", "switch", "(", "RxMsgState", ")", "{", "case", "RX_WAIT_LL_ACK_DLY", ":", "RxMsgState", "=", "RX_SEND_LL_ACK", ";", "rxMessageHandler", "(", "&", "AsyncRxRSBuf", ")", ";", "RxMsgState", "=", "RX_WAIT_APP_ACK_DLY", ";", "TimeMonitorRegisterI", "(", "11", ",", "AL_RESPONSE_MIN_TIME_OUT_MS", ",", "MCI_Wait_Callback", ")", ";", "break", ";", "case", "RX_WAIT_APP_ACK_DLY", ":", "RxMsgState", "=", "RX_SEND_APP_ACK", ";", "rxMessageHandler", "(", "&", "AsyncRxRSBuf", ")", ";", "RxMsgState", "=", "RX_RECEIVE_LL_ACK", ";", "break", ";", "default", ":", "break", ";", "}", "}" ]

[ "MCI", "delayed", "callback", "." ]

[ "// ACK/NAK Sent from here\r" ]

[]

[ "BSD-3-Clause" ]

[ "-", "Identifies", "if", "trying", "to", "do", "a", "read", "or", "write", "to", "ENC", "RAM", "(", "RAW", "Window", ")", ".", "Any", "time", "stack", "code", "changes", "the", "index", "within", "the", "'", "logical", "'", "Ethernet", "RAM", "this", "function", "must", "be", "called", "to", "assure", "the", "RAW", "driver", "is", "synced", "up", "with", "where", "the", "stack", "code", "thinks", "it", "is", "within", "the", "Ethernet", "RAM", ".", "This", "applies", "to", "reading", "/", "writing", "tx", "data", "rx", "data", "or", "tcb", "data" ]

[ "static", "void", "SyncENCPtrRAWState", "(", "UINT8", "encPtrId", ")", "{", "UINT8", "rawId", ";", "UINT16", "rawIndex", ";", "UINT16", "byteCount", ";", "UINT32", "startTickCount", ";", "UINT32", "maxAllowedTicks", ";", "EnsureWFisAwake", "(", ")", ";", "if", "(", "g_encIndex", "[", "encPtrId", "]", "<", "BASE_SCRATCH_ADDR", ")", "{", "if", "(", "g_encIndex", "[", "encPtrId", "]", "<", "TXSTART", ")", "{", "rawId", "=", "RAW_RX_ID", ";", "rawIndex", "=", "g_encIndex", "[", "encPtrId", "]", "-", "ENC_RX_BUF_TO_RAW_RX_BUF_ADJUSTMENT", ";", "WF_ASSERT", "(", "g_encIndex", "[", "encPtrId", "]", ">=", "(", "RXSTART", "+", "ENC_PREAMBLE_SIZE", ")", ")", ";", "}", "else", "{", "if", "(", "!", "RawWindowReady", "[", "RAW_TX_ID", "]", ")", "{", "maxAllowedTicks", "=", "TICKS_PER_SECOND", "*", "6", ";", "startTickCount", "=", "(", "UINT32", ")", "TickGet", "(", ")", ";", "while", "(", "!", "AllocateDataTxBuffer", "(", "MCHP_DATA_PACKET_SIZE", ")", ")", "{", "if", "(", "TickGet", "(", ")", "-", "startTickCount", ">=", "maxAllowedTicks", ")", "{", "WF_ASSERT", "(", "FALSE", ")", ";", "}", "}", "}", "rawId", "=", "RAW_TX_ID", ";", "rawIndex", "=", "g_encIndex", "[", "encPtrId", "]", "-", "ENC_TX_BUF_TO_RAW_TX_BUF_ADJUSTMENT", ";", "WF_ASSERT", "(", "(", "g_encIndex", "[", "encPtrId", "]", ">=", "BASE_TX_ADDR", ")", "&&", "(", "g_encIndex", "[", "encPtrId", "]", "<=", "(", "BASE_TX_ADDR", "+", "MAX_PACKET_SIZE", ")", ")", ")", ";", "}", "WF_ASSERT", "(", "RawWindowReady", "[", "rawId", "]", ")", ";", "if", "(", "GetRawWindowState", "(", "rawId", ")", "!=", "WF_RAW_DATA_MOUNTED", ")", "{", "byteCount", "=", "PopRawWindow", "(", "rawId", ")", ";", "WF_ASSERT", "(", "byteCount", ">", "0", ")", ";", "SetRawWindowState", "(", "rawId", ",", "WF_RAW_DATA_MOUNTED", ")", ";", "}", "}", "else", "{", "if", "(", "GetRawWindowState", "(", "RAW_RX_ID", ")", "==", "WF_SCRATCH_MOUNTED", ")", "{", "rawId", "=", "RAW_RX_ID", ";", "}", "else", "if", "(", "GetRawWindowState", "(", "RAW_TX_ID", ")", "==", "WF_SCRATCH_MOUNTED", ")", "{", "rawId", "=", "RAW_TX_ID", ";", "}", "else", "{", "if", "(", "(", "g_encPtrRAWId", "[", "1", "-", "encPtrId", "]", ")", "==", "RAW_RX_ID", ")", "{", "rawId", "=", "RAW_TX_ID", ";", "}", "else", "{", "rawId", "=", "RAW_RX_ID", ";", "}", "if", "(", "(", "GetRawWindowState", "(", "rawId", ")", "==", "WF_RAW_DATA_MOUNTED", ")", "||", "(", "GetRawWindowState", "(", "rawId", ")", "==", "WF_RAW_MGMT_MOUNTED", ")", ")", "{", "PushRawWindow", "(", "rawId", ")", ";", "}", "if", "(", "ScratchMount", "(", "rawId", ")", "==", "0", ")", "{", "rawId", "=", "!", "rawId", ";", "}", "}", "rawIndex", "=", "g_encIndex", "[", "encPtrId", "]", "-", "ENC_TCB_BUF_TO_RAW_SCRATCH_BUF_ADJUSTMENT", ";", "}", "if", "(", "RawSetIndex", "(", "rawId", ",", "rawIndex", ")", "==", "FALSE", ")", "{", "if", "(", "rawId", "==", "RAW_RX_ID", ")", "{", "g_rxIndexSetBeyondBuffer", "=", "TRUE", ";", "}", "}", "else", "{", "if", "(", "rawId", "==", "RAW_RX_ID", ")", "{", "g_rxIndexSetBeyondBuffer", "=", "FALSE", ";", "}", "}", "g_encPtrRAWId", "[", "encPtrId", "]", "=", "rawId", ";", "if", "(", "g_encPtrRAWId", "[", "1", "-", "encPtrId", "]", "==", "g_encPtrRAWId", "[", "encPtrId", "]", ")", "{", "g_encPtrRAWId", "[", "1", "-", "encPtrId", "]", "=", "RAW_INVALID_ID", ";", "}", "}" ]

[ "FUNCTION", ":", "SyncENCPtrRAWState", "RETURNS", ":", "None" ]

[ "/*----------------------------------------------------*/", "/* if encPtr[encPtrId] in the enc rx or enc tx buffer */", "/*----------------------------------------------------*/", "/*BASE_TCB_ADDR*/", "/*--------------------------------------*/", "/* if encPtr[encPtrId] in enc Rx buffer */", "/*--------------------------------------*/", "/* set the rawId */", "/* Convert encPtr index to Raw Index */", "// encPtr[encPtrId] < (RXSTART + ENC_PREAMBLE_SIZE) is an error since we don't have", "// the same preamble as the ENC chip", "/*----------------------------------------*/", "/* else encPtr[encPtrId] in enc Tx buffer */", "/*----------------------------------------*/", "/* if the Tx data raw window has not yet been allocated (the stack is accessing a new Tx data packet) */", "/* Before we enter the while loop, get the tick timer count and save it */", "/* 2 second timeout, needed if data traffic and scanning occurring */", "/* Retry until MRF24W has drained it's prior TX pkts - multiple sockets & flows can load the MRF24W10 */", "/* The AllocateDataTxBuffer call may not succeed immediately. */", "/* If timed out than lock up */", "/* timeout occurred */", "/* end while */", "/* set the rawId */", "/* convert enc Ptr index to raw index */", "/* encPtr[encPtrId] < BASE_TX_ADDR is an error since we don't have the same */", "/* pre-BASE_TX_ADDR or post tx buffer as the ENC chip */", "/* Buffer should always be ready and enc pointer should always be valid. */", "/* For the RX buffer this assert can only happen before we have received */", "/* the first data packet. For the TX buffer this could only be the case */", "/* after a macflush() where we couldn't re-mount a new buffer and before */", "/* a macistxready() that successfully re-mounts a new tx buffer. */", "/*-----------------------------------------------------------------------------*/", "/* if the RAW buffer is ready but not mounted, or to put it another way, if */", "/* the RAW buffer was saved, needs to be restored, and it is OK to restore it. */", "/*-----------------------------------------------------------------------------*/", "/* if the buffer is not mounted then it must be restored from Mem */", "/* a side effect is that if the scratch buffer was mounted in the raw */", "/* then it will no longer be mounted */", "// set the buffer state", "/*------------------------------------------------*/", "/* else encPtr[encPtrId] is in the enc tcb buffer */", "/*------------------------------------------------*/", "/* if Rx Raw Window already mounted onto Scratch */", "/* else if Tx Raw Window already mounted onto Scratch */", "/* else Scratch not yet mounted, so need to decide which RAW window to use */", "/* use the Tx RAW window to write to scratch */", "// the other enc pointer is in use in the tx buffer raw or invalid", "// so use the rx buffer raw to mount the scratch buffer", "// set the rawId", "// if we currently have a buffer mounted then we need to save it", "// need to check for both data and mgmt packets", "// mount the scratch window in the selected raw", "/* work-around, somehow the scratch was already mounted to the other raw window */", "/* convert Enc ptr index to raw index */", "/* Set RAW index. If false is returned this means that index set beyond end of raw window, which */", "/* is OK so long as no read or write access is attempted, hence the flag setting. */", "// if we fail the set index we should...", "// use a case statement to determine the object that is mounted (rawId==0, could be rxbuffer object or scratch object)", "// (rawId==1, could be txbuffer or scratch object", "// dismount the object in the appropriate manner (rxbuffer ... save operation, txbuffer save operation, scratch save operation)", "// set the index to 0", "// mark the RawWindowState[rawId] = WF_RAW_UNMOUNTED", "// mark the g_encPtrRAWId[encPtrId] = RAW_INVALID_ID", "// set the g_encPtrRAWId", "// if the opposite encPtr was pointing to the raw window", "// that was re-configured by this routine then it is", "// no longer in sync" ]

[ { "param": "encPtrId", "type": "UINT8" } ]

[ "BSD-3-Clause" ]

[ "None", "this", "is", "a", "workaround", "algorithm", "for", "a", "bug", "appearing", "on", "some", "APs", ":", "they", "broadcasts", "ARP", "Request", "over", "basic", "rate", "at", "11Mpbs", "that", "leaves", "our", "devices", "in", "dark", ".", "Here", "we", "do", "ARP", "Request", "in", "the", "beginning", "for", "all", "the", "memebers", "in", "the", "subnet", "then", "periodically", "do", "Gratuitous", "ARP", "to", "keep", "ourselves", "alive", "with", "the", "AP" ]

[ "void", "WFPeriodicGratuitousArp", "(", "void", ")", "{", "static", "DWORD", "oldTime", "=", "0", ",", "currTime", ";", "static", "BYTE", "op_req", "=", "ARP_OPERATION_REQ", ";", "if", "(", "!", "MACIsLinked", "(", ")", ")", "{", "return", ";", "}", "currTime", "=", "TickGet", "(", ")", ";", "if", "(", "(", "currTime", "<", "oldTime", ")", "||", "(", "(", "currTime", "-", "oldTime", ")", ">", "WFArpBroadcastIntervalSec", "*", "TICK_SECOND", ")", ")", "{", "op_req", "=", "op_req", "==", "ARP_OPERATION_REQ", "?", "ARP_OPERATION_RESP", ":", "ARP_OPERATION_REQ", ";", "ARPSendPkt", "(", "*", "(", "DWORD", "*", ")", "&", "AppConfig", ".", "MyIPAddr", ",", "*", "(", "DWORD", "*", ")", "&", "AppConfig", ".", "MyIPAddr", ",", "op_req", ")", ";", "oldTime", "=", "currTime", ";", "}", "}" ]

[ "FUNCTION", ":", "WFPeriodicGratuitousArp", "RETURNS", ":", "None" ]

[ "//wrap-around case" ]

[]

[ "BSD-3-Clause" ]

[ "None", "Called", "form", "main", "loop", "to", "support", "802", ".", "11", "operations" ]

[ "void", "MACProcess", "(", "void", ")", "{", "WFProcess", "(", ")", ";", "#if", "defined", "(", "WF_CONSOLE_IFCFGUTIL", ")", "\n", "if", "(", "WF_hibernate", ".", "wakeup_notice", "&&", "WF_hibernate", ".", "state", "==", "WF_HB_WAIT_WAKEUP", ")", "{", "DelayMs", "(", "200", ")", ";", "WF_hibernate", ".", "state", "=", "WF_HB_NO_SLEEP", ";", "StackInit", "(", ")", ";", "#if", "defined", "(", "WF_CONSOLE_DEMO", ")", "||", "(", "defined", "(", "WF_EASY_CONFIG_DEMO", ")", "&&", "defined", "(", "__C32__", ")", ")", "\n", "IperfAppInit", "(", ")", ";", "#endif", "WF_Connect", "(", ")", ";", "}", "#endif", "#if", "defined", "(", "WF_CONSOLE_DEMO", ")", "||", "(", "defined", "(", "WF_EASY_CONFIG_DEMO", ")", "&&", "defined", "(", "__C32__", ")", ")", "\n", "IperfAppCall", "(", ")", ";", "#endif", "#if", "!", "defined", "(", "WF_EASY_CONFIG_DEMO", ")", "\n", "#if", "defined", "(", "WF_CONSOLE_IFCFGUTIL", ")", "\n", "wait_console_input", ":", "", "#endif", "#if", "defined", "(", "WF_CONSOLE", ")", "\n", "WFConsoleProcess", "(", ")", ";", "#if", "defined", "(", "WF_CONSOLE_DEMO", ")", "||", "defined", "(", "WF_EASY_CONFIG_DEMO", ")", "\n", "if", "(", "WF_hibernate", ".", "state", "==", "WF_HB_NO_SLEEP", ")", "IperfAppCall", "(", ")", ";", "#endif", "WFConsoleProcessEpilogue", "(", ")", ";", "#endif", "#if", "defined", "(", "WF_CONSOLE_IFCFGUTIL", ")", "\n", "if", "(", "WF_hibernate", ".", "state", "!=", "WF_HB_NO_SLEEP", ")", "{", "if", "(", "WF_hibernate", ".", "state", "==", "WF_HB_ENTER_SLEEP", ")", "{", "SetLogicalConnectionState", "(", "FALSE", ")", ";", "#if", "defined", "(", "WF_USE_POWER_SAVE_FUNCTIONS", ")", "\n", "WF_HibernateEnable", "(", ")", ";", "#endif", "WF_hibernate", ".", "state", "=", "WF_HB_WAIT_WAKEUP", ";", "}", "if", "(", "WF_hibernate", ".", "wakeup_notice", ")", "{", "}", "else", "{", "goto", "wait_console_input", ";", "}", "}", "#endif", "#endif", "if", "(", "g_mgmtAppWaiting", ")", "{", "if", "(", "GetRawWindowState", "(", "RAW_TX_ID", ")", "==", "WF_RAW_DATA_MOUNTED", ")", "{", "DeallocateDataTxBuffer", "(", ")", ";", "if", "(", "g_encPtrRAWId", "[", "ENC_RD_PTR_ID", "]", "==", "RAW_RX_ID", ")", "{", "g_encPtrRAWId", "[", "ENC_RD_PTR_ID", "]", "=", "RAW_INVALID_ID", ";", "}", "if", "(", "g_encPtrRAWId", "[", "ENC_WT_PTR_ID", "]", "==", "RAW_TX_ID", ")", "{", "g_encPtrRAWId", "[", "ENC_WT_PTR_ID", "]", "=", "RAW_INVALID_ID", ";", "}", "}", "else", "{", "g_mgmtAppWaiting", "=", "FALSE", ";", "}", "}", "#if", "defined", "(", "STACK_CLIENT_MODE", ")", "&&", "defined", "(", "USE_GRATUITOUS_ARP", ")", "\n", "WFPeriodicGratuitousArp", "(", ")", ";", "#endif", "}" ]

[ "FUNCTION", ":", "MACProcess", "RETURNS", ":", "None" ]

[ "// Let 802.11 processes have a chance to run", "// Set HIBERNATE pin on MRF24W to HIGH", "//continue;", "/* !defined (WF_EASY_CONFIG_DEMO) */", "/* SG. Deadlock avoidance code when two applications contend for the one tx pipe */", "/* ApplicationA is a data plane application, and applicationB is a control plane application */", "/* In this scenario, the data plane application could be the WiFi manager, and the control plane application */", "/* a sockets application. If the sockets application keeps doing a IsUDPPutReady() and never follows with */", "/* a UDPFlush, then the link manager will be locked out. This would be catescrophic if an AP connection */", "/* goes down, then the link manager could never re-establish connection. Why? The link manager is a control */", "/* plane application, which does mgmt request/confirms. */", "/* */", "/* Sequence of events: */", "/* T0: ApplicationA will issue a call like UDPIsPutReady(), which results in a AllocateDataTxBuffer */", "/* T1: ApplicationB attempts a mgmt request with IsTxMbmtReady() call. The call fails. */", "/* T3: Stack process runs and does not deallocate the tx pipe from the data plane application. */", "/* T4: ApplicationB attempts N+1th time, and fails. */", "/* deallocate the RAW on MRF24W - return memory to pool */", "/* This else is important in that it gives the main loop one iteration for the mgmt application to get it's timeslice */", "/* Otherwise, a data plane task could snatch away the tx pipe again, especially if it's placed before */", "/* the link manager in the main()'s while(1) blk. This code is functionally coupled with isRawRxMgmtInProgress() */", "/* as it will keep the dataplane application locked out for 1 iteration, until this else is executed on N+2 iteration */", "//following is the workaround algorithm for the 11Mbps broadcast bugfix" ]

[]

[ "BSD-3-Clause" ]

[ "None", "If", "no", "Ethernet", "transmission", "is", "in", "progress", "FALSE", ":", "If", "a", "previous", "transmission", "was", "started", "and", "it", "has", "not", "completed", "yet", ".", "While", "FALSE", "the", "data", "in", "the", "transmit", "buffer", "and", "the", "TXST", "/", "TXND", "pointers", "must", "not", "be", "changed", ".", "Side", "Effects", ":", "None", "None" ]

[ "BOOL", "MACIsTxReady", "(", "void", ")", "{", "BOOL", "result", "=", "TRUE", ";", "if", "(", "isRawRxMgmtInProgress", "(", ")", ")", "{", "WFProcess", "(", ")", ";", "return", "FALSE", ";", "}", "if", "(", "!", "RawWindowReady", "[", "RAW_TX_ID", "]", ")", "{", "SetRawWindowState", "(", "RAW_TX_ID", ",", "WF_RAW_UNMOUNTED", ")", ";", "if", "(", "g_encPtrRAWId", "[", "ENC_RD_PTR_ID", "]", "==", "RAW_TX_ID", ")", "{", "g_encPtrRAWId", "[", "ENC_RD_PTR_ID", "]", "=", "RAW_INVALID_ID", ";", "}", "if", "(", "g_encPtrRAWId", "[", "ENC_WT_PTR_ID", "]", "==", "RAW_TX_ID", ")", "{", "g_encPtrRAWId", "[", "ENC_WT_PTR_ID", "]", "=", "RAW_INVALID_ID", ";", "}", "if", "(", "!", "AllocateDataTxBuffer", "(", "MCHP_DATA_PACKET_SIZE", ")", ")", "{", "result", "=", "FALSE", ";", "}", "}", "return", "result", ";", "}" ]

[ "Function", ":", "BOOL", "MACIsTxReady", "(", "void", ")", "PreCondition", ":", "None" ]

[ "/* if waiting for a management response then block data tx until */", "/* mgmt response received */", "// allow mgmt message to be received (stack can call this", "// function in an infinite loop so need to allow WiFi state", "// machines to run.", "// create the new tx buffer" ]

[]

[ "BSD-3-Clause" ]

[ "determines", "if", "a", "RAW", "Tx", "buf", "is", "ready", "for", "a", "management", "msg", "and", "if", "so", "creates", "the", "RAW", "tx", "buffer", ".", "Returns", "TRUE", "if", "successful", "else", "FALSE", "." ]

[ "BOOL", "WFisTxMgmtReady", "(", "void", ")", "{", "BOOL", "res", "=", "TRUE", ";", "if", "(", "isMgmtTxBufAvailable", "(", ")", ")", "{", "if", "(", "AllocateMgmtTxBuffer", "(", "WF_MAX_TX_MGMT_MSG_SIZE", ")", ")", "{", "res", "=", "TRUE", ";", "SetRawRxMgmtInProgress", "(", "TRUE", ")", ";", "}", "else", "{", "res", "=", "FALSE", ";", "}", "}", "else", "{", "res", "=", "FALSE", ";", "g_mgmtAppWaiting", "=", "TRUE", ";", "}", "return", "res", ";", "}" ]

[ "determines", "if", "a", "RAW", "Tx", "buf", "is", "ready", "for", "a", "management", "msg", "and", "if", "so", "creates", "the", "RAW", "tx", "buffer", "." ]

[ "// create and mount tx buffer to hold RAW Mgmt packet", "/* Bug. This flag must be set otherwise the data path does not know */", "/* that the tx pipe has been mounted for mgmt operation. SG */", "// else Tx RAW not available for Mgmt packet", "/* See comment in MACProcess */" ]

[]

[ "BSD-3-Clause" ]

[ "returns", "TRUE", "if", "able", "to", "acquire", "the", "RAW", "Rx", "window", "for", "the", "purpose", "of", "processing", "a", "management", "receive", "message" ]

[ "BOOL", "RawGetMgmtRxBuffer", "(", "UINT16", "*", "p_numBytes", ")", "{", "BOOL", "res", "=", "TRUE", ";", "*", "p_numBytes", "=", "0", ";", "if", "(", "GetRawWindowState", "(", "RAW_RX_ID", ")", "==", "WF_RAW_DATA_MOUNTED", ")", "{", "PushRawWindow", "(", "RAW_RX_ID", ")", ";", "}", "*", "p_numBytes", "=", "RawMountRxBuffer", "(", ")", ";", "WF_ASSERT", "(", "*", "p_numBytes", ">", "0", ")", ";", "SetRawRxMgmtInProgress", "(", "TRUE", ")", ";", "return", "res", ";", "}" ]

[ "returns", "TRUE", "if", "able", "to", "acquire", "the", "RAW", "Rx", "window", "for", "the", "purpose", "of", "processing", "a", "management", "receive", "message" ]

[ "// UINT16 numBytes;", "// if Raw Rx is not currently mounted, or the Scratch is mounted", "// save whatever was mounted to Raw Rx", "// mount the mgmt pool rx data, returns number of bytes in mgmt msg. Index", "// defaults to 0.", "/* Should never receive a mgmt msg with 0 bytes */", "// set flag so we do not try to mount an incoming data packet until after the rx Mgmt msg", "// has been handled." ]

[ { "param": "p_numBytes", "type": "UINT16" } ]

[ "BSD-3-Clause" ]

[ "MACIFService", "RETURNS", ":", "Number", "of", "bytes", "in", "the", "Data", "Rx", "packet", "if", "one", "is", "received", "else", "0", ".", "None", "Called", "by", "MACGetHeader", "()", "to", "see", "if", "any", "data", "packets", "have", "been", "received", ".", "If", "the", "MRF24W", "has", "received", "a", "data", "packet", "and", "the", "data", "packet", "is", "not", "a", "management", "data", "packet", "then", "this", "function", "returns", "the", "number", "of", "bytes", "in", "the", "data", "packet", ".", "Otherwise", "it", "returns", "0", "." ]

[ "static", "UINT16", "MACIFService", "(", "void", ")", "{", "UINT16", "byteCount", "=", "0", ";", "tRxPreamble", "wfPreamble", ";", "if", "(", "!", "g_HostRAWDataPacketReceived", ")", "{", "return", "byteCount", ";", "}", "g_HostRAWDataPacketReceived", "=", "FALSE", ";", "byteCount", "=", "RawMountRxBuffer", "(", ")", ";", "WF_ASSERT", "(", "byteCount", ">", "0", ")", ";", "WF_EintEnable", "(", ")", ";", "RawGetByte", "(", "RAW_RX_ID", ",", "(", "UINT8", "*", ")", "&", "wfPreamble", ",", "sizeof", "(", "tRxPreamble", ")", ")", ";", "WF_ASSERT", "(", "wfPreamble", ".", "type", "==", "WF_DATA_RX_INDICATE_TYPE", ")", ";", "return", "byteCount", ";", "}" ]

[ "FUNCTION", ":", "MACIFService", "RETURNS", ":", "Number", "of", "bytes", "in", "the", "Data", "Rx", "packet", "if", "one", "is", "received", "else", "0", "." ]

[ "/* num bytes returned */", "// if no rx data packet to process or not yet finished with mgmt rx processing", "/* if made it here then External interrupt has signalled a data packet has been received */", "/* clear flag for next data packet */", "/* Mount Read FIFO to RAW Rx window. Allows use of RAW engine to read rx data packet. */", "/* Function call returns number of bytes in the data packet. */", "/* byte count should never be 0 */", "// now that buffer mounted it is safe to reenable interrupts" ]

[]

[ "BSD-3-Clause" ]

[ "*", "remote", ":", "Location", "to", "store", "the", "Source", "MAC", "address", "of", "the", "received", "frame", ".", "*", "type", ":", "Location", "of", "a", "BYTE", "to", "store", "the", "constant", "MAC_UNKNOWN", "ETHER_IP", "or", "ETHER_ARP", "representing", "the", "contents", "of", "the", "Ethernet", "type", "field", ".", "If", "a", "packet", "was", "waiting", "in", "the", "RX", "buffer", ".", "The", "remote", "and", "type", "values", "are", "updated", ".", "FALSE", ":", "If", "a", "packet", "was", "not", "pending", ".", "remote", "and", "type", "are", "not", "changed", ".", "Side", "Effects", ":", "Last", "packet", "is", "discarded", "if", "MACDiscardRx", "()", "hasn", "'", "t", "already", "been", "called", ".", "None", "None" ]

[ "BOOL", "MACGetHeader", "(", "MAC_ADDR", "*", "remote", ",", "BYTE", "*", "type", ")", "{", "UINT16", "len", ";", "tWFRxPreamble", "header", ";", "g_rxIndexSetBeyondBuffer", "=", "FALSE", ";", "if", "(", "GetRawWindowState", "(", "RAW_RX_ID", ")", "==", "WF_RAW_DATA_MOUNTED", ")", "{", "PushRawWindow", "(", "RAW_RX_ID", ")", ";", "}", "SetRawWindowState", "(", "RAW_RX_ID", ",", "WF_RAW_UNMOUNTED", ")", ";", "if", "(", "g_encPtrRAWId", "[", "ENC_RD_PTR_ID", "]", "==", "RAW_RX_ID", ")", "{", "g_encPtrRAWId", "[", "ENC_RD_PTR_ID", "]", "=", "RAW_INVALID_ID", ";", "}", "if", "(", "g_encPtrRAWId", "[", "ENC_WT_PTR_ID", "]", "==", "RAW_RX_ID", ")", "{", "g_encPtrRAWId", "[", "ENC_WT_PTR_ID", "]", "=", "RAW_INVALID_ID", ";", "}", "len", "=", "MACIFService", "(", ")", ";", "if", "(", "len", "==", "0", ")", "{", "return", "FALSE", ";", "}", "RawRead", "(", "RAW_RX_ID", ",", "ENC_PREAMBLE_OFFSET", ",", "WF_RX_PREAMBLE_SIZE", ",", "(", "UINT8", "*", ")", "&", "header", ")", ";", "if", "(", "!", "(", "header", ".", "snap", "[", "0", "]", "==", "SNAP_VAL", "&&", "header", ".", "snap", "[", "1", "]", "==", "SNAP_VAL", "&&", "header", ".", "snap", "[", "2", "]", "==", "SNAP_CTRL_VAL", "&&", "header", ".", "snap", "[", "3", "]", "==", "SNAP_TYPE_VAL", "&&", "header", ".", "snap", "[", "4", "]", "==", "SNAP_TYPE_VAL", "&&", "header", ".", "snap", "[", "5", "]", "==", "SNAP_TYPE_VAL", ")", ")", "{", "DeallocateDataRxBuffer", "(", ")", ";", "return", "FALSE", ";", "}", "g_wasDiscarded", "=", "TRUE", ";", "PushRawWindow", "(", "RAW_RX_ID", ")", ";", "PopRawWindow", "(", "RAW_RX_ID", ")", ";", "RawSetIndex", "(", "RAW_RX_ID", ",", "(", "ENC_PREAMBLE_OFFSET", "+", "WF_RX_PREAMBLE_SIZE", ")", ")", ";", "g_rxBufferSize", "=", "len", ";", "g_encPtrRAWId", "[", "ENC_RD_PTR_ID", "]", "=", "RAW_RX_ID", ";", "g_encIndex", "[", "ENC_RD_PTR_ID", "]", "=", "RXSTART", "+", "sizeof", "(", "ENC_PREAMBLE", ")", ";", "header", ".", "Type", ".", "Val", "=", "swaps", "(", "header", ".", "Type", ".", "Val", ")", ";", "memcpy", "(", "(", "void", "*", ")", "remote", "->", "v", ",", "(", "void", "*", ")", "header", ".", "SourceMACAddr", ".", "v", ",", "sizeof", "(", "*", "remote", ")", ")", ";", "*", "type", "=", "MAC_UNKNOWN", ";", "if", "(", "(", "header", ".", "Type", ".", "v", "[", "1", "]", "==", "0x08u", ")", "&&", "(", "(", "header", ".", "Type", ".", "v", "[", "0", "]", "==", "ETHER_IP", ")", "||", "(", "header", ".", "Type", ".", "v", "[", "0", "]", "==", "ETHER_ARP", ")", ")", ")", "{", "*", "type", "=", "header", ".", "Type", ".", "v", "[", "0", "]", ";", "}", "g_wasDiscarded", "=", "FALSE", ";", "return", "TRUE", ";", "}" ]

[ "Function", ":", "BOOL", "MACGetHeader", "(", "MAC_ADDR", "*", "remote", "BYTE", "*", "type", ")", "PreCondition", ":", "None" ]

[ "/* if we currently have a rx buffer mounted then we need to save it */", "/* save state of Rx RAW window */", "/* RAW 0 is now unmounted (and available) */", "/* read preamble header */", "/* as a sanity check verify that the expected bytes contain the SNAP header */", "/* if a vendor proprietary packet, throw away */", "// Make absolutely certain that any previous packet was discarded", "/* we can flush any saved RAW state now by saving and restoring the current rx buffer. */", "// set RAW pointer to 802.11 payload", "///// RawWindowReady[RAW_RX_ID] = TRUE;", "/////SetRawWindowState(RAW_RX_ID, WF_RAW_DATA_MOUNTED); ", "// The EtherType field, like most items transmitted on the Ethernet medium", "// are in big endian.", "// Return the Ethernet frame's Source MAC address field to the caller", "// This parameter is useful for replying to requests without requiring an", "// ARP cycle.", "// Return a simplified version of the EtherType field to the caller", "// Mark this packet as discardable" ]

[ { "param": "remote", "type": "MAC_ADDR" }, { "param": "type", "type": "BYTE" } ]

[ "BSD-3-Clause" ]

[ "*", "remote", ":", "Pointer", "to", "memory", "which", "contains", "the", "destination", "MAC", "address", "(", "6", "bytes", ")", "type", ":", "The", "constant", "ETHER_ARP", "or", "ETHER_IP", "defining", "which", "value", "to", "write", "into", "the", "Ethernet", "header", "'", "s", "type", "field", ".", "dataLen", ":", "Length", "of", "the", "Ethernet", "data", "payload", "None", "Side", "Effects", ":", "None", "None", "Because", "of", "the", "dataLen", "parameter", "it", "is", "probably", "advantagous", "to", "call", "this", "function", "immediately", "before", "transmitting", "a", "packet", "rather", "than", "initially", "when", "the", "packet", "is", "first", "created", ".", "The", "order", "in", "which", "the", "packet", "is", "constructed", "(", "header", "first", "or", "data", "first", ")", "is", "not", "important", "." ]

[ "void", "MACPutHeader", "(", "MAC_ADDR", "*", "remote", ",", "BYTE", "type", ",", "WORD", "dataLen", ")", "{", "UINT8", "buf", "[", "14", "]", ";", "g_txBufferFlushed", "=", "FALSE", ";", "g_txPacketLength", "=", "dataLen", "+", "(", "WORD", ")", "sizeof", "(", "ETHER_HEADER", ")", "+", "WF_TX_PREAMBLE_SIZE", ";", "g_encIndex", "[", "ENC_WT_PTR_ID", "]", "=", "TXSTART", "+", "WF_TX_PREAMBLE_SIZE", ";", "SyncENCPtrRAWState", "(", "ENC_WT_PTR_ID", ")", ";", "memcpy", "(", "&", "buf", "[", "0", "]", ",", "(", "void", "*", ")", "remote", ",", "sizeof", "(", "*", "remote", ")", ")", ";", "buf", "[", "6", "]", "=", "SNAP_VAL", ";", "buf", "[", "7", "]", "=", "SNAP_VAL", ";", "buf", "[", "8", "]", "=", "SNAP_CTRL_VAL", ";", "buf", "[", "9", "]", "=", "SNAP_TYPE_VAL", ";", "buf", "[", "10", "]", "=", "SNAP_TYPE_VAL", ";", "buf", "[", "11", "]", "=", "SNAP_TYPE_VAL", ";", "buf", "[", "12", "]", "=", "0x08", ";", "buf", "[", "13", "]", "=", "(", "type", "==", "MAC_IP", ")", "?", "ETHER_IP", ":", "ETHER_ARP", ";", "MACPutArray", "(", "(", "BYTE", "*", ")", "buf", ",", "sizeof", "(", "buf", ")", ")", ";", "}" ]

[ "Function", ":", "void", "MACPutHeader", "(", "MAC_ADDR", "*", "remote", "BYTE", "type", "WORD", "dataLen", ")", "PreCondition", ":", "MACIsTxReady", "()", "must", "return", "TRUE", "." ]

[ "// Set the SPI write pointer to the beginning of the transmit buffer (post WF_TX_PREAMBLE_SIZE)", "/* write the Ethernet destination address to buffer (6 bytes) */", "/* write snap header to buffer (6 bytes) */", "/* Write the appropriate Ethernet Type WORD for the protocol being used */", "/* write buffer to RAW window */" ]

[ { "param": "remote", "type": "MAC_ADDR" }, { "param": "type", "type": "BYTE" }, { "param": "dataLen", "type": "WORD" } ]

[ "BSD-3-Clause" ]

[ "None", "None", "Side", "Effects", ":", "None", "MACFlush", "causes", "the", "current", "TX", "packet", "to", "be", "sent", "out", "on", "the", "Ethernet", "medium", ".", "The", "hardware", "MAC", "will", "take", "control", "and", "handle", "CRC", "generation", "collision", "retransmission", "and", "other", "details", ".", "After", "transmission", "completes", "(", "MACIsTxReady", "()", "returns", "TRUE", ")", "the", "packet", "can", "be", "modified", "and", "transmitted", "again", "by", "calling", "MACFlush", "()", "again", ".", "Until", "MACPutHeader", "()", "or", "MACPut", "()", "is", "called", "(", "in", "the", "TX", "data", "area", ")", "the", "data", "in", "the", "TX", "buffer", "will", "not", "be", "corrupted", "." ]

[ "void", "MACFlush", "(", "void", ")", "{", "WF_ASSERT", "(", "RawWindowReady", "[", "RAW_TX_ID", "]", ")", ";", "WF_ASSERT", "(", "!", "g_txBufferFlushed", ")", ";", "g_txBufferFlushed", "=", "TRUE", ";", "if", "(", "GetRawWindowState", "(", "RAW_TX_ID", ")", "!=", "WF_RAW_DATA_MOUNTED", ")", "{", "PopRawWindow", "(", "RAW_TX_ID", ")", ";", "}", "WF_ASSERT", "(", "g_txPacketLength", "!=", "0", ")", ";", "EnsureWFisAwake", "(", ")", ";", "SendRAWDataFrame", "(", "g_txPacketLength", ")", ";", "if", "(", "g_encPtrRAWId", "[", "ENC_RD_PTR_ID", "]", "==", "RAW_TX_ID", ")", "{", "g_encPtrRAWId", "[", "ENC_RD_PTR_ID", "]", "=", "RAW_INVALID_ID", ";", "}", "if", "(", "g_encPtrRAWId", "[", "ENC_WT_PTR_ID", "]", "==", "RAW_TX_ID", ")", "{", "g_encPtrRAWId", "[", "ENC_WT_PTR_ID", "]", "=", "RAW_INVALID_ID", ";", "}", "}" ]

[ "Function", ":", "void", "MACFlush", "(", "void", ")", "PreCondition", ":", "A", "packet", "has", "been", "created", "by", "calling", "MACPut", "()", "and", "MACPutHeader", "()", "." ]

[ "/* this function should not be called if no tx buffer is ready to transmit */", "/* this function should not be called after the current tx buffer has been transmitted */", "/* If the RAW engine is not currently mounted */", "/* then it must have been saved, so pop it */", "// at this point the txbuffer should be mounted and ready to go", "/* can't send a tx packet of 0 bytes! */", "/* Ensure the MRF24W is awake (only applies if PS-Poll was enabled) */", "// make sure to de-sync any affected pointers" ]

[]

[ "BSD-3-Clause" ]

[ "void", "MACSetReadPtrInRx", "(", "WORD", "offset", ")", "PreCondition", ":", "A", "packet", "has", "been", "obtained", "by", "calling", "MACGetHeader", "()", "and", "getting", "a", "TRUE", "result", ".", "WORD", "specifying", "how", "many", "bytes", "beyond", "the", "Ethernet", "header", "'", "s", "type", "field", "to", "relocate", "the", "SPI", "read", "pointer", ".", "None", "Side", "Effects", ":", "None", "SPI", "read", "pointer", "are", "updated", ".", "All", "calls", "to", "MACGet", "()", "and", "MACGetArray", "()", "will", "use", "these", "new", "values", ".", "RXSTOP", "must", "be", "statically", "defined", "as", "being", ">", "RXSTART", "for", "this", "function", "to", "work", "correctly", ".", "In", "other", "words", "do", "not", "define", "an", "RX", "buffer", "which", "spans", "the", "0x1FFF", "-", ">", "0x0000", "memory", "boundary", "." ]

[ "void", "MACSetReadPtrInRx", "(", "WORD", "offset", ")", "{", "g_encIndex", "[", "ENC_RD_PTR_ID", "]", "=", "RXSTART", "+", "sizeof", "(", "ENC_PREAMBLE", ")", "+", "offset", ";", "SyncENCPtrRAWState", "(", "ENC_RD_PTR_ID", ")", ";", "}" ]

[ "Function", ":", "void", "MACSetReadPtrInRx", "(", "WORD", "offset", ")", "PreCondition", ":", "A", "packet", "has", "been", "obtained", "by", "calling", "MACGetHeader", "()", "and", "getting", "a", "TRUE", "result", "." ]

[]

[ { "param": "offset", "type": "WORD" } ]

[ "BSD-3-Clause" ]

[ "offset", "-", "Number", "of", "bytes", "beyond", "the", "beginning", "of", "the", "Ethernet", "data", "(", "first", "byte", "after", "the", "type", "field", ")", "where", "the", "checksum", "should", "begin", "len", "-", "Total", "number", "of", "bytes", "to", "include", "in", "the", "checksum", "16", "-", "bit", "checksum", "as", "defined", "by", "RFC", "793", ".", "Side", "Effects", ":", "None", "This", "function", "performs", "a", "checksum", "calculation", "in", "the", "MAC", "buffer", "itself", "None" ]

[ "WORD", "MACCalcRxChecksum", "(", "WORD", "offset", ",", "WORD", "len", ")", "{", "WORD", "temp", ";", "UINT16", "rdSave", ";", "temp", "=", "RXSTART", "+", "sizeof", "(", "ENC_PREAMBLE", ")", "+", "offset", ";", "rdSave", "=", "g_encIndex", "[", "ENC_RD_PTR_ID", "]", ";", "g_encIndex", "[", "ENC_RD_PTR_ID", "]", "=", "temp", ";", "SyncENCPtrRAWState", "(", "ENC_RD_PTR_ID", ")", ";", "temp", "=", "CalcIPBufferChecksum", "(", "len", ")", ";", "g_encIndex", "[", "ENC_RD_PTR_ID", "]", "=", "rdSave", ";", "SyncENCPtrRAWState", "(", "ENC_RD_PTR_ID", ")", ";", "return", "temp", ";", "}" ]

[ "Function", ":", "WORD", "MACCalcRxChecksum", "(", "WORD", "offset", "WORD", "len", ")", "PreCondition", ":", "None" ]

[ "// Add the offset requested by firmware plus the Ethernet header" ]

[ { "param": "offset", "type": "WORD" }, { "param": "len", "type": "WORD" } ]

[ "BSD-3-Clause" ]

[ "Destination", "address", "in", "the", "Ethernet", "memory", "to", "copy", "to", ".", "If", "the", "MSb", "is", "set", "the", "current", "EWRPT", "value", "will", "be", "used", "instead", ".", "sourceAddr", ":", "Source", "address", "to", "read", "from", ".", "If", "the", "MSb", "is", "set", "the", "current", "ERDPT", "value", "will", "be", "used", "instead", ".", "len", ":", "Number", "of", "bytes", "to", "copy", "Byte", "read", "from", "the", "MRF24W", "'", "s", "RAM", "Side", "Effects", ":", "None", "Bytes", "are", "asynchrnously", "transfered", "within", "the", "buffer", ".", "Call", "MACIsMemCopyDone", "()", "to", "see", "when", "the", "transfer", "is", "complete", ".", "If", "a", "prior", "transfer", "is", "already", "in", "progress", "prior", "to", "calling", "this", "function", "this", "function", "will", "block", "until", "it", "can", "start", "this", "transfer", ".", "If", "a", "negative", "value", "is", "used", "for", "the", "sourceAddr", "or", "destAddr", "parameters", "then", "that", "pointer", "will", "get", "updated", "with", "the", "next", "address", "after", "the", "read", "or", "write", "." ]

[ "void", "MACMemCopyAsync", "(", "PTR_BASE", "destAddr", ",", "PTR_BASE", "sourceAddr", ",", "WORD", "len", ")", "{", "UINT16", "readSave", "=", "0", ",", "writeSave", "=", "0", ";", "BOOL", "updateWritePointer", ";", "BOOL", "updateReadPointer", ";", "UINT8", "rawScratchId", "=", "0xff", ";", "UINT8", "copyBuf", "[", "8", "]", ";", "UINT16", "writeIndex", ",", "readIndex", ";", "UINT16", "bytesLeft", ";", "UINT16", "origRawIndex", ";", "EnsureWFisAwake", "(", ")", ";", "if", "(", "(", "(", "WORD_VAL", "*", ")", "&", "destAddr", ")", "->", "bits", ".", "b15", ")", "{", "updateWritePointer", "=", "TRUE", ";", "destAddr", "=", "g_encIndex", "[", "ENC_WT_PTR_ID", "]", ";", "if", "(", "g_encPtrRAWId", "[", "ENC_WT_PTR_ID", "]", "==", "RAW_INVALID_ID", ")", "{", "SyncENCPtrRAWState", "(", "ENC_WT_PTR_ID", ")", ";", "}", "}", "else", "{", "updateWritePointer", "=", "FALSE", ";", "writeSave", "=", "g_encIndex", "[", "ENC_WT_PTR_ID", "]", ";", "g_encIndex", "[", "ENC_WT_PTR_ID", "]", "=", "destAddr", ";", "SyncENCPtrRAWState", "(", "ENC_WT_PTR_ID", ")", ";", "}", "if", "(", "(", "(", "WORD_VAL", "*", ")", "&", "sourceAddr", ")", "->", "bits", ".", "b15", ")", "{", "updateReadPointer", "=", "TRUE", ";", "sourceAddr", "=", "g_encIndex", "[", "ENC_RD_PTR_ID", "]", ";", "if", "(", "g_encPtrRAWId", "[", "ENC_RD_PTR_ID", "]", "==", "RAW_INVALID_ID", ")", "{", "SyncENCPtrRAWState", "(", "ENC_RD_PTR_ID", ")", ";", "}", "}", "else", "{", "updateReadPointer", "=", "FALSE", ";", "readSave", "=", "g_encIndex", "[", "ENC_RD_PTR_ID", "]", ";", "g_encIndex", "[", "ENC_RD_PTR_ID", "]", "=", "sourceAddr", ";", "SyncENCPtrRAWState", "(", "ENC_RD_PTR_ID", ")", ";", "}", "if", "(", "(", "len", ">", "0u", ")", "&&", "(", "destAddr", ">=", "BASE_SCRATCH_ADDR", ")", "&&", "(", "sourceAddr", ">=", "BASE_SCRATCH_ADDR", ")", ")", "{", "bytesLeft", "=", "len", ";", "if", "(", "GetRawWindowState", "(", "RAW_RX_ID", ")", "==", "WF_SCRATCH_MOUNTED", ")", "{", "rawScratchId", "=", "RAW_RX_ID", ";", "}", "else", "if", "(", "GetRawWindowState", "(", "RAW_TX_ID", ")", "==", "WF_SCRATCH_MOUNTED", ")", "{", "rawScratchId", "=", "RAW_TX_ID", ";", "}", "else", "{", "WF_ASSERT", "(", "FALSE", ")", ";", "}", "origRawIndex", "=", "RawGetIndex", "(", "rawScratchId", ")", ";", "if", "(", "(", "(", "sourceAddr", "+", "len", ")", "<=", "destAddr", ")", "||", "(", "(", "destAddr", "+", "len", ")", "<=", "sourceAddr", ")", "||", "(", "destAddr", "<", "sourceAddr", ")", ")", "{", "readIndex", "=", "sourceAddr", "-", "ENC_TCB_BUF_TO_RAW_SCRATCH_BUF_ADJUSTMENT", ";", "writeIndex", "=", "destAddr", "-", "ENC_TCB_BUF_TO_RAW_SCRATCH_BUF_ADJUSTMENT", ";", "while", "(", "bytesLeft", ">", "0", ")", "{", "if", "(", "bytesLeft", ">=", "sizeof", "(", "copyBuf", ")", ")", "{", "RawRead", "(", "rawScratchId", ",", "readIndex", ",", "sizeof", "(", "copyBuf", ")", ",", "copyBuf", ")", ";", "RawWrite", "(", "rawScratchId", ",", "writeIndex", ",", "sizeof", "(", "copyBuf", ")", ",", "copyBuf", ")", ";", "readIndex", "+=", "sizeof", "(", "copyBuf", ")", ";", "writeIndex", "+=", "sizeof", "(", "copyBuf", ")", ";", "bytesLeft", "-=", "sizeof", "(", "copyBuf", ")", ";", "}", "else", "{", "if", "(", "bytesLeft", ">", "0", ")", "{", "RawRead", "(", "rawScratchId", ",", "readIndex", ",", "bytesLeft", ",", "copyBuf", ")", ";", "RawWrite", "(", "rawScratchId", ",", "writeIndex", ",", "bytesLeft", ",", "copyBuf", ")", ";", "bytesLeft", "=", "0", ";", "}", "}", "}", "}", "else", "if", "(", "destAddr", ">", "sourceAddr", ")", "{", "readIndex", "=", "sourceAddr", "-", "ENC_TCB_BUF_TO_RAW_SCRATCH_BUF_ADJUSTMENT", "+", "len", "-", "1", ";", "writeIndex", "=", "destAddr", "-", "ENC_TCB_BUF_TO_RAW_SCRATCH_BUF_ADJUSTMENT", "+", "len", "-", "1", ";", "while", "(", "bytesLeft", ">", "0", ")", "{", "if", "(", "bytesLeft", ">=", "sizeof", "(", "copyBuf", ")", ")", "{", "RawRead", "(", "rawScratchId", ",", "readIndex", "-", "sizeof", "(", "copyBuf", ")", "+", "1", ",", "sizeof", "(", "copyBuf", ")", ",", "copyBuf", ")", ";", "RawWrite", "(", "rawScratchId", ",", "writeIndex", "-", "sizeof", "(", "copyBuf", ")", "+", "1", ",", "sizeof", "(", "copyBuf", ")", ",", "copyBuf", ")", ";", "readIndex", "-=", "sizeof", "(", "copyBuf", ")", ";", "writeIndex", "-=", "sizeof", "(", "copyBuf", ")", ";", "bytesLeft", "-=", "sizeof", "(", "copyBuf", ")", ";", "}", "else", "{", "if", "(", "bytesLeft", ">", "0", ")", "{", "RawRead", "(", "rawScratchId", ",", "readIndex", "-", "bytesLeft", "+", "1", ",", "bytesLeft", "-", "1", ",", "copyBuf", ")", ";", "RawWrite", "(", "rawScratchId", ",", "writeIndex", "-", "bytesLeft", "+", "1", ",", "bytesLeft", "-", "1", ",", "copyBuf", ")", ";", "bytesLeft", "=", "0", ";", "}", "}", "}", "}", "RawSetIndex", "(", "rawScratchId", ",", "origRawIndex", ")", ";", "}", "else", "if", "(", "len", ">", "0", ")", "{", "if", "(", "(", "g_encPtrRAWId", "[", "ENC_RD_PTR_ID", "]", "==", "RAW_INVALID_ID", ")", "||", "(", "g_encPtrRAWId", "[", "ENC_WT_PTR_ID", "]", "==", "RAW_INVALID_ID", ")", ")", "{", "WF_ASSERT", "(", "FALSE", ")", ";", "}", "RawToRawCopy", "(", "g_encPtrRAWId", "[", "ENC_WT_PTR_ID", "]", ",", "len", ")", ";", "}", "if", "(", "!", "updateReadPointer", ")", "{", "g_encIndex", "[", "ENC_RD_PTR_ID", "]", "=", "readSave", ";", "SyncENCPtrRAWState", "(", "ENC_RD_PTR_ID", ")", ";", "}", "if", "(", "!", "updateWritePointer", ")", "{", "g_encIndex", "[", "ENC_WT_PTR_ID", "]", "=", "writeSave", ";", "SyncENCPtrRAWState", "(", "ENC_WT_PTR_ID", ")", ";", "}", "}" ]

[ "Function", ":", "void", "MACMemCopyAsync", "(", "WORD", "destAddr", "WORD", "sourceAddr", "WORD", "len", ")", "PreCondition", ":", "SPI", "bus", "must", "be", "initialized", "(", "done", "in", "MACInit", "()", ")", "." ]

[ "/* garbage value to avoid compiler warning */", "// if copying bytes from TCB to TCB", "// This is a special case because we cannot do a RAW copy within the same RAW window", "// but we can easily copy Scratch data from one section of Scratch to another section of Scratch.", "/*BASE_TCB_ADDR*/", "/*BASE_TCB_ADDR*/", "// if Raw Rx window mounted to scratch", "// else if Raw Tx window mounted to scratch", "/* this should never happen (that can't mount scratch on either RAW window) */", "// save the current RAW index in this scratch window", "// If TCB src block does not overlap TCB dest block, or if destAddr > sourceAddr.", "// We can do a forward copy.", "// end of source before dest (no overlap)", "// end of dest before source (no overlap)", "// dest before source (overlap) ", "// map read index from TCB address to Scratch Index", "// if a full copyBuf worth of bytes to copy", "// index to next block in source and dest", "// else less than a full copyBuf left to copy", "// end while", "// else start of TCB dest block within TCB src block --> destAddr > sourcAddr", "// Do a backward copy.", "// map read index from TCB address to Scratch Index", "// if a full copyBuf worth of bytes to copy", "// index to next block in source and dest", "// else less than a full copyBuf left to copy", "// end while ", "// restore raw index to where it was when this function was called", "// else if not copying from TCB to TCB and there is at least one byte to copy", "// Check if app is trying to copy data within same RAW window (can't do that)" ]

[ { "param": "destAddr", "type": "PTR_BASE" }, { "param": "sourceAddr", "type": "PTR_BASE" }, { "param": "len", "type": "WORD" } ]

[ "BSD-3-Clause" ]

[ "BYTE", "MACGet", "()", "PreCondition", ":", "SPI", "bus", "must", "be", "initialized", "(", "done", "in", "MACInit", "()", ")", ".", "ERDPT", "must", "point", "to", "the", "place", "to", "read", "from", ".", "None", "Byte", "read", "from", "the", "MRF24W", "'", "s", "RAM", "Side", "Effects", ":", "None", "MACGet", "returns", "the", "byte", "pointed", "to", "by", "ERDPT", "and", "increments", "ERDPT", "so", "MACGet", "()", "can", "be", "called", "again", ".", "The", "increment", "will", "follow", "the", "receive", "buffer", "wrapping", "boundary", ".", "None" ]

[ "BYTE", "MACGet", "(", ")", "{", "BYTE", "result", ";", "if", "(", "g_encPtrRAWId", "[", "ENC_RD_PTR_ID", "]", "==", "RAW_INVALID_ID", ")", "{", "SyncENCPtrRAWState", "(", "ENC_RD_PTR_ID", ")", ";", "}", "RawGetByte", "(", "g_encPtrRAWId", "[", "ENC_RD_PTR_ID", "]", ",", "&", "result", ",", "1", ")", ";", "g_encIndex", "[", "ENC_RD_PTR_ID", "]", "+=", "1", ";", "return", "result", ";", "}" ]

[ "Function", ":", "BYTE", "MACGet", "()", "PreCondition", ":", "SPI", "bus", "must", "be", "initialized", "(", "done", "in", "MACInit", "()", ")", "." ]

[]

[]

[ "BSD-3-Clause" ]

[ "WORD", "MACGetArray", "(", "BYTE", "*", "val", "WORD", "len", ")", "PreCondition", ":", "SPI", "bus", "must", "be", "initialized", "(", "done", "in", "MACInit", "()", ")", ".", "ERDPT", "must", "point", "to", "the", "place", "to", "read", "from", ".", "*", "val", ":", "Pointer", "to", "storage", "location", "len", ":", "Number", "of", "bytes", "to", "read", "from", "the", "data", "buffer", ".", "Byte", "(", "s", ")", "of", "data", "read", "from", "the", "data", "buffer", ".", "Side", "Effects", ":", "None", "Burst", "reads", "several", "sequential", "bytes", "from", "the", "data", "buffer", "and", "places", "them", "into", "local", "memory", ".", "With", "SPI", "burst", "support", "it", "performs", "much", "faster", "than", "multiple", "MACGet", "()", "calls", ".", "ERDPT", "is", "incremented", "after", "each", "byte", "following", "the", "same", "rules", "as", "MACGet", "()", ".", "None" ]

[ "WORD", "MACGetArray", "(", "BYTE", "*", "val", ",", "WORD", "len", ")", "{", "WORD", "i", "=", "0", ";", "UINT8", "byte", ";", "if", "(", "g_encPtrRAWId", "[", "ENC_RD_PTR_ID", "]", "==", "RAW_INVALID_ID", ")", "{", "SyncENCPtrRAWState", "(", "ENC_RD_PTR_ID", ")", ";", "}", "if", "(", "val", ")", "{", "RawGetByte", "(", "g_encPtrRAWId", "[", "ENC_RD_PTR_ID", "]", ",", "val", ",", "len", ")", ";", "}", "else", "{", "while", "(", "i", "<", "len", ")", "{", "RawGetByte", "(", "g_encPtrRAWId", "[", "ENC_RD_PTR_ID", "]", ",", "&", "byte", ",", "1", ")", ";", "i", "++", ";", "}", "}", "g_encIndex", "[", "ENC_RD_PTR_ID", "]", "+=", "len", ";", "return", "len", ";", "}" ]

[ "Function", ":", "WORD", "MACGetArray", "(", "BYTE", "*", "val", "WORD", "len", ")", "PreCondition", ":", "SPI", "bus", "must", "be", "initialized", "(", "done", "in", "MACInit", "()", ")", "." ]

[ "// Read the data" ]

[ { "param": "val", "type": "BYTE" }, { "param": "len", "type": "WORD" } ]

[ "BSD-3-Clause" ]

[ "void", "MACPutArray", "(", "BYTE", "*", "val", "WORD", "len", ")", "PreCondition", ":", "SPI", "bus", "must", "be", "initialized", "(", "done", "in", "MACInit", "()", ")", ".", "EWRPT", "must", "point", "to", "the", "location", "to", "begin", "writing", ".", "*", "val", ":", "Pointer", "to", "source", "of", "bytes", "to", "copy", ".", "len", ":", "Number", "of", "bytes", "to", "write", "to", "the", "data", "buffer", ".", "None", "Side", "Effects", ":", "None", "MACPutArray", "writes", "several", "sequential", "bytes", "to", "the", "MRF24W", "RAM", ".", "It", "performs", "faster", "than", "multiple", "MACPut", "()", "calls", ".", "EWRPT", "is", "incremented", "by", "len", ".", "None" ]

[ "void", "MACPutArray", "(", "BYTE", "*", "val", ",", "WORD", "len", ")", "{", "if", "(", "g_encPtrRAWId", "[", "ENC_WT_PTR_ID", "]", "==", "RAW_INVALID_ID", ")", "{", "SyncENCPtrRAWState", "(", "ENC_WT_PTR_ID", ")", ";", "}", "RawSetByte", "(", "g_encPtrRAWId", "[", "ENC_WT_PTR_ID", "]", ",", "val", ",", "len", ")", ";", "g_encIndex", "[", "ENC_WT_PTR_ID", "]", "+=", "len", ";", "}" ]

[ "Function", ":", "void", "MACPutArray", "(", "BYTE", "*", "val", "WORD", "len", ")", "PreCondition", ":", "SPI", "bus", "must", "be", "initialized", "(", "done", "in", "MACInit", "()", ")", "." ]

[]

[ { "param": "val", "type": "BYTE" }, { "param": "len", "type": "WORD" } ]

[ "BSD-3-Clause" ]

[ "Calculates", "an", "IP", "checksum", "in", "the", "MAC", "buffer", "itself", ".", "This", "function", "calculates", "an", "IP", "checksum", "over", "an", "array", "of", "input", "data", "existing", "in", "the", "MAC", "buffer", ".", "The", "checksum", "is", "the", "16", "-", "bit", "one", "'", "s", "complement", "of", "one", "'", "s", "complement", "sum", "of", "all", "words", "in", "the", "data", "(", "with", "zero", "-", "padding", "if", "an", "odd", "number", "of", "bytes", "are", "summed", ")", ".", "This", "checksum", "is", "defined", "in", "RFC", "793", ".", "TCP", "is", "initialized", "and", "the", "MAC", "buffer", "pointer", "is", "set", "to", "the", "start", "of", "the", "buffer", ".", "number", "of", "bytes", "to", "be", "checksummed", "The", "calculated", "checksum", ".", "All", "Microchip", "MACs", "should", "perform", "this", "function", "in", "hardware", "." ]

[ "WORD", "CalcIPBufferChecksum", "(", "WORD", "len", ")", "{", "DWORD_VAL", "Checksum", ";", "BYTE", "DataBuffer", "[", "20", "]", ";", "WORD", "ChunkLen", ";", "WORD", "*", "DataPtr", ";", "Checksum", ".", "w", "[", "0", "]", "=", "0", ";", "Checksum", ".", "w", "[", "1", "]", "=", "0", ";", "while", "(", "len", ")", "{", "ChunkLen", "=", "len", ">", "sizeof", "(", "DataBuffer", ")", "?", "sizeof", "(", "DataBuffer", ")", ":", "len", ";", "MACGetArray", "(", "DataBuffer", ",", "ChunkLen", ")", ";", "len", "-=", "ChunkLen", ";", "if", "(", "(", "(", "WORD_VAL", "*", ")", "&", "ChunkLen", ")", "->", "bits", ".", "b0", ")", "{", "DataBuffer", "[", "ChunkLen", "]", "=", "0x00", ";", "ChunkLen", "++", ";", "}", "DataPtr", "=", "(", "WORD", "*", ")", "&", "DataBuffer", "[", "0", "]", ";", "while", "(", "ChunkLen", ")", "{", "Checksum", ".", "Val", "+=", "*", "DataPtr", "++", ";", "ChunkLen", "-=", "2", ";", "}", "}", "Checksum", ".", "Val", "=", "(", "DWORD", ")", "Checksum", ".", "w", "[", "0", "]", "+", "(", "DWORD", ")", "Checksum", ".", "w", "[", "1", "]", ";", "Checksum", ".", "w", "[", "0", "]", "+=", "Checksum", ".", "w", "[", "1", "]", ";", "Checksum", ".", "w", "[", "0", "]", "=", "~", "Checksum", ".", "w", "[", "0", "]", ";", "return", "Checksum", ".", "w", "[", "0", "]", ";", "}" ]

[ "Function", ":", "WORD", "CalcIPBufferChecksum", "(", "WORD", "len", ")" ]

[ "// Must be an even size", "// Obtain a chunk of data (less SPI overhead compared ", "// to requesting one byte at a time)", "// Take care of a last odd numbered data byte", "// Calculate the checksum over this chunk", "// Do an end-around carry (one's complement arrithmatic)", "// Do another end-around carry in case if the prior add ", "// caused a carry out", "// Return the resulting checksum" ]

[ { "param": "len", "type": "WORD" } ]

[ "BSD-3-Clause" ]

[ "Tests", "the", "performance", "of", "the", "TCP", "module", ".", "This", "function", "calls", "both", "TCPTXPerformanceTask", "and", "TCPRXPerformanceTask", "to", "perform", "the", "performance", "task", "functions", ".", "Refer", "to", "the", "documentation", "for", "each", "of", "those", "functions", "for", "details", ".", "TCP", "is", "initialized", ".", "None", "None" ]

[ "void", "TCPPerformanceTask", "(", "void", ")", "{", "TCPTXPerformanceTask", "(", ")", ";", "TCPRXPerformanceTask", "(", ")", ";", "}" ]

[ "Function", ":", "void", "TCPPerformanceTask", "(", "void", ")" ]

[]

[]

[ "BSD-3-Clause" ]

[ "None", "Determines", "which", "command", "has", "been", "received", "and", "processes", "it", "." ]

[ "void", "process_cmd", "(", "void", ")", "{", "BOOL", "new_arg", ";", "UINT8", "i", ";", "g_ConsoleContext", ".", "argc", "=", "0", ";", "new_arg", "=", "TRUE", ";", "TokenizeCmdLine", "(", "g_ConsoleContext", ".", "rxBuf", ")", ";", "if", "(", "g_ConsoleContext", ".", "argc", "==", "0u", ")", "{", "return", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "strlen", "(", "(", "char", "*", ")", "g_ConsoleContext", ".", "argv", "[", "0", "]", ")", ";", "++", "i", ")", "{", "g_ConsoleContext", ".", "argv", "[", "0", "]", "[", "i", "]", "=", "tolower", "(", "g_ConsoleContext", ".", "argv", "[", "0", "]", "[", "i", "]", ")", ";", "}", "if", "(", "IS_ECHO_ON", "(", ")", ")", "{", "putrsUART", "(", "\"", "\\n", "\\r", "\"", ")", ";", "}", "switch", "(", "GetCmdId", "(", ")", ")", "{", "case", "HELP_MSG", ":", "do_help_msg", "(", ")", ";", "WFConsoleSetMsgFlag", "(", ")", ";", "break", ";", "case", "GET_WF_VERSION_MSG", ":", "do_get_wfver_cmd", "(", ")", ";", "break", ";", "case", "RESET_HOST", ":", "Reset", "(", ")", ";", "break", ";", "case", "CLEAR_SCREEN_MSG", ":", "do_cls_cmd", "(", ")", ";", "break", ";", "#if", "defined", "(", "MRF24WG", ")", "\n", "case", "WPS_PIN_MSG", ":", "do_wps_pin_cmd", "(", ")", ";", "break", ";", "case", "WPS_PUSHBUTTON_MSG", ":", "do_wps_push_button_cmd", "(", ")", ";", "break", ";", "case", "WPS_GET_CREDENTIALS_MSG", ":", "do_wps_get_credentials_cmd", "(", ")", ";", "break", ";", "#endif", "#if", "defined", "(", "WF_CONSOLE_IFCFGUTIL", ")", "\n", "case", "IFCONFIG_MSG", ":", "do_ifconfig_cmd", "(", ")", ";", "break", ";", "case", "IWCONFIG_MSG", ":", "do_iwconfig_cmd", "(", ")", ";", "break", ";", "case", "IWPRIV_MSG", ":", "do_iwpriv_cmd", "(", ")", ";", "break", ";", "#endif", "case", "PING_MSG", ":", "do_ping_cmd", "(", ")", ";", "break", ";", "#if", "defined", "(", "STACK_USE_CERTIFICATE_DEBUG", ")", "\n", "case", "KILLPING_MSG", ":", "do_KillPing_cmd", "(", ")", ";", "break", ";", "#endif", "default", ":", "WFConsoleSetMsgFlag", "(", ")", ";", "break", ";", "}", "}" ]

[ "FUNCTION", ":", "process_cmd", "RETURNS", ":", "None" ]

[ "// Get pointers to each token in the command string", "// if command line nothing but white kWFSpace or a linefeed", "// nothing to do", "// change the command itself (token[0]) to lower case", "/* MRF24WG */", "// WF_CONSOLE_IFCFGUTIL" ]

[]

[ "BSD-3-Clause" ]

[ "Initializes", "the", "Tick", "manager", "module", ".", "Configures", "the", "Tick", "module", "and", "any", "necessary", "hardware", "resources", ".", "None", "None", "None", "This", "function", "is", "called", "only", "one", "during", "lifetime", "of", "the", "application", "." ]

[ "void", "TickInit", "(", "void", ")", "{", "#if", "defined", "(", "__18CXX", ")", "\n", "TMR0H", "=", "0", ";", "TMR0L", "=", "0", ";", "INTCON2bits", ".", "TMR0IP", "=", "0", ";", "INTCONbits", ".", "TMR0IF", "=", "0", ";", "INTCONbits", ".", "TMR0IE", "=", "1", ";", "T0CON", "=", "0x87", ";", "#else", "T1CONbits", ".", "TCKPS", "=", "3", ";", "PR1", "=", "0xFFFF", ";", "TMR1", "=", "0", ";", "#if", "defined", "(", "__C30__", ")", "\n", "IPC0bits", ".", "T1IP", "=", "2", ";", "IFS0bits", ".", "T1IF", "=", "0", ";", "IEC0bits", ".", "T1IE", "=", "1", ";", "#else", "IPC1bits", ".", "T1IP", "=", "2", ";", "IFS0CLR", "=", "_IFS0_T1IF_MASK", ";", "IEC0SET", "=", "_IEC0_T1IE_MASK", ";", "#endif", "T1CONbits", ".", "TON", "=", "1", ";", "#endif", "}" ]

[ "Function", ":", "void", "TickInit", "(", "void", ")" ]

[ "// Use Timer0 for 8 bit processors", "// Initialize the time", "// Set up the timer interrupt", "// Low priority", "// Enable interrupt", "// Timer0 on, 16-bit, internal timer, 1:256 prescalar", "// Use Timer 1 for 16-bit and 32-bit processors", "// 1:256 prescale", "// Base", "// Clear counter", "// Enable timer interrupt", "// Interrupt priority 2 (low)", "// Interrupt priority 2 (low)", "// Start timer" ]

[]

[ "BSD-3-Clause" ]

[ "Obtains", "the", "current", "Tick", "value", ".", "This", "function", "retrieves", "the", "current", "Tick", "value", "allowing", "timing", "and", "measurement", "code", "to", "be", "written", "in", "a", "non", "-", "blocking", "fashion", ".", "This", "function", "retrieves", "the", "least", "significant", "32", "bits", "of", "the", "internal", "tick", "counter", "and", "is", "useful", "for", "measuring", "time", "increments", "ranging", "from", "a", "few", "microseconds", "to", "a", "few", "hours", ".", "Use", "TickGetDiv256", "or", "TickGetDiv64K", "for", "longer", "periods", "of", "time", ".", "None", "None", "Lower", "32", "bits", "of", "the", "current", "Tick", "value", "." ]

[ "DWORD", "TickGet", "(", "void", ")", "{", "DWORD", "dw", ";", "GetTickCopy", "(", ")", ";", "(", "(", "BYTE", "*", ")", "&", "dw", ")", "[", "0", "]", "=", "vTickReading", "[", "0", "]", ";", "(", "(", "BYTE", "*", ")", "&", "dw", ")", "[", "1", "]", "=", "vTickReading", "[", "1", "]", ";", "(", "(", "BYTE", "*", ")", "&", "dw", ")", "[", "2", "]", "=", "vTickReading", "[", "2", "]", ";", "(", "(", "BYTE", "*", ")", "&", "dw", ")", "[", "3", "]", "=", "vTickReading", "[", "3", "]", ";", "return", "dw", ";", "}" ]

[ "Function", ":", "DWORD", "TickGet", "(", "void", ")" ]

[ "// Note: This copy must be done one ", "// byte at a time to prevent misaligned ", "// memory reads, which will reset the PIC." ]

[]

[ "BSD-3-Clause" ]

[ "Obtains", "the", "current", "Tick", "value", "divided", "by", "256", ".", "This", "function", "retrieves", "the", "current", "Tick", "value", "allowing", "timing", "and", "measurement", "code", "to", "be", "written", "in", "a", "non", "-", "blocking", "fashion", ".", "This", "function", "retrieves", "the", "middle", "32", "bits", "of", "the", "internal", "tick", "counter", "and", "is", "useful", "for", "measuring", "time", "increments", "ranging", "from", "a", "few", "minutes", "to", "a", "few", "weeks", ".", "Use", "TickGet", "for", "shorter", "periods", "or", "TickGetDiv64K", "for", "longer", "ones", ".", "None", "None", "Middle", "32", "bits", "of", "the", "current", "Tick", "value", "." ]

[ "DWORD", "TickGetDiv256", "(", "void", ")", "{", "DWORD", "dw", ";", "GetTickCopy", "(", ")", ";", "(", "(", "BYTE", "*", ")", "&", "dw", ")", "[", "0", "]", "=", "vTickReading", "[", "1", "]", ";", "(", "(", "BYTE", "*", ")", "&", "dw", ")", "[", "1", "]", "=", "vTickReading", "[", "2", "]", ";", "(", "(", "BYTE", "*", ")", "&", "dw", ")", "[", "2", "]", "=", "vTickReading", "[", "3", "]", ";", "(", "(", "BYTE", "*", ")", "&", "dw", ")", "[", "3", "]", "=", "vTickReading", "[", "4", "]", ";", "return", "dw", ";", "}" ]

[ "Function", ":", "DWORD", "TickGetDiv256", "(", "void", ")" ]

[ "// Note: This copy must be done one ", "// byte at a time to prevent misaligned ", "// memory reads, which will reset the PIC." ]

[]

[ "BSD-3-Clause" ]

[ "Obtains", "the", "current", "Tick", "value", "divided", "by", "64K", ".", "This", "function", "retrieves", "the", "current", "Tick", "value", "allowing", "timing", "and", "measurement", "code", "to", "be", "written", "in", "a", "non", "-", "blocking", "fashion", ".", "This", "function", "retrieves", "the", "most", "significant", "32", "bits", "of", "the", "internal", "tick", "counter", "and", "is", "useful", "for", "measuring", "time", "increments", "ranging", "from", "a", "few", "days", "to", "a", "few", "years", "or", "for", "absolute", "time", "measurements", ".", "Use", "TickGet", "or", "TickGetDiv256", "for", "shorter", "periods", "of", "time", ".", "None", "None", "Upper", "32", "bits", "of", "the", "current", "Tick", "value", "." ]

[ "DWORD", "TickGetDiv64K", "(", "void", ")", "{", "DWORD", "dw", ";", "GetTickCopy", "(", ")", ";", "(", "(", "BYTE", "*", ")", "&", "dw", ")", "[", "0", "]", "=", "vTickReading", "[", "2", "]", ";", "(", "(", "BYTE", "*", ")", "&", "dw", ")", "[", "1", "]", "=", "vTickReading", "[", "3", "]", ";", "(", "(", "BYTE", "*", ")", "&", "dw", ")", "[", "2", "]", "=", "vTickReading", "[", "4", "]", ";", "(", "(", "BYTE", "*", ")", "&", "dw", ")", "[", "3", "]", "=", "vTickReading", "[", "5", "]", ";", "return", "dw", ";", "}" ]

[ "Function", ":", "DWORD", "TickGetDiv64K", "(", "void", ")" ]

[ "// Note: This copy must be done one ", "// byte at a time to prevent misaligned ", "// memory reads, which will reset the PIC." ]

[]

[ "BSD-3-Clause" ]

[ "None", "Random", "number", "generator", "is", "initialized", ".", "Side", "Effects", ":", "None", "Sets", "up", "the", "random", "generator", "structure", ".", "Data", "may", "not", "be", "secure", "until", "several", "packets", "have", "been", "received", "." ]

[ "void", "RandomInit", "(", "void", ")", "{", "unsigned", "char", "i", ";", "unsigned", "long", "dw", ";", "SHA1Initialize", "(", "&", "randHash", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "5", ";", "i", "++", ")", "{", "dw", "=", "GenerateRandomDWORD", "(", ")", ";", "RandomAdd", "(", "(", "(", "BYTE", "*", ")", "&", "dw", ")", "[", "0", "]", ")", ";", "RandomAdd", "(", "(", "(", "BYTE", "*", ")", "&", "dw", ")", "[", "1", "]", ")", ";", "RandomAdd", "(", "(", "(", "BYTE", "*", ")", "&", "dw", ")", "[", "2", "]", ")", ";", "RandomAdd", "(", "(", "(", "BYTE", "*", ")", "&", "dw", ")", "[", "3", "]", ")", ";", "}", "bCount", "=", "20", ";", "}" ]

[ "Function", ":", "void", "RandomInit", "(", "void", ")", "PreCondition", ":", "None" ]

[ "// Add some starting entropy to the pool. This is slow." ]

[]

[ "BSD-3-Clause" ]

[ "void", "DiscoveryTask", "(", "void", ")", "Summary", ":", "Announce", "callback", "task", ".", "Stack", "is", "initialized", "()", "None", "None", "Side", "Effects", ":", "None", "Recurring", "task", "used", "to", "listen", "for", "Discovery", "messages", "on", "the", "specified", "ANNOUNCE_PORT", ".", "These", "messages", "can", "be", "sent", "using", "the", "Microchip", "Device", "Discoverer", "tool", ".", "If", "one", "is", "received", "this", "function", "will", "transmit", "a", "reply", ".", "A", "UDP", "socket", "must", "be", "available", "before", "this", "function", "is", "called", ".", "It", "is", "freed", "at", "the", "end", "of", "the", "function", ".", "MAX_UDP_SOCKETS", "may", "need", "to", "be", "increased", "if", "other", "modules", "use", "UDP", "sockets", "." ]

[ "void", "DiscoveryTask", "(", "void", ")", "{", "static", "enum", "{", "DISCOVERY_HOME", "=", "0", ",", "DISCOVERY_LISTEN", ",", "DISCOVERY_REQUEST_RECEIVED", ",", "DISCOVERY_DISABLED", "}", "DiscoverySM", "=", "DISCOVERY_HOME", ";", "static", "UDP_SOCKET", "MySocket", ";", "BYTE", "i", ";", "switch", "(", "DiscoverySM", ")", "{", "case", "DISCOVERY_HOME", ":", "MySocket", "=", "UDPOpenEx", "(", "0", ",", "UDP_OPEN_SERVER", ",", "ANNOUNCE_PORT", ",", "ANNOUNCE_PORT", ")", ";", "if", "(", "MySocket", "==", "INVALID_UDP_SOCKET", ")", "return", ";", "else", "DiscoverySM", "++", ";", "break", ";", "case", "DISCOVERY_LISTEN", ":", "if", "(", "!", "UDPIsGetReady", "(", "MySocket", ")", ")", "return", ";", "UDPGet", "(", "&", "i", ")", ";", "UDPDiscard", "(", ")", ";", "if", "(", "i", "!=", "'", "'", ")", "return", ";", "DiscoverySM", "++", ";", "memcpy", "(", "(", "void", "*", ")", "&", "UDPSocketInfo", "[", "MySocket", "]", ".", "remote", ".", "remoteNode", ",", "(", "const", "void", "*", ")", "&", "remoteNode", ",", "sizeof", "(", "remoteNode", ")", ")", ";", "case", "DISCOVERY_REQUEST_RECEIVED", ":", "if", "(", "!", "UDPIsPutReady", "(", "MySocket", ")", ")", "return", ";", "UDPPutArray", "(", "(", "BYTE", "*", ")", "AppConfig", ".", "NetBIOSName", ",", "sizeof", "(", "AppConfig", ".", "NetBIOSName", ")", "-", "1", ")", ";", "UDPPut", "(", "'", "\\r", "'", ")", ";", "UDPPut", "(", "'", "\\n", "'", ")", ";", "i", "=", "0", ";", "while", "(", "1", ")", "{", "UDPPut", "(", "btohexa_high", "(", "AppConfig", ".", "MyMACAddr", ".", "v", "[", "i", "]", ")", ")", ";", "UDPPut", "(", "btohexa_low", "(", "AppConfig", ".", "MyMACAddr", ".", "v", "[", "i", "]", ")", ")", ";", "if", "(", "++", "i", "==", "6u", ")", "break", ";", "UDPPut", "(", "'", "'", ")", ";", "}", "UDPPut", "(", "'", "\\r", "'", ")", ";", "UDPPut", "(", "'", "\\n", "'", ")", ";", "UDPFlush", "(", ")", ";", "DiscoverySM", "=", "DISCOVERY_LISTEN", ";", "break", ";", "case", "DISCOVERY_DISABLED", ":", "break", ";", "}", "}" ]

[ "Function", ":", "void", "DiscoveryTask", "(", "void", ")", "Summary", ":", "Announce", "callback", "task", "." ]

[ "// Open a UDP socket for inbound and outbound transmission", "// Since we expect to only receive broadcast packets and ", "// only send unicast packets directly to the node we last ", "// received from, the remote NodeInfo parameter can be anything", "//MySocket = UDPOpen(ANNOUNCE_PORT, NULL, ANNOUNCE_PORT);", "// Do nothing if no data is waiting", "// See if this is a discovery query or reply", "// We received a discovery request, reply when we can", "// Change the destination to the unicast address of the last received packet", "// No break needed. If we get down here, we are now ready for the DISCOVERY_REQUEST_RECEIVED state", "// Begin sending our MAC address in human readable form.", "// The MAC address theoretically could be obtained from the ", "// packet header when the computer receives our UDP packet, ", "// however, in practice, the OS will abstract away the useful", "// information and it would be difficult to obtain. It also ", "// would be lost if this broadcast packet were forwarded by a", "// router to a different portion of the network (note that ", "// broadcasts are normally not forwarded by routers).", "// Convert the MAC address bytes to hex (text) and then send it", "// Send the packet", "// Listen for other discovery requests" ]

[]

[ "BSD-3-Clause" ]

[ "This", "will", "cause", "a", "send", "function", "to", "stop", "blocking", "and", "return", "a", "failure", "code", "if", "there", "is", "no", "timely", "response", "from", "the", "MCI", "layer", "." ]

[ "void", "RelayTimeoutCallback", "(", "void", ")", "{", "httpCode", "=", "500", ";", "ResponseReadyFlag", "=", "TRUE", ";", "}" ]

[ "This", "will", "cause", "a", "send", "function", "to", "stop", "blocking", "and", "return", "a", "failure", "code", "if", "there", "is", "no", "timely", "response", "from", "the", "MCI", "layer", "." ]

[]

[]

[ "BSD-3-Clause" ]

[ "SendRequestForPowerLevel", "(", "int", "percent", "int", "produce", ")", "brief", ":", "Sends", "the", "Basic", "DR", "request", "for", "an", "SCG", "to", "produce", "/", "consume", "a", "percentage", "of", "its", "maximum", "power", ".", "The", "percent", "argument", "is", "converted", "to", "7", "bit", "precision", "with", "the", "MSB", "of", "the", "second", "opcode", "byte", "being", "used", "to", "specify", "whether", "the", "device", "is", "to", "produce", "or", "consume", "power", "@param", "percent", ":", "the", "percentage", "of", "rated", "power", "that", "will", "be", "consumed", "@param", "produce", ":", "1", "if", "the", "device", "should", "be", "producing", "power", "0", "if", "consuming", "power" ]

[ "RelayMsg", "SendRequestForPowerLevel", "(", "int", "percent", ")", "{", "RelayMsg", "retval", ";", "int", "produce", "=", "0", ";", "unsigned", "char", "opcode2", "=", "0x00", ";", "unsigned", "char", "messageBuffer", "[", "8", "]", ";", "memcpy", "(", "messageBuffer", ",", "RequestPowerLevel", ",", "8", ")", ";", "if", "(", "percent", "<", "0", ")", "{", "produce", "=", "1", ";", "percent", "=", "-1", "*", "percent", ";", "}", "if", "(", "percent", ">", "100", ")", "{", "percent", "=", "100", ";", "}", "percent", "=", "(", "int", ")", "(", "1.27", "*", "(", "float", ")", "percent", ")", ";", "opcode2", "=", "(", "unsigned", "char", ")", "(", "(", "produce", "<<", "7", ")", "|", "percent", ")", ";", "messageBuffer", "[", "5", "]", "=", "opcode2", ";", "RelayMsgState", "=", "RLY_WAITING_REQUEST_POWER_LEVEL", ";", "httpCode", "=", "500", ";", "MCISendNeutral", "(", "messageBuffer", ")", ";", "BlockUntilReady", "(", ")", ";", "retval", ".", "httpCode", "=", "httpCode", ";", "retval", ".", "codeByte", "=", "DEFAULT_RETURN_CODE", ";", "return", "retval", ";", "}" ]

[ "SendRequestForPowerLevel", "(", "int", "percent", "int", "produce", ")", "brief", ":", "Sends", "the", "Basic", "DR", "request", "for", "an", "SCG", "to", "produce", "/", "consume", "a", "percentage", "of", "its", "maximum", "power", "." ]

[ "//limit percent value to 100%" ]

[ { "param": "percent", "type": "int" } ]

[ "BSD-3-Clause" ]

[ "Requests", "control", "of", "the", "RSA", "engine", ".", "This", "function", "acts", "as", "a", "semaphore", "to", "gain", "control", "of", "the", "RSA", "engine", ".", "Call", "this", "function", "and", "ensure", "that", "it", "returns", "TRUE", "before", "using", "any", "other", "RSA", "APIs", ".", "When", "the", "RSA", "module", "is", "no", "longer", "needed", "call", "RSAEndUsage", "to", "release", "the", "module", "back", "to", "the", "application", ".", "This", "function", "should", "not", "be", "called", "directly", ".", "Instead", "its", "macros", "RSABeginEncrypt", "and", "RSABeginDecrypt", "should", "be", "used", "to", "ensure", "that", "the", "specified", "option", "is", "enabled", ".", "RSA", "has", "already", "been", "initialized", ".", "one", "of", "the", "RSA_OP", "constants", "indicating", "encryption", "or", "decryption", "vKeyByteLen", "-", "For", "encryption", "the", "length", "of", "the", "RSA", "key", "in", "bytes", ".", "This", "value", "is", "ignored", "otherwise", ".", "Return", "Values", ":", "TRUE", "-", "No", "RSA", "operation", "is", "in", "progress", "and", "the", "calling", "application", "has", "successfully", "taken", "ownership", "of", "the", "RSA", "module", ".", "FALSE", "-", "The", "RSA", "module", "is", "currently", "being", "used", "so", "the", "calling", "application", "must", "wait", "." ]

[ "BOOL", "RSABeginUsage", "(", "RSA_OP", "op", ",", "WORD", "vKeyByteLen", ")", "{", "if", "(", "smRSA", "!=", "SM_RSA_IDLE", ")", "return", "FALSE", ";", "if", "(", "op", "==", "RSA_OP_ENCRYPT", ")", "smRSA", "=", "SM_RSA_ENCRYPT_START", ";", "else", "if", "(", "op", "==", "RSA_OP_DECRYPT", ")", "smRSA", "=", "SM_RSA_DECRYPT_START", ";", "else", "return", "FALSE", ";", "keyLength", "=", "vKeyByteLen", ";", "return", "TRUE", ";", "}" ]

[ "Function", ":", "BOOL", "RSABeginUsage", "(", "RSA_OP", "op", "WORD", "vKeyByteLen", ")" ]

[ "// Set up the state machine" ]

[ { "param": "op", "type": "RSA_OP" }, { "param": "vKeyByteLen", "type": "WORD" } ]

[ "BSD-3-Clause" ]

[ "void", "RSASetData", "(", "BYTE", "*", "data", "WORD", "len", "RSA_DATA_FORMAT", "format", ")", "Indicates", "the", "data", "to", "be", "encrypted", "or", "decrypted", ".", "Call", "this", "function", "to", "indicate", "what", "data", "is", "to", "be", "encrypted", "or", "decrypted", ".", "This", "function", "ensures", "that", "the", "data", "is", "PKCS", "#1", "padded", "for", "encryption", "operations", "and", "also", "normalizes", "the", "data", "to", "little", "-", "endian", "format", "so", "that", "it", "will", "be", "compatible", "with", "the", "BigInt", "libraries", ".", "RSA", "has", "already", "been", "initialized", "and", "RSABeginUsage", "has", "returned", "TRUE", ".", "The", "data", "to", "be", "encrypted", "or", "decrypted", "len", "-", "The", "length", "of", "data", "format", "-", "One", "of", "the", "RSA_DATA_FORMAT", "constants", "indicating", "the", "endian", "-", "ness", "of", "the", "input", "data", ".", "Return", "Values", ":", "None", "For", "decryption", "operations", "the", "calculation", "is", "done", "in", "place", ".", "Thererore", "the", "endian", "-", "ness", "of", "the", "input", "data", "may", "be", "modified", "by", "this", "function", ".", "Encryption", "operations", "may", "expand", "the", "input", "so", "separate", "memory", "is", "allocated", "for", "the", "operation", "in", "that", "case", "." ]

[ "void", "RSASetData", "(", "BYTE", "*", "data", ",", "WORD", "len", ",", "RSA_DATA_FORMAT", "format", ")", "{", "#if", "defined", "(", "STACK_USE_RSA_ENCRYPT", ")", "\n", "if", "(", "smRSA", "==", "SM_RSA_ENCRYPT_START", ")", "{", "BigInt", "(", "&", "X", ",", "(", "BIGINT_DATA_TYPE", "*", ")", "rsaData", ",", "len", "/", "sizeof", "(", "BIGINT_DATA_TYPE", ")", ")", ";", "memcpy", "(", "(", "void", "*", ")", "rsaData", ",", "(", "void", "*", ")", "data", ",", "len", ")", ";", "if", "(", "format", "==", "RSA_BIG_ENDIAN", ")", "BigIntSwapEndianness", "(", "&", "X", ")", ";", "BigInt", "(", "&", "X", ",", "(", "BIGINT_DATA_TYPE", "*", ")", "rsaData", ",", "keyLength", "/", "sizeof", "(", "BIGINT_DATA_TYPE", ")", ")", ";", "if", "(", "len", "<", "keyLength", "-", "4", ")", "{", "rsaData", "[", "len", "++", "]", "=", "0x00", ";", "while", "(", "len", "<", "keyLength", "-", "2", ")", "{", "do", "{", "rsaData", "[", "len", "]", "=", "RandomGet", "(", ")", ";", "}", "while", "(", "rsaData", "[", "len", "]", "==", "0x00u", ")", ";", "len", "++", ";", "}", "rsaData", "[", "len", "++", "]", "=", "0x02", ";", "rsaData", "[", "len", "++", "]", "=", "0x00", ";", "}", "}", "#endif", "#if", "defined", "(", "STACK_USE_RSA_DECRYPT", ")", "\n", "if", "(", "smRSA", "==", "SM_RSA_DECRYPT_START", ")", "{", "BigInt", "(", "&", "X", ",", "(", "BIGINT_DATA_TYPE", "*", ")", "data", ",", "len", "/", "sizeof", "(", "BIGINT_DATA_TYPE", ")", ")", ";", "outputFormat", "=", "format", ";", "if", "(", "outputFormat", "==", "RSA_BIG_ENDIAN", ")", "BigIntSwapEndianness", "(", "&", "X", ")", ";", "}", "#endif", "}" ]

[ "Function", ":", "void", "RSASetData", "(", "BYTE", "*", "data", "WORD", "len", "RSA_DATA_FORMAT", "format", ")" ]

[ "// Initialize the BigInt wrappers", "// Copy in the data", "// For big-endian, swap the data", "// Resize the big int to full size", "// Pad the input data according to PKCS #1 Block 2", "// Correct and save endianness" ]

[ { "param": "data", "type": "BYTE" }, { "param": "len", "type": "WORD" }, { "param": "format", "type": "RSA_DATA_FORMAT" } ]

[ "BSD-3-Clause" ]

[ "Performs", "non", "-", "blocking", "RSA", "calculations", ".", "Call", "this", "function", "to", "process", "a", "portion", "of", "the", "pending", "RSA", "operation", "until", "RSA_DONE", "is", "returned", ".", "This", "function", "performs", "small", "pieces", "of", "work", "each", "time", "it", "is", "called", "so", "it", "must", "be", "called", "repeatedly", "in", "order", "to", "complete", "an", "operation", ".", "Performing", "small", "pieces", "at", "a", "time", "and", "then", "yielding", "to", "the", "main", "application", "allows", "long", "calculations", "to", "be", "performed", "in", "a", "non", "-", "blocking", "manner", "that", "fits", "with", "the", "co", "-", "operative", "multi", "-", "tasking", "model", "of", "the", "stack", ".", "Status", "updates", "are", "periodically", "returned", ".", "For", "lengthy", "decryption", "operations", "this", "helps", "prevent", "client", "time", "-", "outs", "by", "allowing", "the", "application", "to", "periodically", "transmit", "a", "few", "bytes", "if", "necessary", ".", "RSA", "has", "already", "been", "initialized", "and", "RSABeginUsage", "has", "returned", "TRUE", ".", "None", "Return", "Values", ":", "RSA_WORKING", "-", "Calculation", "is", "in", "progress", ";", "no", "status", "update", "available", ".", "RSA_FINISHED_M1", "-", "This", "call", "has", "completed", "the", "decryption", "calculation", "of", "the", "M1", "CRT", "value", ".", "RSA_FINISHED_M2", "-", "This", "call", "has", "completed", "the", "decryption", "calculation", "of", "the", "M2", "CRT", "value", ".", "RSA_DONE", "-", "The", "RSA", "operation", "is", "complete", "." ]

[ "RSA_STATUS", "RSAStep", "(", "void", ")", "{", "#if", "defined", "(", "STACK_USE_RSA_DECRYPT", ")", "\n", "static", "BIGINT", "m1", ",", "m2", ";", "#endif", "switch", "(", "smRSA", ")", "{", "#if", "defined", "(", "STACK_USE_RSA_ENCRYPT", ")", "\n", "case", "SM_RSA_ENCRYPT_START", ":", "smRSA", "=", "SM_RSA_ENCRYPT", ";", "case", "SM_RSA_ENCRYPT", ":", "if", "(", "_RSAModExp", "(", "&", "Y", ",", "&", "X", ",", "&", "E", ",", "&", "N", ")", ")", "{", "if", "(", "outputFormat", "==", "RSA_BIG_ENDIAN", ")", "BigIntSwapEndianness", "(", "&", "Y", ")", ";", "smRSA", "=", "SM_RSA_DONE", ";", "return", "RSA_DONE", ";", "}", "break", ";", "#endif", "#if", "defined", "(", "STACK_USE_RSA_DECRYPT", ")", "\n", "case", "SM_RSA_DECRYPT_START", ":", "BigInt", "(", "&", "m1", ",", "(", "BIGINT_DATA_TYPE", "*", ")", "(", "(", "BYTE", "*", ")", "&", "sslBuffer", "+", "(", "SSL_RSA_KEY_SIZE", "/", "8", ")", ")", ",", "RSA_PRIME_WORDS", ")", ";", "BigInt", "(", "&", "m2", ",", "(", "BIGINT_DATA_TYPE", "*", ")", "(", "(", "BYTE", "*", ")", "&", "sslBuffer", "+", "3", "*", "(", "SSL_RSA_KEY_SIZE", "/", "16", ")", ")", ",", "RSA_PRIME_WORDS", ")", ";", "smRSA", "=", "SM_RSA_DECRYPT_FIND_M1", ";", "break", ";", "case", "SM_RSA_DECRYPT_FIND_M1", ":", "if", "(", "_RSAModExpROM", "(", "&", "m1", ",", "&", "X", ",", "&", "dP", ",", "&", "P", ")", ")", "{", "smRSA", "=", "SM_RSA_DECRYPT_FIND_M2", ";", "return", "RSA_FINISHED_M1", ";", "}", "break", ";", "case", "SM_RSA_DECRYPT_FIND_M2", ":", "if", "(", "_RSAModExpROM", "(", "&", "m2", ",", "&", "X", ",", "&", "dQ", ",", "&", "Q", ")", ")", "{", "smRSA", "=", "SM_RSA_DECRYPT_FINISH", ";", "return", "RSA_FINISHED_M2", ";", "}", "break", ";", "case", "SM_RSA_DECRYPT_FINISH", ":", "if", "(", "BigIntCompare", "(", "&", "m1", ",", "&", "m2", ")", ">", "0", ")", "{", "BigIntSubtract", "(", "&", "m1", ",", "&", "m2", ")", ";", "BigIntMultiplyROM", "(", "&", "m1", ",", "&", "qInv", ",", "&", "tmp", ")", ";", "BigIntModROM", "(", "&", "tmp", ",", "&", "P", ")", ";", "BigIntCopy", "(", "&", "m1", ",", "&", "tmp", ")", ";", "}", "else", "{", "BigIntCopy", "(", "&", "tmp", ",", "&", "m2", ")", ";", "BigIntSubtract", "(", "&", "m2", ",", "&", "m1", ")", ";", "BigIntCopy", "(", "&", "m1", ",", "&", "tmp", ")", ";", "BigIntMultiplyROM", "(", "&", "m2", ",", "&", "qInv", ",", "&", "tmp", ")", ";", "BigIntCopy", "(", "&", "m2", ",", "&", "m1", ")", ";", "BigIntModROM", "(", "&", "tmp", ",", "&", "P", ")", ";", "BigIntCopyROM", "(", "&", "m1", ",", "&", "P", ")", ";", "BigIntSubtract", "(", "&", "m1", ",", "&", "tmp", ")", ";", "}", "BigIntMultiplyROM", "(", "&", "m1", ",", "&", "Q", ",", "&", "tmp", ")", ";", "BigIntAdd", "(", "&", "tmp", ",", "&", "m2", ")", ";", "BigIntCopy", "(", "&", "X", ",", "&", "tmp", ")", ";", "if", "(", "outputFormat", "==", "RSA_BIG_ENDIAN", ")", "BigIntSwapEndianness", "(", "&", "X", ")", ";", "smRSA", "=", "SM_RSA_DONE", ";", "return", "RSA_DONE", ";", "#endif", "default", ":", "return", "RSA_DONE", ";", "}", "return", "RSA_WORKING", ";", "}" ]

[ "Function", ":", "RSA_STATUS", "RSAStep", "(", "void", ")" ]

[ "// Actually nothing to do here anymore", "// Call ModExp until complete", "// Calculation is finished", "// Swap endian-ness if needed", "// Indicate that we're finished", "// Set up the RSA Decryption memories", "// m1 = c^dP % p", "// m2 = c^dQ % q", "// Almost done...finalize the CRT math", "// if(m1 > m2)", "// m1 = m1 - m2", "// tmp = m1 * qInv", "// m1 = tmp % p", "// m1 < m2", "// tmp = m2", "// m2 = m2 - m1", "// m1 = tmp", "// tmp = m2 * qInv", "// m2 = m1", "// tmp = tmp % p", "// m1 = P", "// m1 = m1 - tmp;", "// msg = m1 * q", "// tmp = m2 + tmp", "// Copy the decrypted value back to X", "// Swap endian-ness if needed", "// Indicate that we're finished", "// Unknown state", "// Indicate that we're still working" ]

[]

[ "BSD-3-Clause" ]

[ "Driver", "function", "to", "configure", "PS", "Poll", "mode", ".", "This", "function", "is", "only", "used", "by", "the", "driver", "not", "the", "application", ".", "This", "function", "other", "than", "at", "initialization", "is", "only", "used", "when", "the", "application", "has", "enabled", "PS", "-", "Poll", "mode", ".", "This", "function", "is", "used", "to", "temporarily", "deactivate", "PS", "-", "Poll", "mode", "when", "there", "is", "mgmt", "or", "data", "message", "tx", "/", "rx", "and", "then", "when", "message", "activity", "has", "ceased", "to", "again", "activate", "PS", "-", "Poll", "mode", ".", "MACInit", "must", "be", "called", "first", ".", "None", ".", "None", "." ]

[ "void", "WFConfigureLowPowerMode", "(", "UINT8", "action", ")", "{", "UINT16", "lowPowerStatusRegValue", ";", "if", "(", "action", "==", "WF_LOW_POWER_MODE_ON", ")", "{", "Write16BitWFRegister", "(", "WF_PSPOLL_H_REG", ",", "REG_ENABLE_LOW_POWER_MASK", ")", ";", "g_psPollActive", "=", "TRUE", ";", "}", "else", "{", "Write16BitWFRegister", "(", "WF_PSPOLL_H_REG", ",", "REG_DISABLE_LOW_POWER_MASK", ")", ";", "g_psPollActive", "=", "FALSE", ";", "do", "{", "#if", "defined", "(", "MRF24WG", ")", "\n", "Write16BitWFRegister", "(", "WF_INDEX_ADDR_REG", ",", "WF_SCRATCHPAD_1_REG", ")", ";", "#else", "Write16BitWFRegister", "(", "WF_INDEX_ADDR_REG", ",", "WF_LOW_POWER_STATUS_REG", ")", ";", "#endif", "lowPowerStatusRegValue", "=", "Read16BitWFRegister", "(", "WF_INDEX_DATA_REG", ")", ";", "}", "while", "(", "lowPowerStatusRegValue", "&", "REG_ENABLE_LOW_POWER_MASK", ")", ";", "}", "}" ]

[ "Function", ":", "void", "WFConfigureLowPowerMode", "(", "UINT8", "action", ")" ]

[ "/*-----------------------------------------*/", "/* if activating PS-Poll mode on MRF24W */", "/*-----------------------------------------*/", "//putrsUART(\"Enable PS\\r\\n\");", "/*---------------------------------------------------------------------------------------------*/", "/* else deactivating PS-Poll mode on MRF24W (taking it out of low-power mode and waking it up) */", "/*---------------------------------------------------------------------------------------------*/", "/* action == WF_LOW_POWER_MODE_OFF */", "//putrsUART(\"Disable PS\\r\\n\");", "/* poll the response bit that indicates when the MRF24W has come out of low power mode */", "/* set the index register to the register we wish to read */", "/* must be a MRF24WB */", "/* set the index register to the register we wish to read */" ]

[ { "param": "action", "type": "UINT8" } ]

[ "BSD-3-Clause" ]

[ "If", "PS", "-", "Poll", "is", "active", "or", "the", "MRF24W", "is", "asleep", "ensure", "that", "it", "is", "woken", "up", ".", "Called", "by", "the", "WiFi", "driver", "when", "it", "needs", "to", "transmit", "or", "receive", "a", "data", "or", "mgmt", "message", ".", "If", "the", "application", "has", "enabled", "PS", "-", "Poll", "mode", "and", "the", "WiFi", "driver", "has", "activated", "PS", "-", "Poll", "mode", "then", "this", "function", "will", "deactivate", "PS", "-", "Poll", "mode", "and", "wake", "up", "the", "MRF24W", ".", "MACInit", "must", "be", "called", "first", ".", "None", ".", "None", ".", "None", "." ]

[ "void", "EnsureWFisAwake", "(", ")", "{", "#if", "defined", "(", "WF_USE_POWER_SAVE_FUNCTIONS", ")", "\n", "if", "(", "(", "g_powerSaveState", "==", "WF_PS_PS_POLL_DTIM_ENABLED", ")", "||", "(", "g_powerSaveState", "==", "WF_PS_PS_POLL_DTIM_DISABLED", ")", ")", "{", "if", "(", "g_psPollActive", "==", "TRUE", ")", "{", "WFConfigureLowPowerMode", "(", "WF_LOW_POWER_MODE_OFF", ")", ";", "}", "SetSleepNeeded", "(", ")", ";", "}", "#endif", "}" ]

[ "Function", ":", "void", "EnsureWFisAwake", "()" ]

[ "/* if the application desires the MRF24W to be in PS-Poll mode (PS-Poll with DTIM enabled or disabled */", "/* if the WF driver has activated PS-Poll */", "/* wake up MRF24W */", "// will need to put device back into PS-Poll sleep mode" ]

[]

[ "BSD-3-Clause" ]

[ "Puts", "the", "MRF24W", "into", "hibernate", "mode", "by", "setting", "HIBERNATE", "pin", "to", "HIGH", ".", "Enables", "Hibernate", "mode", "on", "the", "MRF24W", "which", "effectively", "turns", "off", "the", "device", "for", "maximum", "power", "savings", ".", "HIBERNATE", "pin", "on", "MRF24W", "is", "set", "to", "HIGH", ".", "MRF24W", "state", "is", "not", "maintained", "when", "it", "transitions", "to", "hibernate", "mode", ".", "To", "remove", "the", "MRF24W", "from", "hibernate", "mode", "call", "WF_Init", "()", ".", "MACInit", "must", "be", "called", "first", ".", "None", ".", "None", ".", "Note", "that", "because", "the", "MRF24W", "does", "not", "save", "state", "there", "will", "be", "a", "disconnect", "between", "the", "TCP", "/", "IP", "stack", "and", "the", "MRF24B0M", "state", ".", "If", "it", "is", "desired", "by", "the", "application", "to", "use", "hibernate", "additional", "measures", "must", "be", "taken", "to", "save", "application", "state", ".", "Then", "the", "host", "should", "be", "reset", ".", "This", "will", "ensure", "a", "clean", "connection", "between", "MRF24W", "and", "TCP", "/", "IP", "stack", "Future", "versions", "of", "the", "stack", "might", "have", "the", "ability", "to", "save", "stack", "context", "as", "well", "ensuring", "a", "clean", "wake", "up", "for", "the", "MRF24W", "without", "needing", "a", "host", "reset", "." ]

[ "void", "WF_HibernateEnable", "(", ")", "{", "WF_SetCE_N", "(", "WF_HIGH", ")", ";", "}" ]

[ "Function", ":", "void", "WF_HibernateEnable", "()" ]

[ "/* set XCEN33 pin high, which puts MRF24W in hibernate mode */", "/* SetPowerSaveState(WF_PS_HIBERNATE); */" ]

[]

[ "BSD-3-Clause" ]

[ "Seeds", "the", "LFSR", "random", "number", "generator", "invoked", "by", "the", "LFSRRand", "()", "function", ".", "The", "prior", "seed", "is", "returned", ".", "Seeds", "the", "LFSR", "random", "number", "generator", "invoked", "by", "the", "LFSRRand", "()", "function", ".", "The", "prior", "seed", "is", "returned", ".", "None", "The", "new", "32", "-", "bit", "seed", "value", "to", "assign", "to", "the", "LFSR", ".", "The", "last", "seed", "in", "use", ".", "This", "can", "be", "saved", "and", "restored", "by", "a", "subsequent", "call", "to", "LFSRSeedRand", "()", "if", "you", "wish", "to", "use", "LFSRRand", "()", "in", "multiple", "contexts", "without", "disrupting", "the", "random", "number", "sequence", "from", "the", "alternative", "context", ".", "For", "example", "if", "App", "1", "needs", "a", "given", "sequence", "of", "random", "numbers", "to", "perform", "a", "test", "if", "you", "save", "and", "restore", "the", "seed", "in", "App", "2", "it", "is", "possible", "for", "App", "2", "to", "not", "disrupt", "the", "random", "number", "sequence", "provided", "to", "App", "1", "even", "if", "the", "number", "of", "times", "App", "2", "calls", "LFSRRand", "()", "varies", ".", "Side", "Effects", ":", "None", "Upon", "initial", "power", "up", "the", "internal", "seed", "is", "initialized", "to", "0x1", ".", "Using", "a", "dwSeed", "value", "of", "0x0", "will", "return", "the", "same", "sequence", "of", "random", "numbers", "as", "using", "the", "seed", "of", "0x1", "." ]

[ "DWORD", "LFSRSeedRand", "(", "DWORD", "dwSeed", ")", "{", "DWORD", "dwOldSeed", ";", "BYTE", "i", ";", "dwOldSeed", "=", "dwLFSRRandSeed", ";", "if", "(", "dwSeed", "==", "0u", ")", "dwSeed", "=", "1", ";", "dwLFSRRandSeed", "=", "dwSeed", ";", "for", "(", "i", "=", "0", ";", "i", "<", "16", ";", "i", "++", ")", "LFSRRand", "(", ")", ";", "return", "dwOldSeed", ";", "}" ]

[ "Function", ":", "DWORD", "LFSRSeedRand", "(", "DWORD", "dwSeed", ")" ]

[ "// Save original seed to be returned later", "// Ensure zero isn't selected as a seed value, this would result in all ", "// 0x0000 output values from the LFSR", "// Set the new seed", "// Run the LFSR a few times to get rid of obvious start up artifacts for ", "// seed values that don't have many set bits.", "// Return saved old seed" ]

[ { "param": "dwSeed", "type": "DWORD" } ]

[ "BSD-3-Clause" ]

[ "Returns", "a", "pseudo", "-", "random", "16", "-", "bit", "unsigned", "integer", "in", "the", "range", "from", "0", "to", "65535", "(", "0x0000", "to", "0xFFFF", ")", ".", "Returns", "a", "pseudo", "-", "random", "16", "-", "bit", "unsigned", "integer", "in", "the", "range", "from", "0", "to", "65535", "(", "0x0000", "to", "0xFFFF", ")", ".", "The", "random", "number", "is", "generated", "using", "a", "Linear", "Feedback", "Shift", "Register", "(", "LFSR", ")", "type", "pseudo", "-", "random", "number", "generator", "algorithm", ".", "The", "LFSR", "can", "be", "seeded", "by", "calling", "the", "LFSRSeedRand", "()", "function", "to", "generate", "the", "same", "sequence", "of", "random", "numbers", "as", "a", "prior", "string", "of", "calls", ".", "The", "internal", "LFSR", "will", "repeat", "after", "2^32", "-", "1", "iterations", ".", "None", "None", "Random", "16", "-", "bit", "unsigned", "integer", ".", "Side", "Effects", ":", "The", "internal", "LFSR", "seed", "is", "updated", "so", "that", "the", "next", "call", "to", "LFSRRand", "()", "will", "return", "a", "different", "random", "number", ".", "None" ]

[ "WORD", "LFSRRand", "(", "void", ")", "{", "BYTE", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "15", ";", "i", "++", ")", "dwLFSRRandSeed", "=", "(", "dwLFSRRandSeed", ">>", "1", ")", "^", "(", "(", "0ul", "-", "(", "dwLFSRRandSeed", "&", "1ul", ")", ")", "&", "0xD0000001ul", ")", ";", "return", "(", "WORD", ")", "dwLFSRRandSeed", ";", "}" ]

[ "Function", ":", "WORD", "LFSRRand", "(", "void", ")" ]

[ "// Taps: 32 31 29 1", "// Characteristic polynomial: x^32 + x^31 + x^29 + x + 1", "// Repeat 15 times to make the shift pattern less obvious", "// Return 16-bits as pseudo-random number" ]

[]

[ "BSD-3-Clause" ]

[ "Generates", "a", "random", "DWORD", ".", "This", "function", "generates", "a", "random", "32", "-", "bit", "integer", ".", "It", "collects", "randomness", "by", "comparing", "the", "A", "/", "D", "converter", "'", "s", "internal", "R", "/", "C", "oscillator", "clock", "with", "our", "main", "system", "clock", ".", "By", "passing", "collected", "entropy", "to", "the", "LFSRSeedRand", "()", "/", "LFSRRand", "()", "functions", "the", "output", "is", "normalized", "(", "deskewed", ")", "in", "the", "hopes", "of", "meeting", "statistical", "randomness", "tests", ".", "None", "None", "Random", "32", "-", "bit", "number", ".", "Side", "Effects", ":", "This", "function", "uses", "the", "A", "/", "D", "converter", "(", "and", "so", "you", "must", "disable", "interrupts", "if", "you", "use", "the", "A", "/", "D", "converted", "in", "your", "ISR", ")", ".", "The", "LFSRRand", "()", "function", "will", "be", "reseeded", "and", "Timer0", "(", "PIC18", ")", "and", "Timer1", "(", "PIC24", "dsPIC", "and", "PIC32", ")", "will", "be", "used", ".", "TMR#H", ":", "TMR#L", "will", "have", "a", "new", "value", ".", "Note", "that", "this", "is", "the", "same", "timer", "used", "by", "the", "Tick", "module", ".", "This", "function", "times", "out", "after", "1", "second", "of", "attempting", "to", "generate", "the", "random", "DWORD", ".", "In", "such", "a", "case", "the", "output", "may", "not", "be", "truly", "random", ".", "Typically", "this", "function", "executes", "in", "around", "500", "000", "instruction", "cycles", ".", "The", "intent", "of", "this", "function", "is", "to", "produce", "statistically", "random", "and", "cryptographically", "secure", "random", "number", ".", "Whether", "or", "not", "this", "is", "true", "on", "all", "(", "or", "any", ")", "devices", "/", "voltages", "/", "temperatures", "is", "not", "tested", "." ]

[ "DWORD", "GenerateRandomDWORD", "(", "void", ")", "{", "BYTE", "vBitCount", ";", "WORD", "w", ",", "wTime", ",", "wLastValue", ";", "DWORD", "dwTotalTime", ";", "union", "{", "DWORD", "dw", ";", "WORD", "w", "[", "2", "]", ";", "}", "randomResult", ";", "#if", "defined", "__18CXX", "\n", "{", "BYTE", "ADCON0Save", ",", "ADCON2Save", ";", "BYTE", "T0CONSave", ",", "TMR0HSave", ",", "TMR0LSave", ";", "ADCON0Save", "=", "ADCON0", ";", "ADCON2Save", "=", "ADCON2", ";", "T0CONSave", "=", "T0CON", ";", "TMR0LSave", "=", "TMR0L", ";", "TMR0HSave", "=", "TMR0H", ";", "ADCON0", "=", "0x01", ";", "ADCON2", "=", "0x3F", ";", "T0CON", "=", "0x88", ";", "vBitCount", "=", "0", ";", "dwTotalTime", "=", "0", ";", "wLastValue", "=", "0", ";", "randomResult", ".", "dw", "=", "LFSRRand", "(", ")", ";", "while", "(", "1", ")", "{", "TMR0H", "=", "0x00", ";", "TMR0L", "=", "0x00", ";", "ADCON0bits", ".", "GO", "=", "1", ";", "ClrWdt", "(", ")", ";", "while", "(", "ADCON0bits", ".", "GO", ")", ";", "(", "(", "BYTE", "*", ")", "&", "wTime", ")", "[", "0", "]", "=", "TMR0L", ";", "(", "(", "BYTE", "*", ")", "&", "wTime", ")", "[", "1", "]", "=", "TMR0H", ";", "w", "=", "LFSRRand", "(", ")", ";", "dwTotalTime", "+=", "wTime", ";", "if", "(", "dwTotalTime", ">=", "GetInstructionClock", "(", ")", ")", "{", "randomResult", ".", "w", "[", "0", "]", "^=", "LFSRRand", "(", ")", ";", "randomResult", ".", "w", "[", "1", "]", "^=", "LFSRRand", "(", ")", ";", "break", ";", "}", "if", "(", "wLastValue", "==", "wTime", ")", "continue", ";", "LFSRSeedRand", "(", "w", "+", "(", "wLastValue", "-", "wTime", ")", ")", ";", "wLastValue", "=", "wTime", ";", "randomResult", ".", "dw", "<<=", "1", ";", "if", "(", "LFSRRand", "(", ")", "&", "0x0080", ")", "randomResult", ".", "w", "[", "0", "]", "|=", "0x1", ";", "if", "(", "++", "vBitCount", "==", "0u", ")", "break", ";", "}", "ADCON0", "=", "ADCON0Save", ";", "ADCON2", "=", "ADCON2Save", ";", "TMR0H", "=", "TMR0HSave", ";", "TMR0L", "=", "TMR0LSave", ";", "T0CON", "=", "T0CONSave", ";", "}", "#else", "{", "WORD", "AD1CON1Save", ",", "AD1CON2Save", ",", "AD1CON3Save", ";", "WORD", "T1CONSave", ",", "PR1Save", ";", "AD1CON1Save", "=", "AD1CON1", ";", "AD1CON2Save", "=", "AD1CON2", ";", "AD1CON3Save", "=", "AD1CON3", ";", "T1CONSave", "=", "T1CON", ";", "PR1Save", "=", "PR1", ";", "AD1CON1", "=", "0x0000", ";", "AD1CON3", "=", "0x9F00", ";", "AD1CON2", "=", "0x003F", ";", "AD1CON1", "=", "0x80E4", ";", "T1CON", "=", "0x8000", ";", "PR1", "=", "0xFFFF", ";", "vBitCount", "=", "0", ";", "dwTotalTime", "=", "0", ";", "wLastValue", "=", "0", ";", "randomResult", ".", "dw", "=", "LFSRRand", "(", ")", ";", "while", "(", "1", ")", "{", "ClrWdt", "(", ")", ";", "#if", "defined", "(", "__C30__", ")", "\n", "while", "(", "!", "IFS0bits", ".", "AD1IF", ")", ";", "#else", "while", "(", "!", "IFS1bits", ".", "AD1IF", ")", ";", "#endif", "wTime", "=", "TMR1", ";", "TMR1", "=", "0x0000", ";", "#if", "defined", "(", "__C30__", ")", "\n", "IFS0bits", ".", "AD1IF", "=", "0", ";", "#else", "IFS1CLR", "=", "_IFS1_AD1IF_MASK", ";", "#endif", "w", "=", "LFSRRand", "(", ")", ";", "dwTotalTime", "+=", "wTime", ";", "if", "(", "dwTotalTime", ">=", "GetInstructionClock", "(", ")", ")", "{", "randomResult", ".", "w", "[", "0", "]", "^=", "LFSRRand", "(", ")", ";", "randomResult", ".", "w", "[", "1", "]", "^=", "LFSRRand", "(", ")", ";", "break", ";", "}", "if", "(", "wLastValue", "==", "wTime", ")", "continue", ";", "LFSRSeedRand", "(", "w", "+", "(", "wLastValue", "-", "wTime", ")", ")", ";", "wLastValue", "=", "wTime", ";", "randomResult", ".", "dw", "<<=", "1", ";", "if", "(", "LFSRRand", "(", ")", "&", "0x0080", ")", "randomResult", ".", "w", "[", "0", "]", "|=", "0x1", ";", "if", "(", "++", "vBitCount", "==", "0u", ")", "break", ";", "}", "AD1CON1", "=", "0x0000", ";", "AD1CON3", "=", "AD1CON3Save", ";", "AD1CON2", "=", "AD1CON2Save", ";", "AD1CON1", "=", "AD1CON1Save", ";", "T1CON", "=", "T1CONSave", ";", "PR1", "=", "PR1Save", ";", "}", "#endif", "return", "randomResult", ".", "dw", ";", "}" ]

[ "Function", ":", "DWORD", "GenerateRandomDWORD", "(", "void", ")" ]

[ "// Save hardware SFRs", "// Set up Timer and A/D converter module", "// Turn on the A/D module", "// 20 Tad acquisition, Frc A/D clock used for conversion", "// TMR0ON = 1, no prescalar", "// Time the duration of an A/D acquisition and conversion", "// Wait no longer than 1 second obtaining entropy", "// Keep sampling if minimal entropy was likely obtained this round", "// Add this entropy into the pseudo random number generator by reseeding", "// Accumulate at least 32 bits of randomness over time", "// See if we've collected a fair amount of entropy and can quit early", "// Restore hardware SFRs", "// Save hardware SFRs", "// Set up Timer and A/D converter module", "// Turn off the ADC so we can write to it", "// Frc A/D clock, 31 Tad acquisition", "// Interrupt after every 16th sample/convert", "// Turn on the A/D module, auto-convert", "// TON = 1, no prescalar", "// Don't clear timer early", "// Wait no longer than 1 second obtaining entropy", "// Keep sampling if minimal entropy was likely obtained this round", "// Add this entropy into the pseudo random number generator by reseeding", "// Accumulate at least 32 bits of randomness over time", "// See if we've collected a fair amount of entropy and can quit early", "// Restore hardware SFRs", "// Turn off the ADC so we can write to it" ]

[]

[ "BSD-3-Clause" ]

[ "Converts", "a", "string", "to", "an", "IP", "address", "This", "function", "parses", "a", "dotted", "-", "quad", "decimal", "IP", "address", "string", "into", "an", "IP_ADDR", "struct", ".", "The", "output", "result", "is", "big", "-", "endian", ".", "None", "Pointer", "to", "a", "dotted", "-", "quad", "IP", "address", "string", "IPAddress", "-", "Pointer", "to", "IP_ADDR", "in", "which", "to", "store", "the", "result", "Return", "Values", ":", "TRUE", "-", "an", "IP", "address", "was", "successfully", "decoded", "FALSE", "-", "no", "IP", "address", "could", "be", "found", "or", "the", "format", "was", "incorrect" ]

[ "BOOL", "StringToIPAddress", "(", "BYTE", "*", "str", ",", "IP_ADDR", "*", "IPAddress", ")", "{", "DWORD_VAL", "dwVal", ";", "BYTE", "i", ",", "charLen", ",", "currentOctet", ";", "charLen", "=", "0", ";", "currentOctet", "=", "0", ";", "dwVal", ".", "Val", "=", "0", ";", "while", "(", "(", "i", "=", "*", "str", "++", ")", ")", "{", "if", "(", "currentOctet", ">", "3u", ")", "break", ";", "i", "-=", "'", "'", ";", "if", "(", "charLen", "==", "0u", ")", "{", "if", "(", "i", ">", "9u", ")", "return", "FALSE", ";", "}", "else", "if", "(", "charLen", "==", "3u", ")", "{", "if", "(", "i", "!=", "(", "BYTE", ")", "(", "'", "'", "-", "'", "'", ")", ")", "return", "FALSE", ";", "if", "(", "dwVal", ".", "Val", ">", "0x00020505ul", ")", "return", "FALSE", ";", "IPAddress", "->", "v", "[", "currentOctet", "++", "]", "=", "dwVal", ".", "v", "[", "2", "]", "*", "(", "(", "BYTE", ")", "100", ")", "+", "dwVal", ".", "v", "[", "1", "]", "*", "(", "(", "BYTE", ")", "10", ")", "+", "dwVal", ".", "v", "[", "0", "]", ";", "charLen", "=", "0", ";", "dwVal", ".", "Val", "=", "0", ";", "continue", ";", "}", "else", "{", "if", "(", "i", "==", "(", "BYTE", ")", "(", "'", "'", "-", "'", "'", ")", ")", "{", "if", "(", "dwVal", ".", "Val", ">", "0x00020505ul", ")", "return", "FALSE", ";", "IPAddress", "->", "v", "[", "currentOctet", "++", "]", "=", "dwVal", ".", "v", "[", "2", "]", "*", "(", "(", "BYTE", ")", "100", ")", "+", "dwVal", ".", "v", "[", "1", "]", "*", "(", "(", "BYTE", ")", "10", ")", "+", "dwVal", ".", "v", "[", "0", "]", ";", "charLen", "=", "0", ";", "dwVal", ".", "Val", "=", "0", ";", "continue", ";", "}", "if", "(", "i", ">", "9u", ")", "return", "FALSE", ";", "}", "charLen", "++", ";", "dwVal", ".", "Val", "<<=", "8", ";", "dwVal", ".", "v", "[", "0", "]", "=", "i", ";", "}", "if", "(", "i", "!=", "0u", "&&", "i", "!=", "'", "'", "&&", "i", "!=", "'", "\\r", "'", "&&", "i", "!=", "'", "\\n", "'", "&&", "i", "!=", "'", "'", "&&", "i", "!=", "'", "\\t", "'", "&&", "i", "!=", "'", "'", ")", "return", "FALSE", ";", "if", "(", "dwVal", ".", "Val", ">", "0x00020505ul", ")", "return", "FALSE", ";", "IPAddress", "->", "v", "[", "3", "]", "=", "dwVal", ".", "v", "[", "2", "]", "*", "(", "(", "BYTE", ")", "100", ")", "+", "dwVal", ".", "v", "[", "1", "]", "*", "(", "(", "BYTE", ")", "10", ")", "+", "dwVal", ".", "v", "[", "0", "]", ";", "return", "TRUE", ";", "}" ]

[ "Function", ":", "BOOL", "StringToIPAddress", "(", "BYTE", "*", "str", "IP_ADDR", "*", "IPAddress", ")" ]

[ "// Validate the character is a numerical digit or dot, depending on location", "// Make sure the very last character is a valid termination character ", "// (i.e., not more hostname, which could be legal and not an IP ", "// address as in \"10.5.13.233.picsaregood.com\"", "// Verify and convert the last octet and return the result" ]

[ { "param": "str", "type": "BYTE" }, { "param": "IPAddress", "type": "IP_ADDR" } ]

[ "BSD-3-Clause" ]

[ "void", "uitoa", "(", "WORD", "Value", "BYTE", "*", "Buffer", ")", "Converts", "an", "unsigned", "integer", "to", "a", "decimal", "string", ".", "Converts", "a", "16", "-", "bit", "unsigned", "integer", "to", "a", "null", "-", "terminated", "decimal", "string", ".", "None", "Value", "-", "The", "number", "to", "be", "converted", "Buffer", "-", "Pointer", "in", "which", "to", "store", "the", "converted", "string", "None" ]

[ "void", "uitoa", "(", "WORD", "Value", ",", "BYTE", "*", "Buffer", ")", "{", "BYTE", "i", ";", "WORD", "Digit", ";", "WORD", "Divisor", ";", "BOOL", "Printed", "=", "FALSE", ";", "if", "(", "Value", ")", "{", "for", "(", "i", "=", "0", ",", "Divisor", "=", "10000", ";", "i", "<", "5u", ";", "i", "++", ")", "{", "Digit", "=", "Value", "/", "Divisor", ";", "if", "(", "Digit", "||", "Printed", ")", "{", "*", "Buffer", "++", "=", "'", "'", "+", "Digit", ";", "Value", "-=", "Digit", "*", "Divisor", ";", "Printed", "=", "TRUE", ";", "}", "Divisor", "/=", "10", ";", "}", "}", "else", "{", "*", "Buffer", "++", "=", "'", "'", ";", "}", "*", "Buffer", "=", "'", "\\0", "'", ";", "}" ]

[ "Function", ":", "void", "uitoa", "(", "WORD", "Value", "BYTE", "*", "Buffer", ")" ]

[]

[ { "param": "Value", "type": "WORD" }, { "param": "Buffer", "type": "BYTE" } ]

[ "BSD-3-Clause" ]

[ "WORD", "CalcIPChecksum", "(", "BYTE", "*", "buffer", "WORD", "count", ")", "Calculates", "an", "IP", "checksum", "value", ".", "This", "function", "calculates", "an", "IP", "checksum", "over", "an", "array", "of", "input", "data", ".", "The", "checksum", "is", "the", "16", "-", "bit", "one", "'", "s", "complement", "of", "one", "'", "s", "complement", "sum", "of", "all", "words", "in", "the", "data", "(", "with", "zero", "-", "padding", "if", "an", "odd", "number", "of", "bytes", "are", "summed", ")", ".", "This", "checksum", "is", "defined", "in", "RFC", "793", ".", "buffer", "is", "WORD", "aligned", "(", "even", "memory", "address", ")", "on", "16", "-", "and", "32", "-", "bit", "PICs", ".", "pointer", "to", "the", "data", "to", "be", "checksummed", "count", "-", "number", "of", "bytes", "to", "be", "checksummed", "The", "calculated", "checksum", ".", "This", "function", "could", "be", "improved", "to", "do", "32", "-", "bit", "sums", "on", "PIC32", "platforms", "." ]

[ "WORD", "CalcIPChecksum", "(", "BYTE", "*", "buffer", ",", "WORD", "count", ")", "{", "WORD", "i", ";", "WORD", "*", "val", ";", "union", "{", "WORD", "w", "[", "2", "]", ";", "DWORD", "dw", ";", "}", "sum", ";", "i", "=", "count", ">>", "1", ";", "val", "=", "(", "WORD", "*", ")", "buffer", ";", "sum", ".", "dw", "=", "0x00000000ul", ";", "while", "(", "i", "--", ")", "sum", ".", "dw", "+=", "(", "DWORD", ")", "*", "val", "++", ";", "if", "(", "count", "&", "0x1", ")", "sum", ".", "dw", "+=", "(", "DWORD", ")", "*", "(", "BYTE", "*", ")", "val", ";", "sum", ".", "dw", "=", "(", "DWORD", ")", "sum", ".", "w", "[", "0", "]", "+", "(", "DWORD", ")", "sum", ".", "w", "[", "1", "]", ";", "sum", ".", "w", "[", "0", "]", "+=", "sum", ".", "w", "[", "1", "]", ";", "return", "~", "sum", ".", "w", "[", "0", "]", ";", "}" ]

[ "Function", ":", "WORD", "CalcIPChecksum", "(", "BYTE", "*", "buffer", "WORD", "count", ")" ]

[ "// Calculate the sum of all words", "// Add in the sum of the remaining byte, if present", "// Do an end-around carry (one's complement arrithmatic)", "// Do another end-around carry in case if the prior add ", "// caused a carry out", "// Return the resulting checksum" ]

[ { "param": "buffer", "type": "BYTE" }, { "param": "count", "type": "WORD" } ]

[ "BSD-3-Clause" ]

[ "Formats", "a", "string", "to", "a", "valid", "NetBIOS", "name", ".", "This", "function", "formats", "a", "string", "to", "a", "valid", "NetBIOS", "name", ".", "Names", "will", "be", "exactly", "16", "characters", "as", "defined", "by", "the", "NetBIOS", "spec", ".", "The", "16th", "character", "will", "be", "a", "0x00", "byte", "while", "the", "other", "15", "will", "be", "the", "provided", "string", "padded", "with", "spaces", "as", "necessary", ".", "None", "the", "string", "to", "format", "as", "a", "NetBIOS", "name", ".", "This", "parameter", "must", "have", "at", "least", "16", "bytes", "allocated", ".", "None" ]

[ "void", "FormatNetBIOSName", "(", "BYTE", "Name", "[", "]", ")", "{", "BYTE", "i", ";", "Name", "[", "15", "]", "=", "'", "\\0", "'", ";", "strupr", "(", "(", "char", "*", ")", "Name", ")", ";", "i", "=", "0", ";", "while", "(", "i", "<", "15u", ")", "{", "if", "(", "Name", "[", "i", "]", "==", "'", "\\0", "'", ")", "{", "while", "(", "i", "<", "15u", ")", "{", "Name", "[", "i", "++", "]", "=", "'", "'", ";", "}", "break", ";", "}", "i", "++", ";", "}", "}" ]

[ "Function", ":", "void", "FormatNetBIOSName", "(", "BYTE", "Name", "[]", ")" ]

[]

[ { "param": "Name", "type": "BYTE" } ]

[ "BSD-3-Clause" ]

[ "void", "DNSResolve", "(", "BYTE", "*", "Hostname", "BYTE", "Type", ")", "Begins", "resolution", "of", "an", "address", ".", "This", "function", "attempts", "to", "resolve", "a", "host", "name", "to", "an", "IP", "address", ".", "When", "called", "it", "starts", "the", "DNS", "state", "machine", ".", "Call", "DNSIsResolved", "repeatedly", "to", "determine", "if", "the", "resolution", "is", "complete", ".", "Only", "one", "DNS", "resoultion", "may", "be", "executed", "at", "a", "time", ".", "The", "Hostname", "must", "not", "be", "modified", "in", "memory", "until", "the", "resolution", "is", "complete", ".", "DNSBeginUsage", "returned", "TRUE", "on", "a", "previous", "call", ".", "A", "pointer", "to", "the", "null", "terminated", "string", "specifiying", "the", "host", "for", "which", "to", "resolve", "an", "IP", ".", "RecordType", "-", "DNS_TYPE_A", "or", "DNS_TYPE_MX", "depending", "on", "what", "type", "of", "record", "resolution", "is", "desired", ".", "None", "This", "function", "requires", "access", "to", "one", "UDP", "socket", ".", "If", "none", "are", "available", "MAX_UDP_SOCKETS", "may", "need", "to", "be", "increased", "." ]

[ "void", "DNSResolve", "(", "BYTE", "*", "Hostname", ",", "BYTE", "Type", ")", "{", "if", "(", "StringToIPAddress", "(", "Hostname", ",", "&", "ResolvedInfo", ".", "IPAddr", ")", ")", "{", "Flags", ".", "bits", ".", "AddressValid", "=", "TRUE", ";", "smDNS", "=", "DNS_DONE", ";", "}", "else", "{", "DNSHostName", "=", "Hostname", ";", "DNSHostNameROM", "=", "NULL", ";", "smDNS", "=", "DNS_START", ";", "RecordType", "=", "Type", ";", "Flags", ".", "bits", ".", "AddressValid", "=", "FALSE", ";", "}", "}" ]

[ "Function", ":", "void", "DNSResolve", "(", "BYTE", "*", "Hostname", "BYTE", "Type", ")" ]

[]

[ { "param": "Hostname", "type": "BYTE" }, { "param": "Type", "type": "BYTE" } ]

[ "BSD-3-Clause" ]

[ "Writes", "a", "string", "to", "the", "DNS", "socket", ".", "This", "function", "writes", "a", "string", "to", "the", "DNS", "socket", "ensuring", "that", "it", "is", "properly", "formatted", ".", "UDP", "socket", "is", "obtained", "and", "ready", "for", "writing", ".", "the", "string", "to", "write", "to", "the", "UDP", "socket", ".", "None" ]

[ "static", "void", "DNSPutString", "(", "BYTE", "*", "String", ")", "{", "BYTE", "*", "RightPtr", ";", "BYTE", "i", ";", "BYTE", "Len", ";", "RightPtr", "=", "String", ";", "while", "(", "1", ")", "{", "do", "{", "i", "=", "*", "RightPtr", "++", ";", "}", "while", "(", "(", "i", "!=", "0x00u", ")", "&&", "(", "i", "!=", "'", "'", ")", "&&", "(", "i", "!=", "'", "'", ")", "&&", "(", "i", "!=", "'", "'", ")", "&&", "(", "i", "!=", "'", "'", ")", ")", ";", "Len", "=", "(", "BYTE", ")", "(", "RightPtr", "-", "String", "-", "1", ")", ";", "UDPPut", "(", "Len", ")", ";", "String", "+=", "UDPPutArray", "(", "String", ",", "Len", ")", "+", "1", ";", "if", "(", "i", "==", "0x00u", "||", "i", "==", "'", "'", "||", "i", "==", "'", "'", "||", "i", "==", "'", "'", ")", "break", ";", "}", "UDPPut", "(", "0x00", ")", ";", "}" ]

[ "Function", ":", "static", "void", "DNSPutString", "(", "BYTE", "*", "String", ")" ]

[ "// Put the length and data", "// Also, skip over the '.' in the input string", "// Put the string null terminator character (zero length label)" ]

[ { "param": "String", "type": "BYTE" } ]

[ "BSD-3-Clause" ]

[ "Reads", "a", "name", "string", "or", "string", "pointer", "from", "the", "DNS", "socket", "and", "discards", "it", ".", "This", "function", "reads", "a", "name", "string", "from", "the", "DNS", "socket", ".", "Each", "string", "consists", "of", "a", "series", "of", "labels", ".", "Each", "label", "consists", "of", "a", "length", "prefix", "byte", "followed", "by", "the", "label", "bytes", ".", "At", "the", "end", "of", "the", "string", "a", "zero", "length", "label", "is", "found", "as", "termination", ".", "If", "name", "compression", "is", "used", "this", "function", "will", "automatically", "detect", "the", "pointer", "and", "discard", "it", ".", "UDP", "socket", "is", "obtained", "and", "ready", "for", "reading", "a", "DNS", "name", "None", "None" ]

[ "static", "void", "DNSDiscardName", "(", "void", ")", "{", "BYTE", "i", ";", "while", "(", "1", ")", "{", "if", "(", "!", "UDPGet", "(", "&", "i", ")", ")", "return", ";", "if", "(", "(", "i", "&", "0xC0u", ")", "==", "0xC0u", ")", "{", "UDPGet", "(", "&", "i", ")", ";", "return", ";", "}", "if", "(", "i", "==", "0u", ")", "return", ";", "UDPGetArray", "(", "NULL", ",", "i", ")", ";", "}", "}" ]

[ "Function", ":", "static", "void", "DNSDiscardName", "(", "void", ")" ]

[ "// Get first byte which will tell us if this is a 16-bit pointer or the ", "// length of the first of a series of labels", "// Check if this is a pointer, if so, get the reminaing 8 bits and return", "// Exit once we reach a zero length label", "// Discard complete label" ]

[]

[ "MIT" ]

[ "Path", "is", "either", "the", "/", "dev", "/", "node", "or", "the", "mountpoint" ]

[ "struct", "device_t", "*", "device_search", "(", "const", "char", "*", "path", ")", "{", "int", "j", ";", "device_t", "*", "dev", ";", "if", "(", "!", "path", ")", "return", "NULL", ";", "for", "(", "j", "=", "0", ";", "j", "<", "MAX_DEVICES", ";", "j", "++", ")", "{", "dev", "=", "g_devices", "[", "j", "]", ";", "if", "(", "dev", ")", "{", "if", "(", "!", "xstrcmp", "(", "dev", "->", "node", ",", "path", ")", "||", "!", "xstrcmp", "(", "dev", "->", "rnode", ",", "path", ")", "||", "!", "xstrcmp", "(", "dev", "->", "mountpoint", ",", "path", ")", ")", "return", "g_devices", "[", "j", "]", ";", "}", "}", "return", "NULL", ";", "}" ]

[ "Path", "is", "either", "the", "/", "dev", "/", "node", "or", "the", "mountpoint" ]

[]

[ { "param": "path", "type": "char" } ]

[ "MIT" ]

[ "Really", "basic", "way", "of", "creating", "a", "password" ]

[ "char", "*", "create_passwd", "(", "const", "size_t", "length", ",", "const", "int", "flags", ")", "{", "char", "*", "passwd", "=", "malloc", "(", "sizeof", "(", "char", ")", "*", "length", "+", "1", ")", ";", "size_t", "i", "=", "0", ";", "srand", "(", "time", "(", "NULL", ")", ")", ";", "while", "(", "i", "<", "length", ")", "{", "passwd", "[", "i", "]", "=", "rand", "(", ")", "%", "94", "+", "33", ";", "if", "(", "(", "isdigit", "(", "passwd", "[", "i", "]", ")", "&&", "flags", "&", "8", ")", "||", "(", "islower", "(", "passwd", "[", "i", "]", ")", "&&", "flags", "&", "4", ")", "||", "(", "isupper", "(", "passwd", "[", "i", "]", ")", "&&", "flags", "&", "2", ")", "||", "(", "ispunct", "(", "passwd", "[", "i", "]", ")", "&&", "flags", "&", "1", ")", ")", "continue", ";", "i", "++", ";", "}", "passwd", "[", "i", "]", "=", "'", "\\0", "'", ";", "return", "passwd", ";", "}" ]

[ "Really", "basic", "way", "of", "creating", "a", "password" ]

[ "/* TODO:\n * - secure_malloc;\n * - lock memory;\n */", "/* This if checks if the picked character is accepted or not */" ]

[ { "param": "length", "type": "size_t" }, { "param": "flags", "type": "int" } ]