int
uart_send(serial_port sp, const uint8_t *pbtTx, const size_t szTx, int timeout)
{
DWORD dwTxLen = 0;
COMMTIMEOUTS timeouts;
timeouts.ReadIntervalTimeout = 0;
timeouts.ReadTotalTimeoutMultiplier = 0;
timeouts.ReadTotalTimeoutConstant = timeout;
timeouts.WriteTotalTimeoutMultiplier = 0;
timeouts.WriteTotalTimeoutConstant = timeout;
if (!SetCommTimeouts(((struct serial_port_windows *) sp)->hPort, &timeouts)) {
log_put(LOG_GROUP, LOG_CATEGORY, NFC_LOG_PRIORITY_ERROR, "Unable to apply new timeout settings.");
return NFC_EIO;
}
LOG_HEX(LOG_GROUP, "TX", pbtTx, szTx);
if (!WriteFile(((struct serial_port_windows *) sp)->hPort, pbtTx, szTx, &dwTxLen, NULL)) {
return NFC_EIO;
}
if (!dwTxLen)
return NFC_EIO;
return 0;
}
/**
* @brief Send \a pbtTx content to UART
*
* @return 0 on success, otherwise a driver error is returned
*/
int
uart_send(serial_port sp, const uint8_t *pbtTx, const size_t szTx, int timeout)
{
(void) timeout;
LOG_HEX(LOG_GROUP, "TX", pbtTx, szTx);
if ((int) szTx == write(UART_DATA(sp)->fd, pbtTx, szTx))
return NFC_SUCCESS;
else
return NFC_EIO;
}
int
uart_receive(serial_port sp, uint8_t *pbtRx, const size_t szRx, void *abort_p, int timeout)
{
DWORD dwBytesToGet = (DWORD)szRx;
DWORD dwBytesReceived = 0;
DWORD dwTotalBytesReceived = 0;
BOOL res;
// XXX Put this part into uart_win32_timeouts () ?
DWORD timeout_ms = timeout;
COMMTIMEOUTS timeouts;
timeouts.ReadIntervalTimeout = 0;
timeouts.ReadTotalTimeoutMultiplier = 0;
timeouts.ReadTotalTimeoutConstant = timeout_ms;
timeouts.WriteTotalTimeoutMultiplier = 0;
timeouts.WriteTotalTimeoutConstant = timeout_ms;
if (!SetCommTimeouts(((struct serial_port_windows *) sp)->hPort, &timeouts)) {
log_put(LOG_GROUP, LOG_CATEGORY, NFC_LOG_PRIORITY_ERROR, "Unable to apply new timeout settings.");
return NFC_EIO;
}
log_put(LOG_GROUP, LOG_CATEGORY, NFC_LOG_PRIORITY_DEBUG, "Timeouts are set to %lu ms", timeout_ms);
// TODO Enhance the reception method
// - According to MSDN, it could be better to implement nfc_abort_command() mecanism using Cancello()
volatile bool *abort_flag_p = (volatile bool *)abort_p;
do {
log_put(LOG_GROUP, LOG_CATEGORY, NFC_LOG_PRIORITY_DEBUG, "ReadFile");
res = ReadFile(((struct serial_port_windows *) sp)->hPort, pbtRx + dwTotalBytesReceived,
dwBytesToGet,
&dwBytesReceived, NULL);
dwTotalBytesReceived += dwBytesReceived;
if (!res) {
DWORD err = GetLastError();
log_put(LOG_GROUP, LOG_CATEGORY, NFC_LOG_PRIORITY_ERROR, "ReadFile error: %lu", err);
return NFC_EIO;
} else if (dwBytesReceived == 0) {
return NFC_ETIMEOUT;
}
if (((DWORD)szRx) > dwTotalBytesReceived) {
dwBytesToGet -= dwBytesReceived;
}
if (abort_flag_p != NULL && (*abort_flag_p) && dwTotalBytesReceived == 0) {
return NFC_EOPABORTED;
}
} while (((DWORD)szRx) > dwTotalBytesReceived);
LOG_HEX(LOG_GROUP, "RX", pbtRx, szRx);
return (dwTotalBytesReceived == (DWORD) szRx) ? 0 : NFC_EIO;
}
void CDiscoveryApp::print_DiscoveryResponse( void )
{
LOG("DISCOVERY_REPLY Version %u, Type %u, ANID %u (x%X)", m_stDiscoveryResponse.m_uchMessageVersion,
m_stDiscoveryResponse.m_uchMessageType, ntohl(m_stDiscoveryResponse.m_unAnId), ntohl(m_stDiscoveryResponse.m_unAnId));
LOG_HEX( "MAC_Address", m_stDiscoveryResponse.m_uchMAC_Address, sizeof(m_stDiscoveryResponse.m_uchMAC_Address));
print_ipmask( m_szEthInterf, m_stDiscoveryResponse.m_unIP_ethInterf, m_stDiscoveryResponse.m_unMask_ethInterf );
print_ipmask( m_szEthInterf_0, m_stDiscoveryResponse.m_unIP_ethInterf_0, m_stDiscoveryResponse.m_unMask_ethInterf_0 );
print_ipmask( m_szEthInterf_1, m_stDiscoveryResponse.m_unIP_ethInterf_1, m_stDiscoveryResponse.m_unMask_ethInterf_1 );
print_ipmask( "DefaultGW", m_stDiscoveryResponse.m_unDefaultGateway, 0);
}
int
pn53x_usb_bulk_read (struct pn53x_usb_data *data, uint8_t abtRx[], const size_t szRx, const int timeout)
{
int res = usb_bulk_read (data->pudh, data->uiEndPointIn, (char *) abtRx, szRx, timeout);
if (res > 0) {
LOG_HEX ("RX", abtRx, res);
} else if (res < 0) {
if (res != -USB_TIMEDOUT)
log_put (LOG_CATEGORY, NFC_PRIORITY_ERROR, "Unable to read from USB (%s)", _usb_strerror (res));
}
return res;
}
int
pn53x_usb_bulk_write (struct pn53x_usb_data *data, uint8_t abtTx[], const size_t szTx, const int timeout)
{
LOG_HEX ("TX", abtTx, szTx);
int res = usb_bulk_write (data->pudh, data->uiEndPointOut, (char *) abtTx, szTx, timeout);
if (res > 0) {
// HACK This little hack is a well know problem of USB, see http://www.libusb.org/ticket/6 for more details
if ((res % data->uiMaxPacketSize) == 0) {
usb_bulk_write (data->pudh, data->uiEndPointOut, "\0", 0, timeout);
}
} else {
log_put (LOG_CATEGORY, NFC_PRIORITY_ERROR, "Unable to write to USB (%s)", _usb_strerror (res));
}
return res;
}
static int
acr122_usb_bulk_read(struct acr122_usb_data *data, uint8_t abtRx[], const size_t szRx, const int timeout)
{
int res = usb_bulk_read(data->pudh, data->uiEndPointIn, (char *) abtRx, szRx, timeout);
if (res > 0) {
LOG_HEX(NFC_LOG_GROUP_COM, "RX", abtRx, res);
} else if (res < 0) {
if (res != -USB_TIMEDOUT) {
res = NFC_EIO;
log_put(LOG_GROUP, LOG_CATEGORY, NFC_LOG_PRIORITY_ERROR, "Unable to read from USB (%s)", _usb_strerror(res));
} else {
res = NFC_ETIMEOUT;
}
}
return res;
}
/**
* @brief Write a frame to I2C device containing \a pbtTx content
*
* @param id I2C device.
* @param pbtTx pointer on buffer containing data
* @param szTx length of the buffer
* @return NFC_SUCCESS on success, otherwise driver error code
*/
int
i2c_write(i2c_device id, const uint8_t *pbtTx, const size_t szTx)
{
LOG_HEX(LOG_GROUP, "TX", pbtTx, szTx);
ssize_t writeCount;
writeCount = write(I2C_DATA(id) ->fd, pbtTx, szTx);
if ((const ssize_t) szTx == writeCount) {
log_put(LOG_GROUP, LOG_CATEGORY, NFC_LOG_PRIORITY_DEBUG,
"wrote %d bytes successfully.", (int)szTx);
return NFC_SUCCESS;
} else {
log_put(LOG_GROUP, LOG_CATEGORY, NFC_LOG_PRIORITY_ERROR,
"Error: wrote only %d bytes (%d expected) (%s).", (int)writeCount, (int) szTx, strerror(errno));
return NFC_EIO;
}
}
int fcopy_s(FILE* dest, int src, size_t size, int&contentLength )
{
char rdBuf[8*1024];
int rb = read( src, rdBuf, size );
if ( rb <= 0 )
{
LOG_ERR("smth went wrong again2");
return -1 ;
}
for ( int wb=0; wb < rb; )
{
wb += fwrite( rdBuf+wb, sizeof(char), rb-wb, dest);
}
contentLength -= rb ;
if ( contentLength <= 0 )
{
LOG_HEX("BUFFER", (const unsigned char*)rdBuf, rb );
}
return rb ;
}
int
acr122_receive (nfc_device *pnd, uint8_t *pbtData, const size_t szData, int timeout)
{
// FIXME: timeout is not handled
(void) timeout;
int len;
uint8_t abtRxCmd[5] = { 0xFF, 0xC0, 0x00, 0x00 };
if (DRIVER_DATA (pnd)->ioCard.dwProtocol == SCARD_PROTOCOL_T0) {
/*
* Retrieve the PN532 response.
*/
DWORD dwRxLen = sizeof (DRIVER_DATA (pnd)->abtRx);
abtRxCmd[4] = DRIVER_DATA (pnd)->abtRx[1];
if (SCardTransmit (DRIVER_DATA (pnd)->hCard, &(DRIVER_DATA (pnd)->ioCard), abtRxCmd, sizeof (abtRxCmd), NULL, DRIVER_DATA (pnd)->abtRx, &dwRxLen) != SCARD_S_SUCCESS) {
pnd->last_error = NFC_EIO;
return pnd->last_error;
}
DRIVER_DATA (pnd)->szRx = dwRxLen;
} else {
/*
* We already have the PN532 answer, it was saved by acr122_send().
*/
}
LOG_HEX ("RX", DRIVER_DATA (pnd)->abtRx, DRIVER_DATA (pnd)->szRx);
// Make sure we have an emulated answer that fits the return buffer
if (DRIVER_DATA (pnd)->szRx < 4 || (DRIVER_DATA (pnd)->szRx - 4) > szData) {
pnd->last_error = NFC_EIO;
return pnd->last_error;
}
// Wipe out the 4 APDU emulation bytes: D5 4B .. .. .. 90 00
len = DRIVER_DATA (pnd)->szRx - 4;
memcpy (pbtData, DRIVER_DATA (pnd)->abtRx + 2, len);
return len;
}
int socket_sendData(void* data, s32 len)
{
s32 rc;
LOG_HEX((const char*)data, len);
rc = eat_soc_send(socket_id, data, len);
if (rc >= 0)
{
LOG_DEBUG("socket send data successful.");
}
else
{
if (rc == SOC_PIPE || rc == SOC_NOTCONN)
{
fsm_run(EVT_SOCKET_DISCONNECTED); //这个地方仅为保护作用，正常的socket断链应该会通过soc_notify_cb来通知
}
LOG_ERROR("sokcet send data failed:%d!", rc);
}
return rc;
}
/*============================================================================*/
e_derdRet_t sslDerd_getOctStr(s_derdCtx_t *ps_derdCtx,
uint8_t* pc_encSign, size_t* pi_encSignLen)
{
e_derdRet_t e_res = E_SSL_DER_OK;
assert(ps_derdCtx != NULL);
assert(ps_derdCtx->s_octVal.pc_data != NULL);
if ((ps_derdCtx->c_tag == SSL_DER_ASN1_OCTET_STRING) &&
(ps_derdCtx->s_octVal.cwt_len > 1) &&
(pc_encSign != NULL)) {
*pi_encSignLen = ps_derdCtx->s_octVal.cwt_len;
memmove(pc_encSign,ps_derdCtx->s_octVal.pc_data,*pi_encSignLen);
LOG_INFO("signature");
LOG_HEX(pc_encSign,*pi_encSignLen);
}
else
{
e_res = E_SSL_DER_ERR_NO_OCTETSTR;
}
return (e_res);
} /* sslDerd_getOctStr */
int
acr122_send (nfc_device *pnd, const uint8_t *pbtData, const size_t szData, int timeout)
{
// FIXME: timeout is not handled
(void) timeout;
// Make sure the command does not overflow the send buffer
if (szData > ACR122_COMMAND_LEN) {
pnd->last_error = NFC_EINVARG;
return pnd->last_error;
}
// Prepare and transmit the send buffer
const size_t szTxBuf = szData + 6;
uint8_t abtTxBuf[ACR122_WRAP_LEN + ACR122_COMMAND_LEN] = { 0xFF, 0x00, 0x00, 0x00, szData + 1, 0xD4 };
memcpy (abtTxBuf + 6, pbtData, szData);
LOG_HEX ("TX", abtTxBuf, szTxBuf);
DRIVER_DATA (pnd)->szRx = 0;
DWORD dwRxLen = sizeof (DRIVER_DATA (pnd)->abtRx);
if (DRIVER_DATA (pnd)->ioCard.dwProtocol == SCARD_PROTOCOL_UNDEFINED) {
/*
* In this communication mode, we directly have the response from the
* PN532. Save it in the driver data structure so that it can be retrieved
* in ac122_receive().
*
* Some devices will never enter this state (e.g. Touchatag) but are still
* supported through SCardTransmit calls (see bellow).
*
* This state is generaly reached when the ACR122 has no target in it's
* field.
*/
if (SCardControl (DRIVER_DATA (pnd)->hCard, IOCTL_CCID_ESCAPE_SCARD_CTL_CODE, abtTxBuf, szTxBuf, DRIVER_DATA (pnd)->abtRx, ACR122_RESPONSE_LEN, &dwRxLen) != SCARD_S_SUCCESS) {
pnd->last_error = NFC_EIO;
return pnd->last_error;
}
} else {
/*
* In T=0 mode, we receive an acknoledge from the MCU, in T=1 mode, we
* receive the response from the PN532.
*/
if (SCardTransmit (DRIVER_DATA (pnd)->hCard, &(DRIVER_DATA (pnd)->ioCard), abtTxBuf, szTxBuf, NULL, DRIVER_DATA (pnd)->abtRx, &dwRxLen) != SCARD_S_SUCCESS) {
pnd->last_error = NFC_EIO;
return pnd->last_error;
}
}
if (DRIVER_DATA (pnd)->ioCard.dwProtocol == SCARD_PROTOCOL_T0) {
/*
* Check the MCU response
*/
// Make sure we received the byte-count we expected
if (dwRxLen != 2) {
pnd->last_error = NFC_EIO;
return pnd->last_error;
}
// Check if the operation was successful, so an answer is available
if (DRIVER_DATA (pnd)->abtRx[0] == SCARD_OPERATION_ERROR) {
pnd->last_error = NFC_EIO;
return pnd->last_error;
}
} else {
DRIVER_DATA (pnd)->szRx = dwRxLen;
}
return NFC_SUCCESS;
}
/**
* @brief Receive data from UART and copy data to \a pbtRx
*
* @return 0 on success, otherwise driver error code
*/
int
uart_receive(serial_port sp, uint8_t *pbtRx, const size_t szRx, void *abort_p, int timeout)
{
int iAbortFd = abort_p ? *((int *)abort_p) : 0;
int received_bytes_count = 0;
int available_bytes_count = 0;
const int expected_bytes_count = (int)szRx;
int res;
fd_set rfds;
do {
select:
// Reset file descriptor
FD_ZERO(&rfds);
FD_SET(UART_DATA(sp)->fd, &rfds);
if (iAbortFd) {
FD_SET(iAbortFd, &rfds);
}
struct timeval timeout_tv;
if (timeout > 0) {
timeout_tv.tv_sec = (timeout / 1000);
timeout_tv.tv_usec = ((timeout % 1000) * 1000);
}
res = select(MAX(UART_DATA(sp)->fd, iAbortFd) + 1, &rfds, NULL, NULL, timeout ? &timeout_tv : NULL);
if ((res < 0) && (EINTR == errno)) {
// The system call was interupted by a signal and a signal handler was
// run. Restart the interupted system call.
goto select;
}
// Read error
if (res < 0) {
log_put(LOG_GROUP, LOG_CATEGORY, NFC_LOG_PRIORITY_DEBUG, "Error: %s", strerror(errno));
return NFC_EIO;
}
// Read time-out
if (res == 0) {
log_put(LOG_GROUP, LOG_CATEGORY, NFC_LOG_PRIORITY_DEBUG, "%s", "Timeout!");
return NFC_ETIMEOUT;
}
if (FD_ISSET(iAbortFd, &rfds)) {
// Abort requested
log_put(LOG_GROUP, LOG_CATEGORY, NFC_LOG_PRIORITY_DEBUG, "%s", "Abort!");
close(iAbortFd);
return NFC_EOPABORTED;
}
// Retrieve the count of the incoming bytes
res = ioctl(UART_DATA(sp)->fd, FIONREAD, &available_bytes_count);
if (res != 0) {
return NFC_EIO;
}
// There is something available, read the data
res = read(UART_DATA(sp)->fd, pbtRx + received_bytes_count, MIN(available_bytes_count, (expected_bytes_count - received_bytes_count)));
// Stop if the OS has some troubles reading the data
if (res <= 0) {
return NFC_EIO;
}
received_bytes_count += res;
} while (expected_bytes_count > received_bytes_count);
LOG_HEX(LOG_GROUP, "RX", pbtRx, szRx);
return NFC_SUCCESS;
}
//retcode: true if DISCOVERY_REPLY must be sent back
//retcode false if no reply is necessary either because the incomming
//message is wrong or because it must be ignored
bool CDiscoveryApp::processData(unsigned char *p, const struct sockaddr_in& p_stClientAddr)
{
if (p==NULL)
{
LOG("ERROR processData: parameter NULL");
return false;
}
if (*(unsigned char *)p!=1)
{
LOG("ERROR processData: incorrect MessageVersion %d", *(unsigned char *)p);
return false;
}
unsigned char *uchMesssageType=p+sizeof(unsigned char);
switch (*uchMesssageType)
{
case DISCOVERY_QRY:
{
LOG("DISCOVERY_QRY");
return fillDiscoveryResponse(); // instruct caller to send the reply back
}
case DISCOVERY_SET:
{
IPSet_Msg * pIPSet = (IPSet_Msg*)p;
LOG("DISCOVERY_SET version %u ANID %u (x%X)", pIPSet->m_uchMessageVersion, ntohl(pIPSet->m_unAnId), ntohl(pIPSet->m_unAnId) );
unsigned short crc=computeCRC((uint8_t *)pIPSet, (uint16_t)(sizeof(IPSet_Msg)-sizeof(pIPSet->m_ushCRC)));
if (crc!=pIPSet->m_ushCRC)
{
LOG("ERROR processData: Wrong CRC in ipSet");
return false;
}
if( ( pIPSet->m_unIP_ethInterf==0x0 )
|| ( pIPSet->m_unDefaultGateway==0x0)
|| ((pIPSet->m_unMask_ethInterf & pIPSet->m_unDefaultGateway) != ( pIPSet->m_unMask_ethInterf & pIPSet->m_unIP_ethInterf)) )
{
LOG("ERROR processData: invalid DISCOVERY_SET (IP/GW are zero or IP&mask != GW&mask)");
log2flash( "ERR DISCOVERY: Invalid SET %s [IP %s/Mask %s/GW %s] from %s", m_szEthInterf, pIPSet->m_unIP_ethInterf, pIPSet->m_unMask_ethInterf, pIPSet->m_unDefaultGateway, inet_ntoa( p_stClientAddr.sin_addr ));
return false;
}
IP_array ip_array;
//read ip/mask/gw to match with packet
if (GetNetworkConfiguration(ip_array) < 0)
{
return false;
}
MatchIP_dev( ip_array );
//both ANID/MAC should either match or mismatch.
if( matchMAC( pIPSet ) && (!matchANID( pIPSet )) )
{
LOG("ERROR processData: MAC match while ANID mismatch (in %u own %u)", ntohl(pIPSet->m_unAnId), ntohl(getANId()) );
}
if( (!matchMAC( pIPSet )) && matchANID( pIPSet ) )
{
LOG_HEX( "ERROR processData: MAC mismatch while ANID match. In: ", pIPSet->m_uchMAC_Address, sizeof(pIPSet->m_uchMAC_Address) );
LOG_HEX( "ERROR processData: MAC mismatch while ANID match. Own:", m_ucEthInterfMAC, sizeof(m_ucEthInterfMAC) );
}
// Compare own MAC and ANID with the ones from the incoming packet
if( !( matchMAC( pIPSet ) && matchANID( pIPSet ) ) )
{
char szTmp[128];
snprintf(szTmp, sizeof(szTmp), "Ignore DISCOVERY_SET for AN %u MAC", ntohl(pIPSet->m_unAnId) );
szTmp[ sizeof(szTmp) - 1 ] = 0;
LOG_HEX( szTmp, pIPSet->m_uchMAC_Address, sizeof(pIPSet->m_uchMAC_Address) );
return false;
}
ConfigureNetwork(*pIPSet);
update_rcnetinfo(RC_NET_INFO, pIPSet->m_unIP_ethInterf, pIPSet->m_unMask_ethInterf, pIPSet->m_unDefaultGateway, p_stClientAddr);
//memset(p, 0, BUFLEN);
fillDiscoveryResponse();
return true; // instruct caller to send the reply back
}
case DISCOVERY_REPLY:
{
LOG("Ignore DISCOVERY_REPLY");
return false;
}
default:
{
LOG("ERROR processData() unknown MessageType %u", *uchMesssageType);
return false;
}
}
}
/// Load the config.ini file and parse it to extract various configurations out of it
/// @retval 1 success
/// @retval 0 failure
/// @note DO NOT read same variable in Init() and Reload(). Init calls Reload.
int CISAConfig::Init()
{
if(!CConfig::Init("GATEWAY"))
{
return 0;
}
READ_DEFAULT_VARIABLE_INT ("TCP_YGSAP_PORT", m_nYGSAP_TCPPort, 0);
READ_DEFAULT_VARIABLE_INT ("TCP_SERVER_PORT", m_nGSAP_TCPPort, 4900);
READ_DEFAULT_VARIABLE_INT ("TCP_SERVER_PORT_SSL", m_nGSAP_TCPPort_SSL, 0);
READ_DEFAULT_VARIABLE_INT ("TCP_YGSAP_PORT_SSL", m_nYGSAP_TCPPort_SSL, 0);
READ_DEFAULT_VARIABLE_INT ("SM_LINK_TIMEOUT", m_nPingTimeout, 50);
READ_DEFAULT_VARIABLE_STRING("GATEWAY_TAG", m_szGWTag, "Nivis Gateway" );
if ( m_nGSAP_TCPPort_SSL != 0 || m_nYGSAP_TCPPort_SSL != 0)
{
READ_DEFAULT_VARIABLE_STRING("SSL_SERVER_CERTIF_FILE", m_szSslServerCertif, "/access_node/activity_files/ssl_resources/servercert.pem" );
READ_DEFAULT_VARIABLE_STRING("SSL_SERVER_KEY_FILE", m_szSslServerKey, "/access_node/activity_files/ssl_resources/serverkey.pem" );
READ_DEFAULT_VARIABLE_STRING("SSL_CA_CERTIF_FILE", m_szSslCaCertif, "/access_node/activity_files/ssl_resources/cakey.pem" );
}
if(GetVar("HOST_APP", &m_HostAddr )){
LOG_HEX( "m_HostAddr(hexdump):", (uint8*)&m_HostAddr, sizeof(net_address));
}
READ_MANDATORY_VARIABLE("GATEWAY_IPv6", m_oGWIPv6 );
char szIPv4[16];
READ_MANDATORY_VARIABLE_STRING("GATEWAY_IPv4", szIPv4);
READ_MANDATORY_VARIABLE("GATEWAY_UDPPort", m_nGW_UDPPort)
if (!AdjustIPv6(&m_oGWIPv6,szIPv4, m_nGW_UDPPort))
{
return 0;
}
LOG("GW IPv6=%s IPv4=%s UDPPort=%d", m_oGWIPv6.GetPrintIPv6(), szIPv4, m_nGW_UDPPort);
if(!GetVar("GATEWAY_EUI64", (uint8_t*)m_pu8GWEUI64, sizeof(m_pu8GWEUI64)))
{
return 0;
}
READ_MANDATORY_VARIABLE("SubnetID", m_nSubnetID);
LOG("SubnetID %u (0x%X)", m_nSubnetID, m_nSubnetID);
READ_MANDATORY_VARIABLE_STRING("AppJoinKey", m_u8AppJoinKey);
READ_DEFAULT_VARIABLE_INT ("TLDE_HLIST_SIZE", m_nTldeHListSize, 100);
READ_DEFAULT_VARIABLE_INT ("TLDE_HLIST_TIME_WINDOW", m_nTldeHListTimeWindow, 60);
Reload();
if(!CIniParser::GetVar("SYSTEM_MANAGER", "SYSTEM_MANAGER_IPv6", &m_oSMIPv6 ))
{ return 0;
}
if(!CIniParser::GetVar("SYSTEM_MANAGER", "SYSTEM_MANAGER_IPv4", szIPv4, sizeof(szIPv4)))
{ return 0;
}
if(!CIniParser::GetVar("SYSTEM_MANAGER", "SYSTEM_MANAGER_Port", &m_nSMPort))
{ return 0;
}
if(!CIniParser::GetVar("SYSTEM_MANAGER", "CURRENT_UTC_ADJUSTMENT", &m_nCrtUTCAdj))
{ return 0;
}
if (!AdjustIPv6(&m_oSMIPv6,szIPv4, m_nSMPort))
{ return 0;
}
LOG("SM IPv6=%s IPv4=%s Port=%d", m_oSMIPv6.GetPrintIPv6(), szIPv4, m_nSMPort);
if(!CIniParser::GetVar("SYSTEM_MANAGER", "SECURITY_MANAGER_EUI64", m_u8SecurityManager, sizeof(m_u8SecurityManager)))
{ return 0;
}
LOG("Config loaded");
//--------------
return 1;
}