SSH/SecureSerToEthFactoryApp/src/serialburnerdata.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef _SERIALBURNERDATA_H_
#define _SERIALBURNERDATA_H_
 
/*
 ******************************************************************************
 *
 * Include Files
 *
 ******************************************************************************
 */
#include <snmp.h>
#include <netbios.h>
#include <config_obj.h>
#include <netinterface.h>
#include <fdprintf.h>
#include "nbfactory.h"
#include "serialburnerdata.h"
 
/*
 ******************************************************************************
 *
 * Definitions
 *
 ******************************************************************************
 */
/* Constants that go with Protocol and selection list ProtocolList */
#define PROTOCOL_UDP_TO_SERIAL "UDP"
#define PROTOCOL_TCP_SSL_TO_SERIAL "TCP/SSL"
#define PROTOCOL_TCP_TO_SERIAL "TCP"
#define PROTOCOL_SSH "SSH"
 
/* Constants that go with SerialMode and selection list SerialModeList */
#define SERIAL_MODE_RS232 "RS-232"
#define SERIAL_MODE_DEBUG "DEBUG"
#define SERIAL_MODE_485H "RS-485 Half Duplex"
#define SERIAL_MODE_485F "RS-485 Full Duplex"
#define SERIAL_MODE_422F "RS-422 Full Duplex"
#define SERIAL_MODE_485H_ECHO "RS-485 Half Duplex with Echo" // Used by PK70 quad UART blade board - S/W configurable
#define SERIAL_MODE_485H_NOECHO "RS-485 Half Duplex without Echo" // Used by PK70 quad UART blade board - S/W configurable
#define SERIAL_MODE_DISABLED "Disabled"
 
#define SERIAL_MODE_DISABLED_PINS_OUTPUT_HIGH "Output High"
#define SERIAL_MODE_DISABLED_PINS_OUTPUT_LOW "Output Low"
#define SERIAL_MODE_DISABLED_PINS_HIZ "High Impedance"
 
/* Constants that go with serial FlowMode and selection list FlowModeList */
#define SERIAL_FLOW_MODE_NONE "None"
#define SERIAL_FLOW_MODE_XON_OFF "XON/XOFF"
#define SERIAL_FLOW_MODE_RTS_CTS "RTS/CTS"
 
/* Constants that go with serial ConnectMode */
#define SERIAL_CONNECT_CONNECT_NEVER "Never"
#define SERIAL_CONNECT_CONNECT_AT_POWERUP "On power-up"
#define SERIAL_CONNECT_CONNECT_WHEN_DATARX "If serial data received"
 
/* Constants that go with IP_Addr_mode */
/* These strings need to match the string defined in the ip4.mode config_chooser variable defined in the InterfaceBlock */
#define IP_ADDR_MODE_DHCP "DHCP"
#define IP_ADDR_MODE_DHCP_W_FALLBACK "DHCP w Fallback"
#define IP_ADDR_MODE_STATIC "Static"
#define IP_ADDR_MODE_DISABLED "Disabled"
 
/* Constants that go with character strings */
#define CONNECT_NAME_LENGTH (79)
#define CONNECT_MESSAGE_LENGTH (79)
#define CONNECT_LOSS_MESSAGE_LENGTH (79)
#define DEVICE_NAME_LENGTH (15)
#define NTP_NAME_LENGTH (35)
#define USERNAME_LENGTH (39)
#define PASSWORD_LENGTH (39)
#define MAX_NUMERICAL_USER_INPUT_LENTH (32)
#define MAX_STRING_USER_INPUT_LENTH (64)
 
/* Constants that define buffer sizes */
#define MAX_UDP_RX_BUFFER (1500)
#define BUFFER_SIZE (20000)
 
/* Constants that define task priorities */
#define LED_TASK_PRIO (MAIN_PRIO - 1)
#define SNMP_PRIO (MAIN_PRIO - 2)
#define AT_COM_PRIO (MAIN_PRIO - 3)
#define I2C_SERVER_TASK_PRIO (MAIN_PRIO + 1)
#define GPIO_SERVER_TASK_PRIO (MAIN_PRIO + 2)
#define START_WIFI_TASK_PRIO (OS_MAX_PRIOS - 2)
 
#ifdef NB_FACTORY_INCLUDE_SSH
 
/* Constants that go with SSH character strings */
#define SSH_USERNAME_LENGTH (39)
#define SSH_PASSWORD_LENGTH (39)
 
#endif /* #ifdef NB_FACTORY_INCLUDE_SSH */
 
extern MonitorRecord monitor_config;
 
#ifdef NB_FACTORY_INCLUDE_SSL
 
/*
 ******************************************************************************
 * Key or certificate size
 * SSL Certificate size 2200 (empirical)
 * OpenSSL format is Privacy-enhanced Electronic Mail (PEM) encoded
 * NULL terminated for conversion
 *
 ******************************************************************************
 */
#define SERIAL_BURNER_CERTIFICATE_SIZE_MAX ((2 * 1024) - 1)
#define SERIAL_BURNER_CERTIFICATE_SIZE_MAX_PEM ((3 * 1024) - 1)
 
#endif /* #ifdef NB_FACTORY_INCLUDE_SSL */
 
#if defined(NB_FACTORY_INCLUDE_SSH) || defined(NB_FACTORY_INCLUDE_SSL)
 
/* Certificate and key status */
#define SERIAL_BURNER_LIBRARY_DEFAULT ((uint8_t)0x00)
#define SERIAL_BURNER_DEFAULT ((uint8_t)0x01)
#define SERIAL_BURNER_USER_INSTALLED ((uint8_t)0x02)
 
