libgfaservices/mqttcl/mqttcfg.cpp

#include <stdio.h>
#include <limits.h>
#include <stdlib.h>
#include <unistd.h>
#include "fileutil.h"
#include "strutil.h"
#include "mqttcfg.h"
#include "debug.h"

#define _DEFAULT_CFG_FILE_NAME					"mqttcl.cfg.json"

#define _CFG_KEY_NAME_BROKER_ADDR				"brokerAddr"
#define _CFG_KEY_NAME_BROKER_PORT				"brokerPort"
#define _CFG_KEY_NAME_DEFAULT_QOS				"defaultQos"
#define _CFG_KEY_NAME_DEFAULT_RETAIN			"defaultRetain"
#define _CFG_KEY_NAME_DEVICE_PREFIX				"devicePrefix"
#define _CFG_KEY_NAME_DEVICE_ID					"deviceID"
#define _CFG_KEY_NAME_TLS_MODE					"tlsMode"
#define _CFG_KEY_NAME_TLS_CA_CRT_FILE			"tlsCaCrtFile"
#define _CFG_KEY_NAME_TLS_CL_CRT_FILE			"tlsClCrtFile"
#define _CFG_KEY_NAME_TLS_CL_KEY_FILE			"tlsClKeyFile"
#define _CFG_KEY_NAME_TLS_PSK					"tlsPsk"
#define _CFG_KEY_NAME_TLS_PSK_CLIENT_ID			"tlsPskClientID"
#define _CFG_KEY_NAME_LAST_WILL_MSG_STR			"lastWillMsgStr"
#define _CFG_KEY_NAME_LAST_WILL_MSG_INT			"lastWillMsgInt"
#define _CFG_KEY_NAME_LAST_WILL_TOPIC			"lastWillTopic"
#define _CFG_KEY_NAME_LAST_WILL_QOS				"lastWillQos"
#define _CFG_KEY_NAME_LAST_WILL_RETAIN			"lastWillRetain"
#define _CFG_KEY_NAME_LAST_WILL_ON_EXIT			"lastWillOnExit"
#define _CFG_KEY_NAME_LAST_WILL_ON_EXIT_MSG_STR	"lastWillOnExitMsgStr"
#define _CFG_KEY_NAME_LAST_WILL_ON_EXIT_MSG_INT	"lastWillOnExitMsgInt"
#define _CFG_KEY_NAME_CONNECT_MSG_STR			"connectMsgStr"
#define _CFG_KEY_NAME_CONNECT_MSG_INT			"connectMsgInt"
#define _CFG_KEY_NAME_CONNECT_TOPIC				"connectTopic"
#define _CFG_KEY_NAME_CONNECT_QOS				"connectQos"
#define _CFG_KEY_NAME_CONNECT_RETAIN			"connectRetain"
#define _CFG_KEY_NAME_MAX_KEEP_ALIVE			"maxKeepAlive"
#define _CFG_KEY_NAME_TOPIC_PREFIX_STRING		"topicPrefix"
#define _CFG_KEY_NAME_DISABLE_TOPIC_PREFIX		"disableTopicPrefix"
#define _CFG_KEY_NAME_USERNAME					"userName"
#define _CFG_KEY_NAME_PASSWORD					"passWord"

/////////////////////////////////////////////////////////////////////////////

CMqttClConfig::CMqttClConfig(const char *pszShmUuid) :	m_strShmID(formatString("SHM-%s", strucase(pszShmUuid).c_str())),
														m_nBrokerPort(0),
														m_nDefaultQOS(0),
														m_bDefaultRetain(MQTTCL_DEFAULT_RETAIN),
														m_nLastWillMessage(0),
														m_nLastWillQos(m_nDefaultQOS),
														m_bLastWillRetain(MQTTCL_DEFAULT_RETAIN),
														m_bHasLastWill(false),
														m_bLastWillOnExit(false),
														m_nLastWillOnExitMsg(0),
														m_nConnectMessage(0),
														m_nConnectQos(m_nDefaultQOS),
														m_bConnectRetain(MQTTCL_DEFAULT_RETAIN),
														m_bHasConnect(false),
														m_bDisableTopicPrefix(false),
														m_bHasPrefix(false),
														m_nTlsMode(0),
														m_nMaxKeepAlive(MQTTCL_DEFAULT_MAX_KEEP_ALIVE_TIME),
														m_bHasUsername(false),
														m_bHasPassword(false)
{
}

