/*
* The only current difference is that POSTGRES needs to escape the backquotes
* while everything else does not
*/
void catstr(string *str, char *s)
{
while(*s)
{
if(!(*s)) return;
switch(*s) {
case '\'':
string_cat(str, "''");
break;
/*
case '"':
string_cat(str, "\"\"");
break;
*/
case '\\':
if(mode == SHSQL_POSTGRES)
string_cat(str, "\\\\");
else
string_cat_c(str, *s);
break;
default:
string_cat_c(str, *s);
break;
}
s++;
}
}
irom static void trigger_type_to_string(io_trigger_t trigger_type, string_t *string)
{
switch(trigger_type)
{
case(io_trigger_off):
{
string_cat(string, "off");
break;
}
case(io_trigger_on):
{
string_cat(string, "on");
break;
}
case(io_trigger_down):
{
string_cat(string, "down");
break;
}
case(io_trigger_up):
{
string_cat(string, "up");
break;
}
default:
{
string_cat(string, "error");
break;
}
}
}
irom io_error_t io_trigger_pin(string_t *error, int io, int pin, io_trigger_t trigger_type)
{
const io_info_entry_t *info;
io_data_entry_t *data;
io_config_pin_entry_t *pin_config;
io_data_pin_entry_t *pin_data;
if(io >= io_id_size)
{
if(error)
string_cat(error, "io out of range\n");
return(io_error);
}
info = &io_info[io];
data = &io_data[io];
if(pin >= info->pins)
{
if(error)
string_cat(error, "pin out of range\n");
return(io_error);
}
pin_config = &config.io_config[io][pin];
pin_data = &data->pin[pin];
return(io_trigger_pin_x(error, info, pin_data, pin_config, pin, trigger_type));
}
irom static void pin_string_from_flags(string_t *flags, const io_config_pin_entry_t *pin_config)
{
bool none = true;
if(pin_config->flags.autostart)
{
none = false;
string_cat(flags, " autostart");
}
if(pin_config->flags.repeat)
{
none = false;
string_cat(flags, " repeat");
}
if(pin_config->flags.pullup)
{
none = false;
string_cat(flags, " pullup");
}
if(pin_config->flags.reset_on_read)
{
none = false;
string_cat(flags, " reset-on-read");
}
if(none)
string_cat(flags, " <none>");
}
irom static app_action_t application_function_i2c_write(const string_t *src, string_t *dst)
{
i2c_error_t error;
static uint8_t bytes[32];
int current, out;
for(current = 0; current < (int)sizeof(bytes); current++)
{
if(parse_int(current + 1, src, &out, 16) != parse_ok)
break;
bytes[current] = (uint8_t)(out & 0xff);
}
if((error = i2c_send(i2c_address, current, bytes)) != i2c_error_ok)
{
string_cat(dst, "i2c_write");
i2c_error_format_string(dst, error);
string_cat(dst, "\n");
i2c_reset();
return(app_action_error);
}
string_format(dst, "i2c_write: written %d bytes to %02x\n", current, i2c_address);
return(app_action_normal);
}
static void
convert_cat(String *cap, char *s, Config *c, int maxlen)
{
int res;
if (config_get_boolean(c, "/enfle/plugins/ui/normal/filename_code_conversion", &res)) {
char **froms = config_get_list(c, "/enfle/plugins/ui/normal/filename_code_from", &res);
char *to = config_get_str(c, "/enfle/plugins/ui/normal/filename_code_to");
char *from;
int i = 0;
if (res && to) {
while ((from = froms[i++])) {
char *tmp;
//debug_message_fnc("%s->%s: %s\n", from, to, s);
if ((res = converter_convert(s, &tmp, strlen(s), from, to)) < 0)
continue;
if (maxlen)
string_ncat(cap, tmp, maxlen);
else
string_cat(cap, tmp);
free(tmp);
return;
}
}
}
if (maxlen > 0)
string_ncat(cap, s, maxlen);
else
string_cat(cap, s);
}
char* MakeStringName2(const char* aT1, const char* aT2, const char* aT3) {
size_t size = strlen(aT1) + strlen(aT2) + strlen(aT3);
char* str = (char*)BEHAVIAC_MALLOC_WITHTAG(size + 1, "CRTTIBase");
string_cpy(str, aT1);
string_cat(str, aT2);
string_cat(str, aT3);
return str;
}
irom static void io_string_from_i2c_type(string_t *name, io_i2c_t type)
{
switch(type)
{
case(io_i2c_sda): { string_cat(name, "sda"); break; }
case(io_i2c_scl): { string_cat(name, "scl"); break; }
default: { string_cat(name, "error"); break; }
}
}
irom void config_dump(string_t *dst, const config_t *cfg)
{
string_new(static, ntp_server, 32);
string_clear(&ntp_server);
string_ip(&ntp_server, cfg->ntp.server);
string_format(dst,
"> config magic: %04x\n"
"> config version: %d\n"
"> wlan client ssid: %s\n"
"> wlan client passwd: %s\n"
"> wlan ap ssid: %s\n"
"> wlan ap passwd: %s\n"
"> wlan ap channel: %d\n"
"> wlan mode: %s mode\n"
"> bridge tcp port: %u\n"
"> bridge tcp timeout: %u\n"
"> command tcp port: %u\n"
"> command tcp timeout: %u\n"
"> ntp server: %s\n"
"> ntp time zone: GMT%c%u\n"
"> display flip timeout: %u\n"
"> display default message: %s\n"
"> status trigger gpio (-1 is disabled): %d/%d\n"
"> wlan association trigger gpio (-1 is disabled): %d/%d\n"
"> flags: ",
cfg->magic,
cfg->version,
cfg->client_wlan.ssid,
cfg->client_wlan.passwd,
cfg->ap_wlan.ssid,
cfg->ap_wlan.passwd,
cfg->ap_wlan.channel,
cfg->wlan_mode == config_wlan_mode_client ? "client" : "ap",
cfg->bridge.port,
cfg->bridge.timeout,
cfg->command.port,
cfg->command.timeout,
string_to_ptr(&ntp_server),
cfg->ntp.timezone >= 0 ? '+' : '-',
cfg->ntp.timezone >= 0 ? cfg->ntp.timezone : 0 - cfg->ntp.timezone,
cfg->display.flip_timeout,
cfg->display.default_msg,
cfg->status_trigger.io,
cfg->status_trigger.pin,
cfg->assoc_trigger.io,
cfg->assoc_trigger.pin);
config_flags_to_string(dst, 0, 0, cfg->flags);
string_cat(dst, "\n> uart: ");
uart_parameters_to_string(dst, &cfg->uart);
string_cat(dst, "\n> gpios:\n");
io_config_dump(dst, cfg, -1, -1, false);
}
gstring *
authres_spf(gstring * g)
{
uschar * s;
if (!spf_result) return g;
g = string_append(g, 2, US";\n\tspf=", spf_result);
if (spf_result_guessed)
g = string_cat(g, US" (best guess record for domain)");
s = expand_string(US"$sender_address_domain");
return s && *s
? string_append(g, 2, US" smtp.mailfrom=", s)
: string_cat(g, US" smtp.mailfrom=<>");
}
irom static app_action_t application_function_i2c_read(const string_t *src, string_t *dst)
{
int size, current;
i2c_error_t error;
uint8_t bytes[32];
uint32_t start, stop, clocks, spent;
if(parse_int(1, src, &size, 0) != parse_ok)
{
string_cat(dst, "i2c-read: missing byte count\n");
return(app_action_error);
}
if(size > (int)sizeof(bytes))
{
string_format(dst, "i2c-read: read max %d bytes\n", sizeof(bytes));
return(app_action_error);
}
start = system_get_time();
if((error = i2c_receive(i2c_address, size, bytes)) != i2c_error_ok)
{
string_cat(dst, "i2c_read");
i2c_error_format_string(dst, error);
string_cat(dst, "\n");
i2c_reset();
return(app_action_error);
}
stop = system_get_time();
string_format(dst, "> i2c_read: read %d bytes from %02x:", size, i2c_address);
for(current = 0; current < size; current++)
string_format(dst, " %02x", bytes[current]);
string_cat(dst, "\n");
clocks = (size + 1) * 20U;
spent = (stop - start) * 1000U;
string_format(dst, "> transferred %u bytes in %u scl clocks\n", size + 1U, clocks);
string_format(dst, "> time spent: %u microseconds, makes %u kHz i2c bus\n",
spent / 1000U, 1000000U / (spent / clocks));
return(app_action_normal);
}
irom static io_error_t io_write_pin_x(string_t *errormsg, const io_info_entry_t *info, io_data_pin_entry_t *pin_data, io_config_pin_entry_t *pin_config, int pin, int value)
{
io_error_t error;
switch(pin_config->mode)
{
case(io_pin_disabled):
case(io_pin_input_digital):
case(io_pin_input_analog):
case(io_pin_i2c):
case(io_pin_uart):
case(io_pin_error):
case(io_pin_trigger):
{
if(errormsg)
string_cat(errormsg, "cannot write to this pin");
return(io_error);
}
case(io_pin_counter):
case(io_pin_output_digital):
case(io_pin_lcd):
case(io_pin_timer):
case(io_pin_output_analog):
{
if((error = info->write_pin_fn(errormsg, info, pin_data, pin_config, pin, value)) != io_ok)
return(error);
break;
}
}
return(io_ok);
}
char *uri2filename(UriUriA *uri)
{
char *furi_str = uri2string(uri);
char *newfilename = NULL;
if (!furi_str)
return NULL;
string_replace_with_char(furi_str, "//", *DIR_SEPAR_STR);
string_replace_with_char(furi_str, "/", *DIR_SEPAR_STR);
#ifdef _WIN32
string_replace_with_char(furi_str, ":", '_');
#endif
if (furi_str) {
string_printf(&newfilename, "%s%s", option_values.file_output_directory, furi_str);
if (newfilename[strlen(newfilename)-1] == *DIR_SEPAR_STR)
string_cat(&newfilename, "index.html");
}
string_free(furi_str);
return newfilename;
}
irom app_action_t application_function_ota_finish(const string_t *src, string_t *dst)
{
static uint8_t md5_result[16];
string_new(static, local_md5_string, 34);
string_new(static, remote_md5_string, 34);
app_action_t action;
if((ota_state != state_write) && (ota_state != state_verify))
{
string_cat(dst, "OTA: not active\n");
ota_state = state_inactive;
return(app_action_error);
}
string_clear(&remote_md5_string);
if((parse_string(1, src, &remote_md5_string)) != parse_ok)
{
string_copy(dst, "OTA: missing md5sum string\n");
ota_state = state_inactive;
return(app_action_error);
}
if((string_length(&buffer_4k) > 0) &&
((action = flash_write_verify(src, dst)) != app_action_normal))
{
ota_state = state_inactive;
return(action);
}
if(remote_file_length != received)
{
string_format(dst, "OTA: file size differs: %u != %u\n", remote_file_length, received);
ota_state = state_inactive;
return(app_action_error);
}
string_clear(&local_md5_string);
MD5Final(md5_result, &md5);
string_bin_to_hex(&local_md5_string, md5_result, 16);
string_clear(dst);
if(!string_match_string(&local_md5_string, &remote_md5_string))
{
string_format(dst, "OTA: invalid md5sum: \"%s\" != \"%s\"\n",
string_to_const_ptr(&local_md5_string), string_to_ptr(&remote_md5_string));
ota_state = state_inactive;
return(app_action_error);
}
string_format(dst, "%s %s %s %d %d\n", ota_state == state_verify ? "VERIFY_OK" : "WRITE_OK",
string_to_const_ptr(&local_md5_string),
string_to_const_ptr(&remote_md5_string),
written, skipped);
ota_state = state_successful;
return(app_action_normal);
}
static void
convert_path(String *cap, char *s, Config *c, int maxlen, int reserve)
{
static char delimiters[] = { '/', '#', '\0' };
char *part, **parts, *used_delim;
int i, n;
if ((parts = misc_str_split_delimiters(s, delimiters, &used_delim)) == NULL) {
err_message_fnc("No enough memory.\n");
return;
}
n = 0;
while (parts[n])
n++;
i = 0;
while ((part = parts[i])) {
int over = RESERVE_LEN + string_length(cap) + strlen(part) + strlen(REPLACE_STR) + reserve / n - maxlen;
if (maxlen > 0 && over > 0) {
convert_cat(cap, part, c, strlen(part) - over);
string_cat(cap, REPLACE_STR);
} else {
convert_cat(cap, part, c, 0);
}
if (used_delim[i] != '\0')
string_cat_ch(cap, used_delim[i]);
i++;
}
misc_free_str_array(parts);
free(used_delim);
}
int main()
{
char *dest = "helo ";
char *tnt = "monk";
string_cat(dest, tnt);
printf("%s\n", dest);
}
//Generate a verification key using two null-terminated strings
//Concatenates the strings together then hashes them with sha_hash
unsigned char *create_v_key(char* data1, char *data2)
{
char *tmp = string_cat(2,data1,data2); //TODO XOR these instead?
unsigned char* key = sha_hash((unsigned char *)tmp, (long)strlen(tmp));
free(tmp);
return key;
}
void
op_add(void)
{
Var right, left, ret;
right = pop(); left = pop();
if (left.type != right.type && left.type != LIST) {
var_free(left); var_free(right);
raise(E_TYPE);
} else if (left.type == NUM) {
left.v.num = left.v.num + right.v.num;
push(left);
} else if (left.type == STR) {
ret.type = STR;
if (left.v.str->ref == 1) {
ret.v.str = string_cat(left.v.str, right.v.str->str);
} else {
ret.v.str = string_new(left.v.str->len + right.v.str->len + 1);
strcpy(ret.v.str->str, left.v.str->str);
strcpy(ret.v.str->str + left.v.str->len, right.v.str->str);
ret.v.str->len = left.v.str->len + right.v.str->len;
var_free(left);
}
var_free(right);
push(ret);
} else if (left.type == LIST) {
ret.type = LIST;
ret.v.list = list_setadd(left.v.list, right);
push(ret);
} else {
var_free(left); var_free(right);
raise(E_TYPE);
}
}
static int sqlite_callback(void *arg, int argc, char **argv, char **azColName)
{
struct strbuf *res = arg;
int i;
/* For second and subsequent results, insert \n */
if (res->string != NULL)
res->string = string_cat(res->string, &res->size, &res->len, US"\n", 1);
if (argc > 1)
{
/* For multiple fields, include the field name too */
for (i = 0; i < argc; i++)
{
uschar *value = US((argv[i] != NULL)? argv[i]:"<NULL>");
res->string = lf_quote(US azColName[i], value, Ustrlen(value), res->string,
&res->size, &res->len);
}
}
else
{
res->string = string_append(res->string, &res->size, &res->len, 1,
(argv[0] != NULL)? argv[0]:"<NULL>");
}
res->string[res->len] = 0;
return 0;
}
irom static app_action_t application_function_i2c_reset(const string_t *src, string_t *dst)
{
i2c_error_t error;
if((error = i2c_reset()) != i2c_error_ok)
{
string_cat(dst, "i2c-reset: ");
i2c_error_format_string(dst, error);
string_cat(dst, "\n");
return(app_action_error);
}
string_cat(dst, "i2c_reset: ok\n");
return(app_action_normal);
}
void dolines(SQLHSTMT *stmt, SQLSMALLINT ncol, char format)
{
int j;
long ans;
string *str, *tstr;
char istr[256];
long sb = 0;
SQLLEN si;
str = new_string();
tstr = new_string();
for(;;)
{
ans = SQLFetch(*stmt);
/*
* I assume error here is EOF...
*/
if((ans != SQL_SUCCESS) && ( ans != SQL_SUCCESS_WITH_INFO))
break;
for(j=0;j<ncol;j++)
{
si = 0;
for(;;)
{
ans = SQLGetData(stmt, j+1, SQL_C_CHAR, istr, 256, &si);
if(ans == SQL_NO_DATA) break;
if(si == SQL_NO_TOTAL)
{
sb += 255;
}
else
{
sb += si;
}
string_cat(tstr, istr);
if(si != SQL_NO_TOTAL) break;
}
dolitem(str, string_s(tstr), (j == ncol - 1), format);
string_clear(tstr);
}
string_cat_c(str, '\n');
if(message_send(mes, str, 0, MES_SERVER_TO_CLIENT) < 0) return;
string_clear(str);
}
string_delete(str);
string_delete(tstr);
return;
}
static uschar *
rfc2231_to_2047(const uschar * fname, const uschar * charset, int * len)
{
int size = 0, ptr = 0;
uschar * val = string_cat(NULL, &size, &ptr, US"=?", 2);
uschar c;
if (charset)
val = string_cat(val, &size, &ptr, charset, Ustrlen(charset));
val = string_cat(val, &size, &ptr, US"?Q?", 3);
while ((c = *fname))
if (c == '%' && isxdigit(fname[1]) && isxdigit(fname[2]))
{
val = string_cat(val, &size, &ptr, US"=", 1);
val = string_cat(val, &size, &ptr, ++fname, 2);
fname += 2;
}
else
val = string_cat(val, &size, &ptr, fname++, 1);
val = string_cat(val, &size, &ptr, US"?=", 2);
val[*len = ptr] = '\0';
return val;
}
void prepend_pref_path(char * dst, const char * src, int maxlen) {
if (SDL_strlcpy(dst, pref_path, maxlen) >= maxlen) {
fatal("not enough space for pref_path");
}
if (SDL_strlcat(dst, src, maxlen) >= maxlen) {
char * msg = string_cat(src, " too long");
fatal(msg);
}
}
irom void i2c_error_format_string(string_t *dst, i2c_error_t error)
{
string_cat(dst, ": i2c bus error: ");
if(error < i2c_error_size)
string_cat_ptr(dst, error_strings[error]);
else
string_cat(dst, "<unknown error>");
string_cat(dst, " (in bus state: ");
if(state < i2c_state_size)
string_cat_ptr(dst, state_strings[state]);
else
string_format(dst, "<unknown state %d>", state);
string_cat(dst, ")");
}
irom static app_action_t ota_start(const string_t *src, string_t *dst, bool verify)
{
rboot_config rcfg = rboot_get_config();
if(string_size(&buffer_4k) < 0x1000)
{
string_format(dst, "OTA: string write buffer too small: %d\n", string_size(&buffer_4k));
return(app_action_error);
}
if((rcfg.magic != BOOT_CONFIG_MAGIC) || (rcfg.count != 2) || (rcfg.current_rom > 1))
{
string_cat(dst, "OTA: rboot config invalid\n");
return(app_action_error);
}
if(parse_int(1, src, &remote_file_length, 0) != parse_ok)
{
string_cat(dst, "OTA: invalid/missing file length\n");
return(app_action_error);
}
if(wlan_scan_active())
{
string_cat(dst, "OTA: wlan scan active\n");
return(app_action_error);
}
ota_state = verify ? state_verify : state_write;
flash_slot = rcfg.current_rom == 0 ? 1 : 0;
flash_sector = rcfg.roms[flash_slot] / 0x1000;
received = 0;
written = 0;
skipped = 0;
string_clear(&buffer_4k);
string_crc32_init();
MD5Init(&md5);
string_format(dst, "%s %d %d\n", verify ? "VERIFY" : "WRITE", flash_slot, flash_sector);
return(app_action_normal);
}
static int concat_parts(t_printf_part **beginning, char **ret)
{
t_printf_part *current;
size_t len;
current = *beginning;
len = final_string_size(current);
if (!(*ret = (char*)ft_memalloc(sizeof(char) * (len + 1))))
return (-1);
string_cat(*ret, 0);
while (current)
{
string_cat((char*)current->str_ptr, current->str_size);
string_cat(current->nbr_ptr, current->nbr_size);
current = current->next;
}
string_cat(NULL, 0);
return (len);
}
irom static app_action_t application_function_i2c_sensor_calibrate(const string_t *src, string_t *dst)
{
int intin;
i2c_sensor_t sensor;
double factor;
double offset;
if(parse_int(1, src, &intin, 0) != parse_ok)
{
string_cat(dst, "> invalid i2c sensor\n");
return(app_action_error);
}
sensor = (i2c_sensor_t)intin;
if(parse_float(2, src, &factor) != parse_ok)
{
string_cat(dst, "> invalid factor\n");
return(app_action_error);
}
if(parse_float(3, src, &offset) != parse_ok)
{
string_cat(dst, "> invalid offset\n");
return(app_action_error);
}
if(!i2c_sensor_setcal(sensor, factor, offset))
{
string_format(dst, "> invalid i2c sensor: %d\n", (int)sensor);
return(app_action_error);
}
string_format(dst, "> i2c sensor %d calibration set to factor ", (int)sensor);
string_double(dst, config.i2c_sensors.sensor[sensor].calibration.factor, 4, 1e10);
string_cat(dst, ", offset: ");
string_double(dst, config.i2c_sensors.sensor[sensor].calibration.offset, 4, 1e10);
string_cat(dst, "\n");
return(app_action_normal);
}
irom static app_action_t application_function_wlan_list(const string_t *src, string_t *dst)
{
if(wlan_scan_state != ws_finished)
{
string_cat(dst, "wlan scan: no results (yet)\n");
return(app_action_normal);
}
string_copy_string(dst, &buffer_4k);
wlan_scan_state = ws_inactive;
return(app_action_normal);
}
irom static app_action_t application_function_wlan_scan(const string_t *src, string_t *dst)
{
if(wlan_scan_state != ws_inactive)
{
string_cat(dst, "wlan-scan: already scanning\n");
return(app_action_error);
}
#if IMAGE_OTA == 1
if(ota_active())
{
string_cat(dst, "wlan-scan: ota active\n");
return(app_action_error);
}
#endif
wlan_scan_state = ws_scanning;
wifi_station_scan(0, wlan_scan_done_callback);
string_cat(dst, "wlan scan started, use wlan-list to retrieve the results\n");
return(app_action_normal);
}
irom static app_action_t application_function_wlan_mode(const string_t *src, string_t *dst)
{
if(parse_string(1, src, dst) != parse_ok)
{
string_cat(dst, "wlan-mode: supply mode: client or ap\n");
return(app_action_error);
}
if(string_match(dst, "client"))
{
string_clear(dst);
config.wlan_mode = config_wlan_mode_client;
if(!wlan_init())
{
string_cat(dst, "wlan-mode: invalid mode\n");
return(app_action_error);
}
return(app_action_disconnect);
}
if(string_match(dst, "ap"))
{
string_clear(dst);
config.wlan_mode = config_wlan_mode_ap;
if(!wlan_init())
{
string_cat(dst, "wlan-mode: invalid mode\n");
return(app_action_error);
}
return(app_action_disconnect);
}
string_cat(dst, ": invalid wlan mode\n");
return(app_action_error);
}