/*
 ******************************************************************************
 * Key size
 * SSH MAX_PRIVKEY_SIZE 1700 (options.h)
 * SSH key size (PEM) < 4K (empirical)
 * NULL terminated for conversion
 *
 ******************************************************************************
 */
#define SERIAL_BURNER_KEY_SIZE_MAX_PEM ((4 * 1024) - 1)
 
#endif /* #if defined(NB_FACTORY_INCLUDE_SSH) || defined(NB_FACTORY_INCLUDE_SSL) */
/*
 ******************************************************************************
 * HTML support
 ******************************************************************************
 */
/* HTML data sizes */
#define SERIAL_BURNER_HTML_INPUT_NUMBER_SIZE (5)
 
/* HTML data sizes */
#define SERIAL_BURNER_HTML_HEX_NUMBER_LENGTH (2)
 
/* The following defines the webpage table width in percentage of the column that
 * includes text description of each input field. It allows platforms with two
 * ports or less to use more of the table width to fit text, improving readability.
 */
#if ((NB_FACTORY_SERIAL_PORTS + NB_FACTORY_I2C_PORTS) <= 2)
#define SERIAL_BURNER_DESCRIPTION_COLUMN_WIDTH_PERCENT (40)
#else
#define SERIAL_BURNER_DESCRIPTION_COLUMN_WIDTH_PERCENT (30)
#endif
 
#define SERIAL_BURNER_PORT_COLUMN_WIDTH_PERCENT ((100 - SERIAL_BURNER_DESCRIPTION_COLUMN_WIDTH_PERCENT) / (NB_FACTORY_SERIAL_PORTS + NB_FACTORY_I2C_PORTS))
 
/* HTML I2C column width percentage */
#define SERIAL_BURNER_HTML_I2C_WIDTH (70)
 
/* HTML input name maximum size */
#define SERIAL_BURNER_HTML_INPUT_SIZE (39)
 
/* HTML IP address string size */
#define SERIAL_BURNER_HTML_IP_STRING_SIZE (20)
 
/* Password protection string (SSH_PASSWORD_LENGTH length ) */
#define SERIAL_BURNER_PASSWORD_STRING "*******************"
 
/*
 ******************************************************************************
 * Booting support
 ******************************************************************************
 */
#define boot_iprintf(...) \
 { \
 if (monitor_config.Quiet == 0) \
 { \
 int ifNum = GetFirstInterface(); \
 InterfaceBlock *pIfB = GetInterfaceBlock(ifNum); \
 if (pIfB != nullptr) \
 { \
 iprintf("%s : ", pIfB->device_name.c_str()); \
 iprintf(__VA_ARGS__); \
 iprintf("\r\n"); \
 } \
 } \
 }
 
/*
 ******************************************************************************
 * Debug support
 ******************************************************************************
 */
#define debug_iprintf(...) \
 { \
 if (bShowDebug == true) \
 { \
 int ifNum = GetFirstInterface(); \
 InterfaceBlock *pIfB = GetInterfaceBlock(ifNum); \
 if (pIfB != nullptr) \
 { \
 iprintf("%s [debug] : ", pIfB->device_name.c_str()); \
 iprintf(__VA_ARGS__); \
 iprintf("\r\n"); \
 } \
 } \
 }
 
/*
 ******************************************************************************
 *
 * Structures
 *
 ******************************************************************************
 */
// #ifndef SNMP
// #include <snmp.h>
// struct SysInfo
// {
// char SysContact[ 256 ];
// char SysName[ 256 ];
// char SysLocation[ 256 ];
// unsigned char ReadCommunity[ 40 ];
// unsigned char WriteCommunity[ 40 ];
// IPADDR trap_destination;
// uint32_t trap_enable_flags;
// uint32_t valid;
// };
// #endif /* SNMP */
 
#ifndef SNMP
#include <snmp.h>
class SysInfo : public config_obj
{
 public:
 config_string SysContact{"", "Sys Contact"};
 config_string SysName{"", "Sys Name"};
 config_string SysLocation{"", "Sys Location"};
 config_string ReadCommunity{"", "Read Community"};
 config_string WriteCommunity{"", "Write Community"};
 config_IPADDR4 trap_destination{"", "Trap Destination"};
 config_uint trap_enable_flags{0, "Trap Enable Flags"};
 config_uint valid{0, "Valid"};
 ConfigEndMarker;
 
 SysInfo(const char *name, const char *desc = nullptr) : config_obj(name, desc){};
 SysInfo(config_obj &owner, const char *name, const char *desc = nullptr) : config_obj(owner, name, desc){};
 SysInfo & operator=(const SysInfo & si)
 {
 SysContact = si.SysContact;
 SysName = si.SysName;
 SysLocation = si.SysLocation;
 ReadCommunity = si.ReadCommunity;
 WriteCommunity = si.WriteCommunity;
 trap_destination = si.trap_destination;
 trap_enable_flags = si.trap_enable_flags;
 valid = si.valid;
 
 return *this;
 }
};
#endif /* SNMP */
 