CMqttClConfig::~CMqttClConfig(void)
{
}

/////////////////////////////////////////////////////////////////////////////
// LoadCfg

bool CMqttClConfig::LoadCfg(const char *pszCfgFilePath, CLogfile &rlf)
{
	char szCfgFilePath[PATH_MAX];
	std::string strErr;

	if(!pszCfgFilePath)
	{	// use default config file path
		pszCfgFilePath = ::BuildCanonicalFilePath(NULL, _DEFAULT_CFG_FILE_NAME, szCfgFilePath, sizeof(szCfgFilePath));
	}

	/////////////////////////////////////////////////////////////////////////
	// load and parse config file

	json_t *pjtCfg;
	json_error_t err;

	if(!(pjtCfg = ::json_load_file(pszCfgFilePath, JSON_REJECT_DUPLICATES, &err)))
	{
		rlf.Error("LoadCfg: Error loading file %s: %s!\n", pszCfgFilePath, err.text);
		return false;
	}

	CJson_t jtCfg(pjtCfg, true);

	/////////////////////////////////////////////////////////////////////////
	// tlsMode

	if(!GetIntValue(jtCfg, _CFG_KEY_NAME_TLS_MODE, m_nTlsMode, strErr))
	{
		m_nTlsMode = MQTTCL_TLS_MODE_OFF;
		rlf.Warning("LoadCfg: TLS will not be used!\n");
	}
	else if((m_nTlsMode < MQTTCL_TLS_MODE_OFF) || (m_nTlsMode > MQTTCL_TLS_MODE_PSK))
	{
		rlf.Error("LoadCfg: Invalid TLS mode: %d! No way to continue!\n", m_nTlsMode);
		return false;
	}

	/////////////////////////////////////////////////////////////////////////
	// brokerAddr

	if(!GetStringValue(jtCfg, _CFG_KEY_NAME_BROKER_ADDR, m_strBrokerAddr, strErr))
	{
		rlf.Error("LoadCfg: %s!\n", strErr.c_str());
		return false;
	}

	/////////////////////////////////////////////////////////////////////////
	// brokerPort

	if(!GetIntValue(jtCfg, _CFG_KEY_NAME_BROKER_PORT, m_nBrokerPort, strErr))
	{
		m_nBrokerPort = (m_nTlsMode > MQTTCL_TLS_MODE_OFF) ? 8883 : 1883;
		rlf.Info("LoadCfg: Using default broker port %d!\n", m_nBrokerPort);
	}
	else if(m_nBrokerPort < 0 || m_nBrokerPort > 0xffff)
	{
		rlf.Error("LoadCfg: Invalid broker port number: %d! No way to continue!\n", m_nBrokerPort);
		return false;
	}

	/////////////////////////////////////////////////////////////////////////
	// defaultQos

	if(!GetIntValue(jtCfg, _CFG_KEY_NAME_DEFAULT_QOS, m_nDefaultQOS, strErr))
	{
		m_nDefaultQOS = MQTTCL_DEFAULT_QOS;
		rlf.Info("LoadCfg: Using default QOS: %d!\n", m_nDefaultQOS);
	}
	else if(m_nDefaultQOS < MQTTCL_MIN_QOS)
	{
		rlf.Warning("LoadCfg: Invalid QOS: %d - adjusted to %d!\n", m_nDefaultQOS, MQTTCL_MIN_QOS);
		m_nDefaultQOS = MQTTCL_MIN_QOS;
	}
	else if(m_nDefaultQOS > MQTTCL_MAX_QOS)
	{
		rlf.Warning("LoadCfg: Invalid QOS: %d - adjusted to %d!\n", m_nDefaultQOS, MQTTCL_MAX_QOS);
		m_nDefaultQOS = MQTTCL_MAX_QOS;
	}
	else
	{
		rlf.Info("LoadCfg: Default QOS: %d!\n", m_nDefaultQOS);
	}

	/////////////////////////////////////////////////////////////////////////
	// defaultRetain

	if(!GetBoolValue(jtCfg, _CFG_KEY_NAME_DEFAULT_RETAIN, m_bDefaultRetain, strErr))
	{
		m_bDefaultRetain = MQTTCL_DEFAULT_RETAIN;
		rlf.Info("LoadCfg: Using default retain \"%s\"!\n", m_bDefaultRetain ? "true" : "false");
	}

	/////////////////////////////////////////////////////////////////////////
	// lastWillMsgStr

	if(GetStringValue(jtCfg, _CFG_KEY_NAME_LAST_WILL_MSG_STR, m_strLastWillMessage, strErr))
	{
		m_bHasLastWill = true;
		rlf.Info("LoadCfg: Last Will - String message: \"%s\".\n", m_strLastWillMessage.c_str());
	}

	/////////////////////////////////////////////////////////////////////////
	// lastWillMsgInt

	if(!m_bHasLastWill)
	{
		if(GetInt64Value(jtCfg, _CFG_KEY_NAME_LAST_WILL_MSG_INT, m_nLastWillMessage, strErr))
		{
			m_bHasLastWill = true;
			rlf.Info("LoadCfg: Last Will - Numeric message: %lld.\n", m_nLastWillMessage);
		}
		else
		{
			rlf.Warning("LoadCfg: %s! No Last Will Message provided.\n", strErr.c_str());
		}
	}

	if(m_bHasLastWill)
	{
		/////////////////////////////////////////////////////////////////////
		// lastWillTopic

		if(!GetStringValue(jtCfg, _CFG_KEY_NAME_LAST_WILL_TOPIC, m_strLastWillTopic, strErr))
		{
			m_strLastWillTopic = MQTTCL_DEFAULT_LAST_WILL_CONNECT_TOPIC;
			rlf.Info("LoadCfg: %s! Setting Last Will Topic to default: \"%s\".\n", strErr.c_str(), m_strLastWillTopic.c_str());
		}

		/////////////////////////////////////////////////////////////////////
		// lastWillQos

		if(!GetIntValue(jtCfg, _CFG_KEY_NAME_LAST_WILL_QOS, m_nLastWillQos, strErr))
		{
			m_nLastWillQos = m_nDefaultQOS;
			rlf.Info("LoadCfg: %s! Using default Last Will QOS: %d!\n", strErr.c_str(), m_nLastWillQos);
		}

		/////////////////////////////////////////////////////////////////////
		// lastWillRetain

		if(!GetBoolValue(jtCfg, _CFG_KEY_NAME_LAST_WILL_RETAIN, m_bLastWillRetain, strErr))
		{
			m_bLastWillRetain = m_bDefaultRetain;
			rlf.Info("LoadCfg: %s! Using default Last Will retain: \"%s\"!\n", strErr.c_str(), m_bLastWillRetain ? "true" : "false");
		}

		/////////////////////////////////////////////////////////////////////
		// lastWillOnExit

		if(!GetBoolValue(jtCfg, _CFG_KEY_NAME_LAST_WILL_ON_EXIT, m_bLastWillOnExit, strErr))
		{
			m_bLastWillOnExit = false;
			rlf.Warning("LoadCfg: %s! No Last Will on Exit.\n", strErr.c_str());
		}

		if(m_bLastWillOnExit)
		{
			/////////////////////////////////////////////////////////////////
			// lastWillOnExitMsgStr, lastWillOnExitMsgInt

			if(GetStringValue(jtCfg, _CFG_KEY_NAME_LAST_WILL_ON_EXIT_MSG_STR, m_strLastWillOnExitMsg, strErr))
			{
				rlf.Info("LoadCfg: Last Will on Exit - String message: \"%s\".\n", m_strLastWillOnExitMsg.c_str());
			}
			else
			{
				if(GetInt64Value(jtCfg, _CFG_KEY_NAME_LAST_WILL_ON_EXIT_MSG_INT, m_nLastWillOnExitMsg, strErr))
				{
					rlf.Info("LoadCfg: Last Will on Exit - Numeric message: %lld.\n", m_nLastWillOnExitMsg);
				}
				else
				{
					if(!m_strLastWillMessage.empty())
					{
						m_strLastWillOnExitMsg = m_strLastWillMessage;
						rlf.Info("LoadCfg: Setting Last Will Exit Message to Last Will string: \"%s\".\n", m_strLastWillOnExitMsg.c_str());
					}
					else
					{
						m_nLastWillOnExitMsg = m_nLastWillMessage;
						rlf.Info("LoadCfg: Setting Last Will Exit Message to Last Will numeric: %lld.\n", m_nLastWillOnExitMsg);
					}
				}
			}
		}
	}

	/////////////////////////////////////////////////////////////////////////
	// connectMsgStr

	if(GetStringValue(jtCfg, _CFG_KEY_NAME_CONNECT_MSG_STR, m_strConnectMessage, strErr))
	{
		m_bHasConnect = true;
		rlf.Info("LoadCfg: Connect - String message: \"%s\".\n", m_strConnectMessage.c_str());
	}

	/////////////////////////////////////////////////////////////////////////
	// connectMsgInt

	if(!m_bHasConnect)
	{
		if(GetInt64Value(jtCfg, _CFG_KEY_NAME_CONNECT_MSG_INT, m_nConnectMessage, strErr))
		{
			m_bHasConnect = true;
			rlf.Info("LoadCfg: Connect - Numeric message: %lld.\n", m_nConnectMessage);
		}
		else
		{
			rlf.Warning("LoadCfg: %s! No Connect message provided.\n", strErr.c_str());
		}
	}

	if(m_bHasConnect)
	{
		/////////////////////////////////////////////////////////////////////
		// connectTopic

		if(!GetStringValue(jtCfg, _CFG_KEY_NAME_CONNECT_TOPIC, m_strConnectTopic, strErr))
		{
			if(m_bHasLastWill)
			{
				m_strConnectTopic = m_strLastWillTopic;
				rlf.Info("LoadCfg: %s! Setting Connect Topic to Last Will Topic: \"%s\".\n", strErr.c_str(), m_strConnectTopic.c_str());
			}
			else
			{
				m_strConnectTopic = MQTTCL_DEFAULT_LAST_WILL_CONNECT_TOPIC;
				rlf.Info("LoadCfg: %s! Setting Connect Topic to default: \"%s\".\n", strErr.c_str(), m_strConnectTopic.c_str());
			}
		}

		/////////////////////////////////////////////////////////////////////
		// connectQos

		if(!GetIntValue(jtCfg, _CFG_KEY_NAME_CONNECT_QOS, m_nConnectQos, strErr))
		{
			m_nConnectQos = m_nDefaultQOS;
			rlf.Info("LoadCfg: %s! Using default Connect Qos: %d!\n", strErr.c_str(), m_nConnectQos);
		}

		/////////////////////////////////////////////////////////////////////
		// connectRetain

		if(!GetBoolValue(jtCfg, _CFG_KEY_NAME_CONNECT_RETAIN, m_bConnectRetain, strErr))
		{
			m_bConnectRetain = m_bDefaultRetain;
			rlf.Info("LoadCfg: %s! Using default Last Will retain: %s!\n", strErr.c_str(), m_bConnectRetain ? "true" : "false");
		}
	}

	/////////////////////////////////////////////////////////////////////////
	// maxKeepAlive

	if(!GetIntValue(jtCfg, _CFG_KEY_NAME_MAX_KEEP_ALIVE, m_nMaxKeepAlive, strErr))
	{
		m_nMaxKeepAlive = MQTTCL_DEFAULT_MAX_KEEP_ALIVE_TIME;
		rlf.Info("LoadCfg: %s! Using default Keep-alive time: %d!\n", strErr.c_str(), m_nMaxKeepAlive);
	}
	else if(m_nMaxKeepAlive < MQTTCL_MIN_MAX_KEEP_ALIVE_TIME)
	{
		rlf.Warning("LoadCfg: Adjusting max keep-alive time from %d to %d!\n", m_nMaxKeepAlive, MQTTCL_MIN_MAX_KEEP_ALIVE_TIME);
		m_nMaxKeepAlive = MQTTCL_MIN_MAX_KEEP_ALIVE_TIME;
	}

	/////////////////////////////////////////////////////////////////////////
	// devicePrefix

	if(!GetStringValue(jtCfg, _CFG_KEY_NAME_DEVICE_PREFIX, m_strDevicePrefix, strErr))
	{
		rlf.Warning("LoadCfg: %s! Using empty device prefix!\n", strErr.c_str());
	}

	/////////////////////////////////////////////////////////////////////////
	// deviceID

	if(GetStringValue(jtCfg, _CFG_KEY_NAME_DEVICE_ID, m_strDeviceID, strErr))
	{
		rlf.Info("LoadCfg: Using configured device ID: \"%s\"!\n", m_strDeviceID.c_str());
	}
	else
	{
		m_strDeviceID = CreateDeviceID(m_strDevicePrefix.c_str());
		rlf.Info("LoadCfg: Using automatic device ID: \"%s\"!\n", m_strDeviceID.c_str());
	}

	/////////////////////////////////////////////////////////////////////////
	// userName

	if(GetStringValue(jtCfg, _CFG_KEY_NAME_USERNAME, m_strUsername, strErr))
	{
		rlf.Info("LoadCfg: Username provided.\n");
		m_bHasUsername = (m_strUsername.size() > 0);
	}
	else
	{
		m_bHasUsername = false;
		rlf.Info("LoadCfg: No username provided.\n");
	}

	/////////////////////////////////////////////////////////////////////////
	// passWord

	if(m_bHasUsername)
	{
		if(GetStringValue(jtCfg, _CFG_KEY_NAME_PASSWORD, m_strPassword, strErr))
		{
			rlf.Info("LoadCfg: Password provided.\n");
			m_bHasPassword = (m_strPassword.size() > 0);
		}
		else
		{
			m_bHasUsername = false;
			m_bHasPassword = false;
			rlf.Info("LoadCfg: No password provided.\n");
		}
	}
	else
	{
		m_bHasPassword = false;
	}

	/////////////////////////////////////////////////////////////////////
	// disableTopicPrefix

	if(!GetBoolValue(jtCfg, _CFG_KEY_NAME_DISABLE_TOPIC_PREFIX, m_bDisableTopicPrefix, strErr))
	{
		m_bDisableTopicPrefix = false;
	}

	/////////////////////////////////////////////////////////////////////////
	// topicPrefix

	if(!m_bDisableTopicPrefix)
	{
		if(GetStringValue(jtCfg, _CFG_KEY_NAME_TOPIC_PREFIX_STRING, m_strTopicPrefix, strErr))
		{
			rlf.Info("LoadCfg: Using configured topic prefix: \"%s\"!\n", m_strTopicPrefix.c_str());
		}
		else
		{
			m_strTopicPrefix = formatString("%s/%s", GetDeviceID(), GetShmID());
			rlf.Info("LoadCfg: Using automatic topic prefix: \"%s\"!\n", m_strTopicPrefix.c_str());
		}
	}
	else
	{
		m_strTopicPrefix.clear();
		rlf.Warning("LoadCfg: Topic prefix disabled!\n");
	}

	/////////////////////////////////////////////////////////////////////////
	// if m_nTlsMode != MQTTCL_TLS_MODE_OFF

	if(m_nTlsMode == MQTTCL_TLS_MODE_CRT)
	{
		/////////////////////////////////////////////////////////////////////
		// tlsCaCrtFile

		if(!GetStringValue(jtCfg, _CFG_KEY_NAME_TLS_CA_CRT_FILE, m_strTlsCaCrtFile, strErr))
		{
			rlf.Error("LoadCfg: %s! TLS-Mode = %d and no Certificate Authority file provided! No way to continue!\n", strErr.c_str(), m_nTlsMode);
			return false;
		}

		/////////////////////////////////////////////////////////////////////
		// tlsClCrtFile

		if(!GetStringValue(jtCfg, _CFG_KEY_NAME_TLS_CL_CRT_FILE, m_strTlsClCrtFile, strErr))
		{
			rlf.Error("LoadCfg: %s! TLS-Mode = %d and no public Key Certificate file provided! No way to continue!\n", strErr.c_str(), m_nTlsMode);
			return false;
		}

		/////////////////////////////////////////////////////////////////////
		// tlsClKeyFile

		if(!GetStringValue(jtCfg, _CFG_KEY_NAME_TLS_CL_KEY_FILE, m_strTlsClKeyFile, strErr))
		{
			rlf.Error("LoadCfg: %s! TLS-Mode = %d and no private Key file provided! No way to continue!\n", strErr.c_str(), m_nTlsMode);
			return false;
		}
	}
	else if(m_nTlsMode == MQTTCL_TLS_MODE_PSK)
	{
		/////////////////////////////////////////////////////////////////////
		// tlsPsk

		if(!GetStringValue(jtCfg, _CFG_KEY_NAME_TLS_PSK, m_strTlsPSK, strErr))
		{
			rlf.Error("LoadCfg: %s! TLS-Mode = %d and no Preshared Key provided! No way to continue!\n", strErr.c_str(), m_nTlsMode);
			return false;
		}

		/////////////////////////////////////////////////////////////////////
		// tlsPskClientID

		if(!GetStringValue(jtCfg, _CFG_KEY_NAME_TLS_PSK_CLIENT_ID, m_strTlsPSKCliID, strErr))
		{
			rlf.Warning("LoadCfg: %s! TLS-Mode = %d, No PSK-Client-ID provided. Using Device-ID.\n", strErr.c_str(), m_nTlsMode);
			m_strTlsPSKCliID = m_strDeviceID;
		}
	}

	return true;
}

