bool ICACHE_FLASH_ATTR otb_conf_verify(otb_conf_struct *conf)
{
bool rc = FALSE;
int ii;
char pad[3] = {0, 0, 0};
bool modified = FALSE;
int valid_adss = 0;
DEBUG("CONF: otb_conf_verify entry");
// Test magic value
if (otb_conf->magic != OTB_CONF_MAGIC)
{
ERROR("CONF: Bad magic value - invalid config file");
rc = FALSE;
goto EXIT_LABEL;
}
// Test version valid
if (otb_conf->version > OTB_CONF_VERSION_CURRENT)
{
ERROR("CONF: Bad magic value - invalid config file");
rc = FALSE;
goto EXIT_LABEL;
}
// Test checksum
rc = otb_conf_verify_checksum(conf);
if (!rc)
{
ERROR("CONF: Bad checksum - invalid config file");
goto EXIT_LABEL;
}
if (otb_conf->version >= 1)
{
if ((os_strnlen(conf->ssid, OTB_CONF_WIFI_SSID_MAX_LEN) >=
OTB_CONF_WIFI_SSID_MAX_LEN) ||
(os_strnlen(conf->password, OTB_CONF_WIFI_PASSWORD_MAX_LEN) >=
OTB_CONF_WIFI_PASSWORD_MAX_LEN))
{
// Reset _both_ ssid and password if either got corrupted
WARN("CONF: SSID or Password wasn't null terminated");
os_memset(conf->ssid, 0, OTB_CONF_WIFI_SSID_MAX_LEN);
os_memset(conf->password, 0, OTB_CONF_WIFI_PASSWORD_MAX_LEN);
modified = TRUE;
}
if (os_memcmp(conf->pad1, pad, sizeof(*(conf->pad1))))
{
WARN("CONF: Pad 1 wasn't 0");
os_memset(conf->pad1, 0, 3);
modified = TRUE;
}
// DS18B20 config checking
if ((conf->ds18b20s < 0) || (conf->ds18b20s > OTB_DS18B20_MAX_DS18B20S))
{
WARN("CONF: Invalid number of DS18B20s");
conf->ds18b20s = 0;
os_memset(conf->ds18b20, 0, OTB_DS18B20_MAX_DS18B20S * sizeof(otb_conf_ds18b20));
}
for (ii = 0; ii < OTB_DS18B20_MAX_DS18B20S; ii++)
{
// Check DS18B20 id is right length (or 0), and location is null terminated
if (((os_strnlen(conf->ds18b20[ii].id, OTB_CONF_DS18B20_MAX_ID_LEN) !=
OTB_CONF_DS18B20_MAX_ID_LEN-1) &&
(conf->ds18b20[ii].id[0] != 0)) ||
(os_strnlen(conf->ds18b20[ii].loc, OTB_CONF_DS18B20_LOCATION_MAX_LEN) >=
OTB_CONF_DS18B20_LOCATION_MAX_LEN))
{
WARN("CONF: DS18B20 index %d id or location invalid", ii);
os_memset(conf->ds18b20[ii].id, 0, OTB_CONF_DS18B20_MAX_ID_LEN);
os_memset(conf->ds18b20[ii].loc, 0, OTB_CONF_DS18B20_LOCATION_MAX_LEN);
modified = TRUE;
}
}
if ((os_strnlen(conf->loc.loc1, OTB_CONF_LOCATION_MAX_LEN) >=
OTB_CONF_LOCATION_MAX_LEN) ||
(os_strnlen(conf->loc.loc2, OTB_CONF_LOCATION_MAX_LEN) >=
OTB_CONF_LOCATION_MAX_LEN) ||
(os_strnlen(conf->loc.loc3, OTB_CONF_LOCATION_MAX_LEN) >=
OTB_CONF_LOCATION_MAX_LEN))
{
WARN("CONF: Location invalid");
os_memset(conf->loc.loc1, 0, OTB_CONF_LOCATION_MAX_LEN);
os_memset(conf->loc.loc2, 0, OTB_CONF_LOCATION_MAX_LEN);
os_memset(conf->loc.loc3, 0, OTB_CONF_LOCATION_MAX_LEN);
modified = TRUE;
}
// ADS config checking
if ((conf->adss < 0) || (conf->adss > OTB_CONF_ADS_MAX_ADSS))
{
WARN("CONF: Invalid number of ADSs");
otb_conf_ads_init(conf);
modified = TRUE;
}
for (ii = 0; ii < OTB_CONF_ADS_MAX_ADSS; ii++)
{
if (conf->ads[ii].addr != 0x00)
{
valid_adss++;
}
}
if (valid_adss != otb_conf->adss)
{
WARN("CONF: Wrong overall ADS number set - clearing");
otb_conf_ads_init(conf);
modified = TRUE;
}
for (ii = 0; ii < OTB_CONF_ADS_MAX_ADSS; ii++)
{
// Check ADS id is right length (or 0), and location is null terminated
if ((os_strnlen(conf->ads[ii].loc, OTB_CONF_ADS_LOCATION_MAX_LEN) >=
OTB_CONF_ADS_LOCATION_MAX_LEN) ||
((conf->ads[ii].addr != 0x00) &&
(conf->ads[ii].addr != 0x48) &&
(conf->ads[ii].addr != 0x49) &&
(conf->ads[ii].addr != 0x4a) &&
(conf->ads[ii].addr != 0x4b)) ||
(conf->ads[ii].index != ii) ||
(conf->ads[ii].pad1[0] != 0) ||
((conf->ads[ii].mux < 0) || (conf->ads[ii].mux > 7)) ||
((conf->ads[ii].gain < 0) || (conf->ads[ii].gain > 7)) ||
((conf->ads[ii].rate < 0) || (conf->ads[ii].rate > 7)) ||
((conf->ads[ii].cont < 0) || (conf->ads[ii].cont > 1)) ||
((conf->ads[ii].rms < 0) || (conf->ads[ii].rms > 1)) ||
((conf->ads[ii].period < 0) || (conf->ads[ii].period >= 0xffff)) ||
((conf->ads[ii].samples < 0) || (conf->ads[ii].samples >= 1024)))
{
WARN("CONF: ADS index %d something invalid", ii);
INFO("CONF: ADS %d index: %d", ii, conf->ads[ii].index);
INFO("CONF: ADS %d address: 0x%02x", ii, conf->ads[ii].addr);
INFO("CONF: ADS %d location: %s", ii, conf->ads[ii].loc);
INFO("CONF: ADS %d pad1: 0x%x", ii, conf->ads[ii].pad1[0]);
INFO("CONF: ADS %d mux: 0x%x", ii, conf->ads[ii].mux);
INFO("CONF: ADS %d gain: 0x%x", ii, conf->ads[ii].gain);
INFO("CONF: ADS %d rate: 0x%x", ii, conf->ads[ii].rate);
INFO("CONF: ADS %d cont: 0x%x", ii, conf->ads[ii].cont);
INFO("CONF: ADS %d rms: 0x%x", ii, conf->ads[ii].rms);
INFO("CONF: ADS %d period: %ds", ii, conf->ads[ii].period);
INFO("CONF: ADS %d samples: %d", ii, conf->ads[ii].samples);
otb_conf_ads_init_one(&(conf->ads[ii]), ii);
modified = TRUE;
}
}
for (ii = 0; ii < 17; ii++)
{
if ((conf->gpio_boot_state[ii] < 0) || (conf->gpio_boot_state[ii] > 1))
{
WARN("CONF: gpio_boot_state %d invalid 0x2.2x", ii, conf->gpio_boot_state[ii]);
conf->gpio_boot_state[ii] = 0;
modified = TRUE;
}
}
for (ii = 0; ii < 3; ii++)
{
if (conf->pad3[ii] != 0)
{
WARN("CONF: pad3 %d invalid 0x%2.2x", ii, conf->pad3[0]);
conf->pad3[ii] = 0;
modified = TRUE;
}
}
}
if (otb_conf->version > 1)
{
// When increment version number need to add code here to handle checking new
// fields, and also upgrading back level versions
ERROR("CONF: No versioning code provided for config version: %d", otb_conf->version);
OTB_ASSERT(FALSE);
}
if (modified)
{
// Need to update rather than save so new checksum is calculated
rc = otb_conf_update(conf);
if (!rc)
{
ERROR("CONF: Failed to save corrected config");
goto EXIT_LABEL;
}
}
// If we get this far everything was fine, or we fixed it
rc = TRUE;
EXIT_LABEL:
DEBUG("CONF: otb_conf_verify exit");
return(rc);
}
/** \brief Figure out the identity of the current process
*
* os_procFigureIdentity determines the numeric, and if possible named
* identity of a process. It will first check if the environment variable
* SPLICE_PROCNAME is set (which is always the case if the process is started
* via os_procCreate). If so, that value will be returned. Otherwise it will be
* attempted to determine the commandline which started the process through the
* procfs. If that fails, the PID will be returned.
*
* \param procIdentity Pointer to a char-buffer to which the result can be
* written. If a name could be resolved, the result will
* have the format "name <PID>". Otherwise it will just
* be "<PID>".
* \param procIdentitySize Size of the buffer pointed to by procIdentitySize
* \return same as snprintf returns
*/
os_int32
os_procFigureIdentity(
char *procIdentity,
os_uint32 procIdentitySize)
{
os_int32 size = 0;
char *process_name;
size_t r = 0;
int missingBytes = 0;
process_name = os_getenv("SPLICE_PROCNAME");
if (process_name != NULL) {
size = snprintf(procIdentity, procIdentitySize, "%s <%d>",
process_name, os_procIdToInteger(os_procIdSelf()));
} else {
char *procPath;
procPath = (char*) os_malloc(_OS_PROCESS_DEFAULT_CMDLINE_LEN_);
if (procPath) {
size = snprintf(procPath, _OS_PROCESS_DEFAULT_CMDLINE_LEN_,
_OS_PROCESS_PROCFS_PATH_FMT_, os_procIdToInteger(os_procIdSelf()));
if (size >= _OS_PROCESS_DEFAULT_CMDLINE_LEN_) { /* pid is apparently longer */
char *tmp = (char*) os_realloc(procPath, size + 1);
if (tmp) {
procPath = tmp;
size = snprintf(procPath, size + 1, _OS_PROCESS_PROCFS_PATH_FMT_,
os_procIdToInteger(os_procIdSelf()));
} else {
/* Memory-claim failed, revert to default (just pid) */
size = 0;
}
}
/* procPath is set */
if (size > 0) {
if (os_access(procPath, OS_ROK) == os_resultSuccess) {
FILE *proc = fopen(procPath, "r");
if (proc) {
do {
r += fread((void*)&procIdentity[r], 1L, procIdentitySize-r,proc);
} while( ferror(proc) && errno == EINTR );
/* Only count characters till the first null */
r = os_strnlen( procIdentity, r );
if ( r == procIdentitySize )
{
char altbuffer[16];
int usefullRead;
/* Buffer is full null terminate it */
procIdentity[r-1] = '\0';
/* There may be more bytes - count them*/
do {
int p=0;
do {
p += fread((void*)&altbuffer, 1L,
sizeof(altbuffer)-p,proc);
} while( ferror(proc) && errno == EINTR );
usefullRead=os_strnlen(&altbuffer[0], sizeof(altbuffer));
missingBytes+=usefullRead;
} while ( usefullRead == sizeof(altbuffer) );
/* Account for space before pid */
missingBytes++;
}
else if ( r > 1 ) {
/* Add a space before the pid */
procIdentity[r++] = ' ';
}
fclose(proc);
}
}
}
os_free(procPath);
}
size = snprintf(&procIdentity[r], procIdentitySize-r,
"<%d>", os_procIdToInteger(os_procIdSelf()));
size = size+r+missingBytes;
}
return size;
}