/*
 Port Setting (Protocol)
 
 * Listening socket (All) *
 ListenPort - Listen port
 InactivityTimeoutInSecs - Inactivity timeout in seconds
 New_connection_timeout - Connection timeout
 ConnectMode - Serial connect mode
 
 * Connect on power-up and received serial data choices (TCP) *
 ConnectPort - Port
 ConnectName - Target name for GetHostByName
 ConnectAddress - Target IP address
 ConnectIdleTimeout - Idle timeout in seconds
 Connection_retry_timeout- Retry interval in seconds
 keepAliveInterval - Check and maintain the connection in second intervals
 
 * Primary connection settings - serial port settings (All) *
 SerialMode - Type port
 DataBaudRate - Baud rate
 Output_Bits - Data bits per byte
 Output_Parity - Parity
 Output_Stop - Stop bits
 FlowMode - Flow control
 
 * Primary connection settings - serial data notification settings (TCP, UDP) *
 ConnectMessage - Serial message upon connection
 ConnectLossMessage - Serial message upon connection loss
 BreakOnConnect - Send serial break on connection
 BreakInterval - Break interval
 BreakKeyFlag - Send data then a break
 BreakKeyValue - Data prior to break
 
 * UDP *
 UdpAccumulatedChars - Char. to accumulate before sending packet
 UdpWait - Accumulation wait in ticks
 UdpTriggerChar - Flushing character
 bLearnUdp - Learn IP address from connection
 bUdpCheckFramingChar - UDP framing character to check
 
 * Custom Framing (TCP, SSH) *
 bTcpCustomFrame - Enabled?
 TcpAccumulatedChars - Char. to accumulate before sending packet
 TcpWait - Accumulation wait in ticks
 TcpTriggerChar - Serial flushing character
 
 * Framing (TCP) *
 bTcpCheckFramingChar - TCP framing character to check
 
*/
class NV_OnePortSetting : public config_obj
{
 public:
 config_uint ListenPort{NB_FACTORY_LISTEN_PORT_DEFAULT, "Listen Port"};
 config_uint InactivityTimeoutInSecs{NB_FACTORY_INACTIVITY_TIMEOUT_DEFAULT, "Inactivity Timeout(seconds)"};
 config_uint New_connection_timeout{NB_FACTORY_NEW_CONNECTION_TIMEOUT_DEFAULT, "New Connection Timeout(seconds)"};
 config_chooser ConnectMode{"Connect Mode", "Never", "Never,On power-up,If serial data received"};
 config_uint ConnectPort{NB_FACTORY_CONNECT_PORT_DEFAULT, "Connect Port"};
 config_string ConnectName1{"", "Connect Name 1"};
 config_string ConnectName2{"", "Connect Name 2"};
 config_IPADDR4 ConnectAddress1{"0.0.0.0", "Connect Address 1"};
 config_IPADDR4 ConnectAddress2{"0.0.0.0", "Connect Address 2"};
 config_uint ConnectIdleTimeout{NB_CONNECT_IDLE_TIMEOUT_DEFAULT, "Connect Idle Timeout(seconds)"};
 config_uint Connection_retry_timeout{NB_CONNECT_RETRY_TIMEOUT_DEFAULT, "Connection Retry Timeout(seconds)"};
 config_uint keepAliveInterval{NB_CONENCT_KEEP_ALIVE_INTERVAL_DEFAULT, "Keep Alive Interval(seconds)"};
 // Port-TODO: Hook in system serial port configurations so that any change made in the Factory App also change the system's serial port
 // config variable.
 config_chooser SerialMode{"Serial Mode", NB_FACTORY_DEFAULT_SERIAL_MODE, NB_FACTORY_SERIAL_CAPABILITY_RS232};
 config_chooser DataBaudRate{
 "Data Baud Rate", NB_FACTORY_SERIAL_DATA_RATE_DEFAULT,
 "921600,500000,460800,345600,256000,230400,128000,115200,57600,38400,32000,19200,9600,4800,2400,1200,Custom"};
 config_uint CustomBaudRate{NB_FACTORY_SERIAL_CUSTOM_DATA_RATE_DEFAULT, "Custom Baudrate"};
 config_chooser Output_Bits{"Output Bits", NB_FACTORY_SERIAL_DATA_BITS_DEFAULT, "8,7,6,5"};
 config_chooser Output_Parity{"Output Parity", NB_FACTORY_SERIAL_PARITY_DEFAULT, "None,Odd,Even"};
 config_chooser Output_Stop{"Output Stop", NB_FACTORY_SERIAL_STOP_BITS_DEFAULT, "1,2"};
 config_chooser FlowMode{"Flow Control Mode", NB_FACTORY_SERIAL_FLOW_CONTROL_DEFAULT, "None,XON/XOFF,RTS/CTS"};
 config_bool bDoAtCommand{NB_FACTORY_DO_AT_COMMANDS_DEFAULT, "Do AT Commands"};
 config_chooser DisabledPortPinFunction{"Disabled Port Pin Function", NB_FACTORY_DISABLED_SER_PORT_PIN_FUNC_DEFAULT, "Output High,Output Low,High Impedance"};
 config_string ConnectMessage{"", "Connect Message"};
 config_bool bUseConnectMessage{NB_FACTORY_USE_CONNECT_MSG_DEFAULT, "Use the Configured Connect Message"};
 config_string ConnectLossMessage{"", "Lost Connection Message"};
 config_bool bUseConnectLossMessage{NB_FACTORY_USE_CONNECTION_LOST_MSG_DEFAULT, "Use the Configured Lost Connection Message"};
 config_bool BreakOnConnect{NB_FACTORY_BREAK_ON_CONNECT_DEFAULT, "Break On Connect"};
 config_uint BreakInterval{NB_FACTORY_BREAK_INTERVAL_DEFAULT, "Break Interval"};
 config_bool BreakKeyFlag{NB_FACTORY_BREAK_KEY_FLAG_DEFAULT, "Break Key Flag"};
 config_string BreakKeyValue{NB_FACTORY_BREAK_KEY_VALUE_DEFAULT, "Break Key Value"};
 config_uint UdpAccumulatedChars{NB_FACTORY_ACCUMULATED_CHARS_UDP_DEFAULT, "UDP Accumulated Chars"};
 config_uint UdpWait{NB_FACTORY_WAIT_UDP_IN_TICKS_DEFAULT, "UDP Wait(ticks)"};
 config_uint TcpAccumulatedChars{NB_FACTORY_ACCUMULATED_CHARS_TCP_DEFAULT, "TCP Accumulated Chars"};
 config_uint TcpWait{NB_FACTORY_WAIT_TCP_IN_TICKS_DEFAULT, "TCP Wait(ticks)"};
 config_string UdpTriggerChar{NB_FACTORY_TRIGGER_CHAR_UDP_DEFAULT,
 "UDP Trigger Character"};
 config_string TcpTriggerChar{NB_FACTORY_TRIGGER_CHAR_TCP_DEFAULT,
 "TCP Trigger Character"}; // Port-TODO: need to test char to config_uint comparison when parsing
 config_bool bListenForTCPConnections{NB_FACTORY_LISTEN_FOR_TCP_CONNECT_DEFAULT, "Listen for incoming network connections"};
 config_bool bTcpCustomFrame{NB_FACTORY_CUSTOM_FRAME_TCP_DEFAULT, "TCP Custom Frame"};
 config_bool bLearnUdp{NB_FACTORY_LEARN_UDP_DEFAULT, "Learn UDP"};
 config_bool bUdpCheckFramingChar{NB_FACTORY_CHECK_FRAMING_CHAR_UDP_DEFAULT, "Check UDP Framing Character"};
 config_bool bTcpCheckFramingChar{NB_FACTORY_CHECK_FRAMING_CHAR_TCP_DEFAULT, "Check TCP Framing Character"};
 config_bool bAlwaysStoreSerialChars{false, "Always Store Serial Characters"};
#ifdef SB800EX
 config_bool bDTRReflectsConnection{false, "DTR Reflects Connection"}; // Port-TODO: requires logic based on port number to initialize. See setDefaultsForUDP()
#endif /* SB800EX */
 config_bool bTCPasSSL{false, "Allow SSL on TCP Socket"};
 ConfigEndMarker;
 