/////////////////////////////////////////////////////////////////////////////

bool CMqttClConfig::GetValue(CJson_t &rjtParent, const char *pszKey, CJson_t &rjtVal, std::string &strErr)
{
	if(!rjtParent.GetValue(pszKey, rjtVal))
	{
		strErr = formatString("Key \"%s\" not found", pszKey);
		return false;
	}
	return true;
}

/////////////////////////////////////////////////////////////////////////////

bool CMqttClConfig::GetBoolValue(CJson_t &rjtParent, const char *pszKey, bool &rbVal, std::string &strErr)
{
	CJson_t jtVal;

	if(GetValue(rjtParent, pszKey, jtVal, strErr))
	{
		int nType;

		switch((nType = jtVal.Type()))
		{
		case JSON_TRUE:
		case JSON_FALSE:
			rbVal = (nType == JSON_TRUE);
			return true;
		default:
			strErr = formatString("\"%s\" (type=%d) is not a boolean value", pszKey, nType);
			return false;
		}
	}

	return false;
}

/////////////////////////////////////////////////////////////////////////////

bool CMqttClConfig::GetIntValue(CJson_t &rjtParent, const char *pszKey, int &rnVal, std::string &strErr)
{
	CJson_t jtVal;

	if(GetValue(rjtParent, pszKey, jtVal, strErr))
	{
		if(json_is_integer(jtVal.operator const json_t*()))
		{
			rnVal = (int)::json_integer_value(jtVal);
			return true;
		}

		strErr = formatString("\"%s\" (type=%d) is not an integer value", pszKey, jtVal.Type());
	}

	return false;
}