 NV_OnePortSetting(const char *name,
 const char *desc = nullptr,
 const char *serialMode = nullptr,
 const char *serialModeChoices = nullptr)
 : config_obj(name, desc)
 {
 if (serialModeChoices != nullptr) { SerialMode.SetChoices(serialModeChoices); }
 if (serialMode != nullptr)
 {
 SerialMode = serialMode;
 
 if (strncmp(serialMode, SERIAL_MODE_DEBUG, sizeof(SERIAL_MODE_DEBUG)) == 0)
 {
 // Disable AT command parser on a debug serial port
 bDoAtCommand = false;
 }
 }
 };
 
 NV_OnePortSetting(config_obj &owner,
 const char *name,
 const char *desc = nullptr,
 const char *serialMode = nullptr,
 const char *serialModeChoices = nullptr)
 : config_obj(owner, name, desc)
 {
 if (serialModeChoices != nullptr) { SerialMode.SetChoices(serialModeChoices); }
 if (serialMode != nullptr)
 {
 SerialMode = serialMode;
 
 if (strncmp(serialMode, SERIAL_MODE_DEBUG, sizeof(SERIAL_MODE_DEBUG)) == 0)
 {
 // Disable AT command parser on a debug serial port
 bDoAtCommand = false;
 }
 }
 };
};
 
/* ic - The byte value written to the I2FDR register of the processor
 * to reach a desired frequency divider. Used with InitI2C() to
 * initialize the bus to a particular I2C bus speed
 * FreqDivider - The frequency divider that corresponds to the byte value in ic.
 * For a table of ic-frequency divider pairs, refer to the reference manual for the
 * processor - specifically, refer to the I2FDR section of the
 * I2C chapter.
 */
class NV_OneI2CPortSetting : public config_obj
{
 public:
 // I2C parameters
 config_uint ic{NB_FACTORY_I2C_IC_DEFAULT, "ic"};
 config_uint FreqDivider{NB_FACTORY_I2C_FREQ_DIVIDER_DEFAULT, "Frequency Divider"};
 config_uint CustomBaudRate{0, "Custom Baud Rate"};
 config_uint BusSpeed{100000, "I2C Bus Speed"};
 config_uint SetMasterAddress{NB_FACTORY_I2C_ADDRESS_DEFAULT, "Set Master Address"};
 config_uint SaveMasterAddress{NB_FACTORY_I2C_ADDRESS_DEFAULT, "Save Master Address"};
 
 // TCP parameters
 config_uint ListenPort{NB_FACTORY_I2C_LISTEN_PORT_DEFAULT, "Listen Port"};
 config_bool bListenCheck{NB_FACTORY_LISTEN_FOR_TCP_CONNECT_DEFAULT, "Listen for incoming network connections"};
 config_uint InactivityTimeoutInSecs{NB_FACTORY_INACTIVITY_TIMEOUT_DEFAULT, "Inactivity Timeout(seconds)"};
 config_uint New_connection_timeout{NB_FACTORY_NEW_CONNECTION_TIMEOUT_DEFAULT, "New Connection Timeout(seconds)"};
 config_uint ConnectIdleTimeout{NB_CONNECT_IDLE_TIMEOUT_DEFAULT, "Connect Idle Timeout(seconds)"};
 config_bool bTCPasSSL{false, "Allow TCP as SSL"};
 ConfigEndMarker;
 
 NV_OneI2CPortSetting(const char *name, const char *desc = nullptr) : config_obj(name, desc){};
 NV_OneI2CPortSetting(config_obj &owner, const char *name, const char *desc = nullptr) : config_obj(owner, name, desc){};
};
 
/* Refer to the I2FDR section of the reference manual for the processor in use
 * for a table of dividers and the respective ICs's */
struct BaudRate
{
 unsigned char ic;
 int divider;
};
 
 
extern const char* defaultSerialPortModes[];
 
class NV_SettingsStruct : public config_obj
{
 public:
 /* NetBurner protocol */
 config_chooser Protocol{"Protocol", "TCP/SSL", "UDP,TCP/SSL,SSH,TCP"};
 config_chooser ConnectMode{"Connect Mode", "Never", "Never,On power-up,If serial data received"};
 
 /* NetBurner address configuration */
 config_string NTPName{NB_FACTORY_NTPSERVERNAME_DEFAULT, "NTP Name"}; // NTPName[ NTP_NAME_LENGTH+ 1 ];
 config_IPADDR4 NTP_Addr{"0.0.0.0", "NTP IPv4 Address"};
 
 NV_OnePortSetting port0{"Serial Port 0", nullptr, defaultSerialPortModes[0], NB_FACTORY_SERIAL_PORT_0_MODE_CAPABILITY};
#if !(defined SOMRT1061)
 NV_OnePortSetting port1{"Serial Port 1", nullptr, defaultSerialPortModes[1], NB_FACTORY_SERIAL_PORT_1_MODE_CAPABILITY};
#endif
 
#if (defined NANO54415)
 NV_OnePortSetting port2{"Serial Port 2", nullptr, defaultSerialPortModes[2], NB_FACTORY_SERIAL_PORT_2_MODE_CAPABILITY};
 NV_OnePortSetting port3{"Serial Port 3", nullptr, defaultSerialPortModes[3], NB_FACTORY_SERIAL_PORT_3_MODE_CAPABILITY};
 NV_OnePortSetting port4{"Serial Port 4", nullptr, defaultSerialPortModes[4], NB_FACTORY_SERIAL_PORT_4_MODE_CAPABILITY};
#elif ((defined MODM7AE70 && defined USE_E70_UART_SERIAL_PORTS))
 NV_OnePortSetting port2{"Serial Port 2", nullptr, defaultSerialPortModes[2], NB_FACTORY_SERIAL_PORT_2_MODE_CAPABILITY};
 NV_OnePortSetting port3{"Serial Port 3", nullptr, defaultSerialPortModes[3], NB_FACTORY_SERIAL_PORT_3_MODE_CAPABILITY};
 NV_OnePortSetting port4{"Serial Port 4", nullptr, defaultSerialPortModes[4], NB_FACTORY_SERIAL_PORT_4_MODE_CAPABILITY};
 NV_OnePortSetting port5{"Serial Port 5", nullptr, defaultSerialPortModes[5], NB_FACTORY_SERIAL_PORT_5_MODE_CAPABILITY};
 NV_OnePortSetting port6{"Serial Port 6", nullptr, defaultSerialPortModes[6], NB_FACTORY_SERIAL_PORT_6_MODE_CAPABILITY};
#elif ( defined SOMRT1061 )
 NV_OnePortSetting port1{"Serial Port 1", nullptr, defaultSerialPortModes[1], NB_FACTORY_SERIAL_PORT_1_MODE_CAPABILITY};
 NV_OnePortSetting port2{"Serial Port 2", nullptr, defaultSerialPortModes[2], NB_FACTORY_SERIAL_PORT_2_MODE_CAPABILITY};
 NV_OnePortSetting port3{"Serial Port 3", nullptr, defaultSerialPortModes[3], NB_FACTORY_SERIAL_PORT_3_MODE_CAPABILITY};
 NV_OnePortSetting port4{"Serial Port 4", nullptr, defaultSerialPortModes[4], NB_FACTORY_SERIAL_PORT_4_MODE_CAPABILITY};
 NV_OnePortSetting port5{"Serial Port 5", nullptr, defaultSerialPortModes[5], NB_FACTORY_SERIAL_PORT_5_MODE_CAPABILITY};
 NV_OnePortSetting port6{"Serial Port 6", nullptr, defaultSerialPortModes[6], NB_FACTORY_SERIAL_PORT_6_MODE_CAPABILITY};
#endif
 
#ifdef SUPPORTED_GPIO_SERVER_PLATFORM
 config_bool bEnableGpioProcess{NB_FACTORY_DO_GPIO_COMMANDS_DEFAULT, "bEnableGpioProcess"};
 config_bool bEnableHighDrive{NB_FACTORY_ENABLE_GPIO_HI_DRIVE_DEFAULT, "bEnableHighDrive"};
 config_uint GpioProcessPort{NB_FACTORY_GPIO_PORT_DEFAULT, "GpioProcessPort"};
 config_uint GpioInactivityTimeoutInSecs{NB_CONNECT_IDLE_TIMEOUT_DEFAULT, "Inactivity timeout in seconds"};
 config_uint GpioMaxConnections{NB_MAX_TCP_CONNECTIONS, "Max simultaneous connections"};
 config_bool bSaveGpioToFlash{
 NB_FACTORY_GPIO_SAVE_TO_FLASH_DEFAULT,
 "Save every change to a pin's setting/state to flash. This will use more flash write cycles if a pin is modified often."};
#endif
 