/////////////////////////////////////////////////////////////////////////////

bool CMqttClConfig::GetInt64Value(CJson_t &rjtParent, const char *pszKey, long long &rnVal, std::string &strErr)
{
	CJson_t jtVal;

	if(GetValue(rjtParent, pszKey, jtVal, strErr))
	{
		if(json_is_integer(jtVal.operator const json_t*()))
		{
			rnVal = (long long)::json_integer_value(jtVal);
			return true;
		}

		strErr = formatString("\"%s\" (type=%d) is not an integer value", pszKey, jtVal.Type());
	}

	return false;
}

/////////////////////////////////////////////////////////////////////////////

bool CMqttClConfig::GetStringValue(CJson_t &rjtParent, const char *pszKey, std::string &rstrVal, std::string &strErr)
{
	CJson_t jtVal;

	if(GetValue(rjtParent, pszKey, jtVal, strErr))
	{
		if(json_is_string(jtVal.operator const json_t*()))
		{
			rstrVal = ::json_string_value(jtVal);
			return !rstrVal.empty();
		}

		strErr = formatString("\"%s\" (type=%d) is not a string value", pszKey, jtVal.Type());
	}

	rstrVal.clear();
	return false;
}

/////////////////////////////////////////////////////////////////////////////

sa_family_t CMqttClConfig::GetDevIdInterfaceName(char *pszItfName, size_t nCChItfName, const char *pszRequested)
{
	sa_family_t nFamily = 0;
	struct ifaddrs *ifaddr, *ifa;
	memset(pszItfName, 0, nCChItfName);

	if(getifaddrs(&ifaddr) == 0)
	{
		for(ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next)
		{
			if(!ifa->ifa_addr || (ifa->ifa_flags & IFF_LOOPBACK))
				continue;
			if(	ifa->ifa_addr->sa_family == AF_INET ||
				ifa->ifa_addr->sa_family == AF_INET6)
			{
				if(!strcmp(ifa->ifa_name, pszRequested))
				{
					strncpy(pszItfName, ifa->ifa_name, nCChItfName - 1);
					nFamily = ifa->ifa_addr->sa_family;
					break;
				}
				else if(!nFamily)
				{
					strncpy(pszItfName, ifa->ifa_name, nCChItfName - 1);
					nFamily = ifa->ifa_addr->sa_family;
				}
			}
		}

		freeifaddrs(ifaddr);
	}

	return nFamily;
}