 SysInfo SysInfoData{"SNMP_SysInfo"};
 
 /* I2C address */
 config_string slaveI2CAddress{"", "I2C Slave Address"}; // char slaveI2CAddress[3];
 
#if (defined SUPPORTED_I2C_PLATFORM)
 NV_OneI2CPortSetting i2c_port{"I2C Configuration"};
#endif
 
#ifdef NB_FACTORY_INCLUDE_SSL
 
 /* SSL certificate and keys file lengths */
 config_uint SslCertificateSource{SERIAL_BURNER_LIBRARY_DEFAULT, "SSL Certificate Source"};
 config_uint SslCertificateLength{0, "SSL Certificate Length"};
 config_uint SslKeyLength{0, "SSL Key Length"};
 
#endif /* #ifdef NB_FACTORY_INCLUDE_SSL */
 
#ifdef NB_FACTORY_INCLUDE_SSH
 
 /* SSH user name and password */
 config_pass SshUserName{"", "SSH User Name"};
 config_pass SshPassword{"", "SSH Password"};
 
 /* SSH key source and lengths (default and user installed) */
 config_uint SshKeyRsaSource{SERIAL_BURNER_LIBRARY_DEFAULT, "SSH Key RSA Source"};
 config_uint SshKeyRsaLength{0, "SSH Key RSA Length"};
 config_uint SshKeyEcdsaSource{SERIAL_BURNER_LIBRARY_DEFAULT, "SSH Key ECDSA Source"};
 config_uint SshKeyEcdsaLength{0, "SSH Key ECDSA Length"};
 
#endif /* #ifdef NB_FACTORY_INCLUDE_SSH */
 
 config_bool bAllowAtToAccessAPassword{true, "Allow AT to Access A Password"};
 config_bool bAllowAtToAccessSPassword{true, "Allow AT to Access S Password"};
 
 /* Version verification key */
 config_uint VerifyKey{NB_FACTORY_VERIFY_KEY, "App Version Verification Key"};
 
 /* Flash File System Version verification key */
 config_uint STDEFFSVerifyKey{STD_EFFS_VERIFY_KEY, "File System Version Verification Key"};
 
 config_bool bFirstRun{true, "First time loading the SS2E Factory app on this device"};
 ConfigEndMarker;
 
 NV_OnePortSetting *ports[NB_FACTORY_SERIAL_PORTS];
 
 NV_SettingsStruct(const char *name, const char *desc = nullptr, uint32_t configFlag = 0) : config_obj(name, desc)
 {
 if (configFlag > 0) { SetFlag(configFlag); }
 // SetFlag(fConfigHidden); // hide from the config server
 
 ports[0] = &port0;
 ports[1] = &port1;
 
#if (defined NANO54415)
 ports[2] = &port2;
 ports[3] = &port3;
 ports[4] = &port4;
#elif ((defined MODM7AE70 && defined USE_E70_UART_SERIAL_PORTS) || (defined SOMRT1061) )
 ports[2] = &port2;
 ports[3] = &port3;
 ports[4] = &port4;
 ports[5] = &port5;
 ports[6] = &port6;
#endif
 
 #ifdef SB800EX
 // SB800EX serial ports are numbered 1 and 2, not 0 and 1
 ports[(int)(monitor_config.Uart) - 1]->SerialMode = SERIAL_MODE_DEBUG;
 #else
 ports[(int)(monitor_config.Uart)]->SerialMode = SERIAL_MODE_DEBUG;
 #endif
 
 for (uint8_t i = 1; i < NB_FACTORY_SERIAL_PORTS; i++)
 {
 // intentionally skip port 0 since it's initialized with a default value
 ports[i]->ListenPort = ports[i]->ListenPort + i;
 ports[i]->ConnectPort = ports[i]->ConnectPort + i;
 }
 };
 
 NV_SettingsStruct(config_obj &owner, const char *name, const char *desc = nullptr, uint32_t configFlag = 0)
 : config_obj(owner, name, desc)
 {
 if (configFlag > 0) { SetFlag(configFlag); }
 // SetFlag(fConfigHidden);
 
 ports[0] = &port0;
 ports[1] = &port1;
 
#if (defined NANO54415)
 ports[2] = &port2;
 ports[3] = &port3;
 ports[4] = &port4;
#elif ((defined MODM7AE70 && defined USE_E70_UART_SERIAL_PORTS) || (defined SOMRT1061) )
 ports[2] = &port2;
 ports[3] = &port3;
 ports[4] = &port4;
 ports[5] = &port5;
 ports[6] = &port6;
#endif
 
 #ifdef SB800EX
 // SB800EX serial ports are numbered 1 and 2, not 0 and 1
 ports[(int)(monitor_config.Uart) - 1]->SerialMode = SERIAL_MODE_DEBUG;
 #else
 ports[(int)(monitor_config.Uart)]->SerialMode = SERIAL_MODE_DEBUG;
 #endif
 
 for (uint8_t i = 1; i < NB_FACTORY_SERIAL_PORTS; i++)
 {
 // intentionally skip port 0 since it's initialized with a default value
 ports[i]->ListenPort = ports[i]->ListenPort + i;
 ports[i]->ConnectPort = ports[i]->ConnectPort + i;
 }
 };
};
 