bool CMqttClConfig::GetPreferredMacAddress(const char *pszRequested, std::string &s, char sep)
{
	std::string sVal, sPath = ::formatString("/sys/class/net/%s/address", pszRequested);
	if(::readFile(sPath.c_str(), sVal))
	{
		sVal = ::trim(sVal);
		if(!sVal.empty())
		{
			unsigned char m[6];
			if(sscanf(sVal.c_str(), "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx", &m[0], &m[1], &m[2], &m[3], &m[4], &m[5]) == 6)
			{
//				s = ::strucase(sVal.c_str());
				if(sep)
					s = formatString("%02hhX%c%02hhX%c%02hhX%c%02hhX%c%02hhX%c%02hhX" , m[0], sep, m[1], sep, m[2], sep, m[3], sep, m[4], sep, m[5]);
				else
					s = formatString("%02hhX%02hhX%02hhX%02hhX%02hhX%02hhX" , m[0], m[1], m[2], m[3], m[4], m[5]);
				return true;
			}
		}
	}
	return false;
}

const char* CMqttClConfig::GetMacAddress(std::string &s, char sep)
{
	int fd;
	struct ifreq ifr;
	s.clear();
	
	if(GetPreferredMacAddress("eth0", s, sep))
	{
		return s.c_str();
	}

	if((ifr.ifr_addr.sa_family = CMqttClConfig::GetDevIdInterfaceName(ifr.ifr_name, sizeof(ifr.ifr_name), "eth0")))
	{
		if((fd = socket(ifr.ifr_addr.sa_family, SOCK_DGRAM, 0)) >= 0)
		{
			if(	(ioctl(fd, SIOCGIFHWADDR, &ifr) == 0) &&
				(ifr.ifr_hwaddr.sa_family == ARPHRD_ETHER))
			{
				const char *m = (const char*)ifr.ifr_hwaddr.sa_data;
				if(sep)
					s = formatString("%02hhX%c%02hhX%c%02hhX%c%02hhX%c%02hhX%c%02hhX" , m[0], sep, m[1], sep, m[2], sep, m[3], sep, m[4], sep, m[5]);
				else
					s = formatString("%02hhX%02hhX%02hhX%02hhX%02hhX%02hhX" , m[0], m[1], m[2], m[3], m[4], m[5]);
			}

			close(fd);
		}
	}

	return s.c_str();
}

std::string CMqttClConfig::CreateDeviceID(const char *pszDevicePrefix)
{
	std::string m, s;
	if(pszDevicePrefix && *pszDevicePrefix)
		s = formatString("%s-%s", pszDevicePrefix, CMqttClConfig::GetMacAddress(m, 0));
	else
		CMqttClConfig::GetMacAddress(s, 0);
	return s;
}