#ifdef SUPPORTED_GPIO_SERVER_PLATFORM
#include <cpu_pins.h>
#include <pins.h>
#include <htmlfiles.h>
class NV_PinIOConfig : public config_obj
{
 public:
 config_chooser cc_pinFunction{"Function", "Not Configured", "Not Configured,GPIO Input,GPIO Output 0,GPIO Output 1"};
 config_string cs_currentState{"Not Configured", "Current State"};
 
 ConfigEndMarker;
 
 typedef enum
 {
 PIN_FN_NO_CONFIG = 0, 
 PIN_FN_IN, 
 PIN_FN_OUT_0, 
 PIN_FN_OUT_1, 
 PIN_FN_A, 
 PIN_FN_B, 
 PIN_FN_C, 
 PIN_FN_D 
 } pin_fn_t;
 
 uint8_t m_headerNum;
 uint8_t m_pinNum;
 uint32_t m_configFlags;
 PinIO m_pinIO;
 
 NV_PinIOConfig(const char *name,
 PinIO pin,
 const char *desc = nullptr,
 uint8_t headerNumber = 0,
 uint8_t pinNumber = 0,
 const char *pinFuncSelection = nullptr,
 const char *pinFunctionChoices = nullptr,
 uint32_t configFlag = 0)
 : m_pinIO(pin), config_obj(name, desc)
 {
 if (configFlag) { SetFlag(configFlag); }
 if (pinFunctionChoices != nullptr) { cc_pinFunction.SetChoices(pinFunctionChoices); }
 if (pinFuncSelection != nullptr) { cc_pinFunction = pinFuncSelection; }
 
 m_headerNum = headerNumber;
 m_pinNum = pinNumber;
 m_configFlags = configFlag;
 
 if (m_pinIO.mask == 0) // pin is not modifiable. Ex: GND, VCC, or not a valid header pin
 {
 SetFlag(fConfigReadOnly);
 cc_pinFunction.SetChoices("Fixed");
 cc_pinFunction = "Fixed";
 }
 }
 
 NV_PinIOConfig(config_obj &owner,
 const char *name,
 PinIO pin,
 const char *desc = nullptr,
 uint8_t headerNumber = 0,
 uint8_t pinNumber = 0,
 const char *pinFuncSelection = nullptr,
 const char *pinFunctionChoices = nullptr,
 uint32_t configFlag = 0)
 : m_pinIO(pin), config_obj(owner, name, desc)
 {
 if (configFlag > 0) { SetFlag(configFlag); }
 if (pinFunctionChoices != nullptr) { cc_pinFunction.SetChoices(pinFunctionChoices); }
 if (pinFuncSelection != nullptr) { cc_pinFunction = pinFuncSelection; }
 
 m_headerNum = headerNumber;
 m_pinNum = pinNumber;
 m_configFlags = configFlag;
 
 if (m_pinIO.mask == 0) // pin is not modifiable. Ex: GND, VCC, or not a valid header pin
 {
 SetFlag(fConfigReadOnly);
 cc_pinFunction.SetChoices("Fixed");
 cc_pinFunction = "Fixed";
 }
 }
 
 /* It is assumed that a valid NV_PinIOConfig will have a name. An invalid
 * NV_PinIOConfig, like an end marker, will have a nullptr name value */
 inline bool valid() { return pName != nullptr; }
 
 bool ConfigureFromPinIOFunction()
 {
 int8_t pin_fn = m_pinIO.getFn();
 if (pin_fn < 0) { return false; }
 
 // check if the pin has already been configured for a function other than GPIO
 // if the PinIO is not configured for a peripheral function, allow it to be configured
 
 // if the PinIO is already configured for a peripheral function, what should we do?
 // option 1: don't allow it to be configured via the gpio webpage
 // option 2: display which peripheral function (A,B,C,D) and allow it to be reconfigured for GPIO
 }
 
 void DisplayPinFunctionToWeb(int sock)
 {
 fdprintf(sock, "\r\n\t\t<td><font size=\"2\">");
 WriteHtmlVariable(sock, ConfigRenderFunc(2, cc_pinFunction));
 fdprintf(sock, "\r\n\t\t</font></td>\r\n");
 }
 
 void DisplayPinDriveToWeb(int sock)
 {
 if (!valid() || m_pinIO.mask == 0)
 {
 // The pin has not been initialized
 cs_currentState = "N/A";
 }
 else
 {
 if (cc_pinFunction.IsSelected("GPIO Input")) // if the pis an input, read and display the input
 {
 if (m_pinIO.readBack()) { cs_currentState = "GPIO Input = 1"; }
 else
 {
 cs_currentState = "GPIO Input = 0";
 }
 }
 else if (cc_pinFunction.IsSelected("GPIO Output 0")) // if the pin is an output, display the configured output
 {
 cs_currentState = "GPIO Output = 0";
 }
 else if (cc_pinFunction.IsSelected("GPIO Output 1"))
 {
 cs_currentState = "GPIO Output = 1";
 }
 else if (cc_pinFunction.IsSelected("Pin State"))
 {
 cs_currentState = "Not Configured";
 }
 else
 {
 cs_currentState = "Not Configured";
 }
 }
 
 fdprintf(sock, "\r\n\t\t<td><font size=\"2\">");
 WriteHtmlVariable(sock, ConfigRenderFunc(1, cs_currentState));
 fdprintf(sock, "\r\n\t\t</font></td>\r\n");
 }
 
 void DisplayFunction(int sock)
 {
 static char rowLine[sizeof("\r\n\t\t<td><font size=\"2\">")];
 writestring(sock, rowLine);
 WriteHtmlVariable(sock, ConfigRenderFunc(2, cc_pinFunction));
 writestring(sock, "</td>");
 }
 
 // void DisplayCurrentState(int sock)
 // {
 // if( !valid() )
 // {
 // // The pin has not been initialized
 // cs_currentState = "Not Configured";
 // }
 // else
 // {
 // if( m_pinIO.readBack() ) { cs_currentState = "1"; }
 // else { cs_currentState = "0"; }
 // }
 
 // static char rowLine[ sizeof( "\r\n\t\t<td><font size=\"2\">") ];
 // writestring( sock, rowLine );
 // WriteHtmlVariable(sock,ConfigRenderFunc(1, cs_currentState));
 // writestring( sock, "</td>" );
 // }
 
 uint8_t GetPinFunctionIndex()
 {
 NBString pinFuncs(cc_pinFunction.GetChoices());
 
 // find the position of the cc_pinFunction value within the choices to find the index
 size_t position = pinFuncs.find(((NBString)cc_pinFunction).c_str());
 
 uint8_t commaCount = 0;
 for (size_t start = position; start > 0; start--)
 {
 if (pinFuncs[start] == ',') { commaCount++; }
 }
 
 return commaCount;
 }
 
 // returns < 0 if failed or the NV_PinIOConfig::pin_fn_t configuration that the pin was initialized to.
 uint8_t InitPinFunction()
 {
 if (!valid() || m_pinIO.mask == 0) { return -1; }
 // Don't initialize pins that are marked as Read Only
 if (GetFlags() & fConfigReadOnly) { return -2; }
 
 uint8_t cc_pinFunctionVal = GetPinFunctionIndex();
 
 switch (cc_pinFunctionVal)
 {
 case NV_PinIOConfig::PIN_FN_NO_CONFIG: m_pinIO.function(PinIO::PIN_FN_IN); return NV_PinIOConfig::PIN_FN_IN;
 
 case NV_PinIOConfig::PIN_FN_IN: m_pinIO.function(PinIO::PIN_FN_IN); return NV_PinIOConfig::PIN_FN_IN;
 
 case NV_PinIOConfig::NV_PinIOConfig::PIN_FN_OUT_0:
 m_pinIO.function(PinIO::PIN_FN_OUT);
 m_pinIO.clr();
 return NV_PinIOConfig::NV_PinIOConfig::PIN_FN_OUT_0;
 
 case NV_PinIOConfig::PIN_FN_OUT_1:
 m_pinIO.function(PinIO::PIN_FN_OUT);
 m_pinIO.set();
 return NV_PinIOConfig::PIN_FN_OUT_1;
 
 case NV_PinIOConfig::PIN_FN_A: m_pinIO.function(PinIO::PIN_FN_A); return NV_PinIOConfig::PIN_FN_A;
 
 case NV_PinIOConfig::PIN_FN_B: m_pinIO.function(PinIO::PIN_FN_B); return NV_PinIOConfig::PIN_FN_B;
 
 case NV_PinIOConfig::PIN_FN_C: m_pinIO.function(PinIO::PIN_FN_C); return NV_PinIOConfig::PIN_FN_C;
 
 case NV_PinIOConfig::PIN_FN_D: m_pinIO.function(PinIO::PIN_FN_D); return NV_PinIOConfig::PIN_FN_D;
 
 default: return -3;
 }
 }
};
 
#ifdef SBE70LC
#define PIN_HEADER_SIZE 20 // J1 Header
#else
#define PIN_HEADER_SIZE 50
#endif
 
extern NV_PinIOConfig pinHeaderArray[];
bool InitPinArrayFunctions();
bool SetGpioConfigToReadOnly(bool bSetToReadOnly);
bool SetGpioHighCurrentDrive(bool bEnableHighDrive);
#endif // end SUPPORTED_GPIO_SERVER_PLATFORM
 
/*
 ******************************************************************************
 *
 * Global Data Declarations
 *
 ******************************************************************************
 */
/* DHCP object */
// extern DhcpObject* gDHCPObjPtr;
 
/* Settings changed flag */
extern volatile bool Settings_Changed;
extern volatile int old_config_ver;
 
/* User parameters */
extern NV_SettingsStruct NV_Settings;
 
/* User parameters change flag */
extern volatile bool gChangedUserParameters;
 
/* Debugging flag */
extern bool bShowDebug;
 
/*
 * Selection lists for the web page configuration
 */
extern const char *IPModeList[];
extern const char *IPValueList[];
extern const char *IPOnClickList[];
extern const char *BaudList[];
extern const char *BitList[];
extern const char *ParityList[];
extern const char *StopList[];
extern const char *FlowModeList[];
extern const char *SerialModeListFull[];
extern const char *SerialModeListRS232[];
extern const char *SerialModeListRS485[];
extern const char *SerialModeListHybrid[];
extern const char *SerialModeListQuad485[];
extern const char *SerialModeListQuadMMS[];
extern const char *ConnectMode[];
extern const char *ProtocolList[];
/*
 ******************************************************************************
 *
 * Routines
 *
 ******************************************************************************
 */
/* Save data to file */
extern bool UserSaveData(char *dataPtr, int dataSize, const char *fileName);
 
/* Get saved data */
extern bool UserGetData(char *dataPtr, char *fileName, int dataSize);
 
extern void RegisterPost(void);
 
extern void CheckNVSettings(bool returnToFactory = FALSE);
 
extern void SetAndSaveDefaults(void);
 
/* For processing hexadecimal break key value */
extern uint8_t GetHexByte(const char *cp);
 
#endif /* _SERIALBURNERDATA_H_ */