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);
}
irom static app_action_t application_function_wlan_ap_configure(const string_t *src, string_t *dst)
{
string_clear(&ssid);
string_clear(&passwd);
int channel;
if((parse_string(1, src, &ssid) == parse_ok) && (parse_string(2, src, &passwd) == parse_ok) &&
(parse_int(3, src, &channel, 0) == parse_ok))
{
if((channel < 1) || (channel > 13))
{
string_format(dst, "wlan-ap-configure: channel %d out of range (1-13)\n", channel);
return(app_action_error);
}
if(string_length(&passwd) < 8)
{
string_format(dst, "wlan-ap-configure: passwd \"%s\" too short (length must be >= 8)\n",
string_to_ptr(&passwd));
return(app_action_error);
}
strlcpy(config.ap_wlan.ssid, string_to_const_ptr(&ssid), sizeof(config.ap_wlan.ssid));
strlcpy(config.ap_wlan.passwd, string_to_const_ptr(&passwd), sizeof(config.ap_wlan.passwd));
config.ap_wlan.channel = channel;
}
string_format(dst, "wlan-ap-configure: ssid: \"%s\", passwd: \"%s\", channel: %d\n",
config.ap_wlan.ssid, config.ap_wlan.passwd, config.ap_wlan.channel);
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;
}
/*
* input : uname(STR) aname(STR)
* return: NORMAL
* reply : NULL
*/
static NEOERR* aic_cmd_appuserin(struct queue_entry *q, struct cache *cd, mdb_conn *db)
{
STRING str; string_init(&str);
char *aname, *uname;
int aid, uid;
NEOERR *err;
REQ_GET_PARAM_STR(q->hdfrcv, "aname", aname);
REQ_GET_PARAM_STR(q->hdfrcv, "uname", uname);
aid = hash_string(aname);
uid = hash_string(uname);
hdf_set_int_value(q->hdfrcv, "uid", uid);
hdf_set_int_value(q->hdfrcv, "aid", aid);
err = aic_cmd_appusers(q, cd, db);
if (err != STATUS_OK) return nerr_pass(err);
if (hdf_get_valuef(q->hdfsnd, "userlist.%s.uname", uname))
return STATUS_OK;
err = mcs_build_incol(q->hdfrcv,
hdf_get_obj(g_cfg, CONFIG_PATH".InsertCol.userinfo"),
&str);
if (err != STATUS_OK) return nerr_pass(err);
MDB_EXEC(db, NULL, "INSERT INTO userinfo %s", NULL, str.buf);
string_clear(&str);
cache_delf(cd, PREFIX_USERLIST"%d", aid);
return STATUS_OK;
}
static NEOERR* aux_cmd_inboxadd(struct aux_entry *e, QueueEntry *q)
{
STRING str; string_init(&str);
NEOERR *err;
mdb_conn *db = e->db;
HDF *node = hdf_get_child(q->hdfrcv, "mmid");
insert:
if (node) hdf_set_value(q->hdfrcv, "mid", hdf_obj_value(node));
err = mdb_build_incol(q->hdfrcv,
hdf_get_obj(g_cfg, CONFIG_PATH".InsertCol.inbox"),
&str);
if (err != STATUS_OK) return nerr_pass(err);
MDB_EXEC(db, NULL, "INSERT INTO inbox %s", NULL, str.buf);
string_clear(&str);
if (node) {
node = hdf_obj_next(node);
if (node) goto insert;
}
return STATUS_OK;
}
static NEOERR* aux_cmd_emailadd(struct aux_entry *e, QueueEntry *q)
{
STRING str; string_init(&str);
char sum[LEN_MD5], *content;
NEOERR *err;
mdb_conn *db = e->db;
REQ_GET_PARAM_STR(q->hdfrcv, "content", content);
mstr_md5_str(content, sum);
hdf_set_value(q->hdfrcv, "checksum", sum);
HDF *node = hdf_get_child(q->hdfrcv, "mto");
insert:
if (node) hdf_set_value(q->hdfrcv, "to", hdf_obj_value(node));
err = mdb_build_incol(q->hdfrcv,
hdf_get_obj(g_cfg, CONFIG_PATH".InsertCol.email"),
&str);
if (err != STATUS_OK) return nerr_pass(err);
MDB_EXEC(db, NULL, "INSERT INTO email %s", NULL, str.buf);
string_clear(&str);
if (node) {
node = hdf_obj_next(node);
if (node) goto insert;
}
return STATUS_OK;
}
static NEOERR* aux_cmd_cmtadd(struct aux_entry *e, QueueEntry *q)
{
STRING str; string_init(&str);
int type, oid;
NEOERR *err;
REQ_GET_PARAM_INT(q->hdfrcv, "type", type);
REQ_GET_PARAM_INT(q->hdfrcv, "oid", oid);
mdb_conn *db = e->db;
struct cache *cd = e->cd;
err = mdb_build_incol(q->hdfrcv,
hdf_get_obj(g_cfg, CONFIG_PATH".InsertCol.comment"),
&str);
if (err != STATUS_OK) return nerr_pass(err);
MDB_EXEC(db, NULL, "INSERT INTO comment %s", NULL, str.buf);
string_clear(&str);
cache_delf(cd, PREFIX_COMMENT"%d:%d_0", type, oid);
return STATUS_OK;
}
NEOERR* system_who_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
STRING str; string_init(&str);
mdb_conn *db = hash_lookup(dbh, "trace");
char *mname;
NEOERR *err;
MCS_NOT_NULLB(cgi->hdf, db);
MEMBER_CHECK_ADMIN();
SET_DASHBOARD_ACTION(cgi->hdf);
hdf_set_int_value(cgi->hdf, PRE_QUERY".type", TRACE_TYPE_PAGEVIEW);
err = mdb_build_querycond(hdf_get_obj(cgi->hdf, PRE_QUERY),
hdf_get_obj(g_cfg, "Db.QueryCond.system.who"),
&str, NULL);
if (err != STATUS_OK) return nerr_pass(err);
MDB_QUERY_RAW(db, "emap", _COL_EMAP_WHO,
" %s GROUP BY sender ORDER BY min(intime) DESC LIMIT 100",
NULL, str.buf);
err = mdb_set_rows(cgi->hdf, db, _COL_EMAP_WHO, PRE_OUTPUT".who",
NULL, MDB_FLAG_EMPTY_OK);
if (err != STATUS_OK) return nerr_pass(err);
string_clear(&str);
hdf_set_attr(cgi->hdf, PRE_OUTPUT".who", "type", "array");
return STATUS_OK;
}
NEOERR* system_view_detail_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
STRING str; string_init(&str);
mdb_conn *db = hash_lookup(dbh, "trace");
char *mname;
NEOERR *err;
MCS_NOT_NULLB(cgi->hdf, db);
MEMBER_CHECK_ADMIN();
SET_DASHBOARD_ACTION(cgi->hdf);
err = mdb_build_querycond(hdf_get_obj(cgi->hdf, PRE_QUERY),
hdf_get_obj(g_cfg, "Db.QueryCond.system.viewdetail"),
&str, NULL);
if (err != STATUS_OK) return nerr_pass(err);
MDB_QUERY_RAW(db, "emap", _COL_EMAP_VIEW_DETAIL,
" %s ORDER BY intime LIMIT 100", NULL, str.buf);
err = mdb_set_rows(cgi->hdf, db, _COL_EMAP_VIEW_DETAIL, PRE_OUTPUT".details",
NULL, MDB_FLAG_EMPTY_OK);
if (err != STATUS_OK) return nerr_pass(err);
string_clear(&str);
hdf_set_attr(cgi->hdf, PRE_OUTPUT".details", "type", "array");
return STATUS_OK;
}
void save_dialog_ok(char *filename)
{
/* gtk_widget_set_sensitive(GTK_WIDGET(file_selection), 0);
while(gtk_events_pending())
gtk_main_iteration_do(0);
*/
stop_working();
int r = 0;
if(!map_filename->text[0])
r = 1;
string_clear(map_filename);
char *cc = filename;
while(*cc && *cc != '.')
string_cat_char(map_filename, *cc++);
string_cat_text(map_filename, ".map");
set_map_path();
if(r)
make_wall_texture_paths_relative();
map_save();
start_working();
}
void set_map_path()
{
string_clear(map_path);
// count how many '/'s are in map_filename
int slashes = 0;
char *cc = map_filename->text;
while(*cc)
{
if(*cc++ == '/')
slashes++;
}
cc = map_filename->text;
while(slashes)
{
string_cat_char(map_path, *cc);
if(*cc++ == '/')
slashes--;
}
}
void lerr_opfinish_json(NEOERR *err, HDF *hdf)
{
if (err == STATUS_OK) {
hdf_set_value(hdf, PRE_SUCCESS, "1");
return;
}
hdf_remove_tree(hdf, PRE_SUCCESS);
char buf[1024], errname[128];
NEOERR *neede = mcs_err_valid(err);
if (!neede) neede = err;
snprintf(buf, sizeof(buf), "%s:%d %s",
neede->file, neede->lineno,
_lookup_errname(neede, errname, sizeof(errname)));
/* set PRE_ERRXXX with the most recently err */
if (!hdf_get_obj(hdf, PRE_ERRMSG)) {
hdf_set_value(hdf, PRE_ERRMSG, buf);
}
hdf_set_int_value(hdf, PRE_ERRCODE, neede->error);
STRING str; string_init(&str);
nerr_error_traceback(err, &str);
mtc_err("%s", str.buf);
hdf_set_value(hdf, PRE_ERRTRACE, str.buf);
nerr_ignore(&err);
string_clear(&str);
}
void lerr_opfinish_json(NEOERR *err, HDF *hdf)
{
if (err == STATUS_OK) {
hdf_set_value(hdf, PRE_SUCCESS, "1");
mcs_set_int_attr(hdf, PRE_SUCCESS, "type", CNODE_TYPE_INT);
return;
}
hdf_remove_tree(hdf, PRE_SUCCESS);
NEOERR *neede = mcs_err_valid(err);
/* set PRE_ERRXXX with the most recently err */
mcs_set_int_value_with_type(hdf, PRE_ERRCODE, neede->error, CNODE_TYPE_INT);
if (!hdf_get_obj(hdf, PRE_ERRMSG)) {
hdf_set_valuef(hdf, "%s=%s:%d %s",
PRE_ERRMSG, neede->file, neede->lineno, neede->desc);
}
STRING str; string_init(&str);
nerr_error_traceback(err, &str);
mtc_err("%s", str.buf);
hdf_set_value(hdf, PRE_ERRTRACE, str.buf);
nerr_ignore(&err);
string_clear(&str);
}
void dolines(PGresult *pgr, char format)
{
int i, j, ncol = 0, nrow = 0;
string *str;
char *s;
nrow = PQntuples(pgr);
ncol = PQnfields(pgr);
str = new_string();
for(i=0;i<nrow;i++)
{
for(j=0;j<ncol;j++)
{
s = PQgetvalue(pgr, i, j);
dolitem(str, s, (j == ncol - 1), format);
}
string_cat_c(str, '\n');
if(message_send(mes, str, 0, MES_SERVER_TO_CLIENT) < 0) return;
string_clear(str);
}
string_delete(str);
return;
}
void dolines(MYSQL_RES *res, char format)
{
int j;
unsigned int ncol = 0;
string *str;
char *s;
MYSQL_ROW row;
ncol = mysql_num_fields(res);
str = new_string();
while((row = mysql_fetch_row(res)) != NULL)
{
for(j=0;j<ncol;j++)
{
s = row[j];
dolitem(str, s, (j == ncol - 1), format);
}
string_cat_c(str, '\n');
if(message_send(mes, str, 0, MES_SERVER_TO_CLIENT) < 0) return;
string_clear(str);
}
string_delete(str);
return;
}
static NEOERR* dyn_cmd_addtrack(struct queue_entry *q, struct cache *cd, mdb_conn *db)
{
STRING str; string_init(&str);
char *aname, *uname, *oname;
int aid, uid, oid = 0;
NEOERR *err;
REQ_GET_PARAM_STR(q->hdfrcv, "uname", uname);
REQ_GET_PARAM_STR(q->hdfrcv, "aname", aname);
REQ_FETCH_PARAM_STR(q->hdfrcv, "oname", oname);
uid = hash_string(uname);
aid = hash_string(aname);
if (oname) oid = hash_string(oname);
hdf_set_int_value(q->hdfrcv, "aid", aid);
hdf_set_int_value(q->hdfrcv, "uid", uid);
hdf_set_int_value(q->hdfrcv, "oid", oid);
err = mcs_build_incol(q->hdfrcv,
hdf_get_obj(g_cfg, CONFIG_PATH".InsertCol.track"),
&str);
if (err != STATUS_OK) return nerr_pass(err);
MDB_EXEC(db, NULL, "INSERT INTO track %s", NULL, str.buf);
string_clear(&str);
return STATUS_OK;
}
NEOERR* blog_data_mod(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
mdb_conn *conn = (mdb_conn*)hash_lookup(dbh, "aux");
mevent_t *evt = (mevent_t*)hash_lookup(evth, "aic");
char *aname;
int bid;
NEOERR *err;
LPRE_DBOP(cgi->hdf, conn);
HDF_GET_INT(cgi->hdf, PRE_QUERY".bid", bid);
APP_CHECK_LOGIN();
if (hdf_get_int_value(evt->hdfrcv, "state", 0) < LCS_ST_ADMIN)
return nerr_raise(LERR_LIMIT, "%s wan't be admin", aname);
STRING str;
string_init(&str);
err = mcs_build_upcol(hdf_get_obj(cgi->hdf, PRE_QUERY),
hdf_get_obj(g_cfg, "Db.UpdateCol.blog"), &str);
if (err != STATUS_OK) return nerr_pass(err);
MDB_EXEC(conn, NULL, "UPDATE blog SET %s WHERE id=%d AND author=$1",
"s", str.buf, bid, aname);
string_clear(&str);
char command[1024];
snprintf(command, sizeof(command), PATH_PAGER"blg -b %d", bid);
mtc_dbg("%s", command);
system(command);
return STATUS_OK;
}
/**
* Get one line from specific stream with delimiter.
*/
bool_t string_getline_delimiter(string_t* pstr_string, FILE* fp_stream, char c_delimiter)
{
int n_char = EOF;
assert(pstr_string != NULL);
assert(fp_stream != NULL);
if(c_delimiter == '\n')
{
return string_getline(pstr_string, fp_stream);
}
else
{
clearerr(fp_stream);
string_clear(pstr_string);
while(!feof(fp_stream) && !ferror(fp_stream) && (char)n_char != c_delimiter &&
string_size(pstr_string) < string_max_size(pstr_string))
{
n_char = fgetc(fp_stream);
if((char)n_char != c_delimiter && n_char != EOF)
{
string_push_back(pstr_string, (char)n_char);
}
}
if((char)n_char == c_delimiter)
{
return true;
}
else
{
return false;
}
}
}
bool file_getLine(FILE *file, string_t *str)
{
string_clear(str);
bool v = file_readLine(file, str);
string_cstr(str);
return v;
}
bool file_getLine_delim(FILE *file, string_t *str, char delim)
{
string_clear(str);
bool v = file_readLine_delim(file, str, delim);
string_cstr(str);
return v;
}
NEOERR *hdf_write_string (HDF *hdf, char **s)
{
STRING str;
NEOERR *err;
*s = NULL;
string_init (&str);
err = hdf_dump_str (hdf, NULL, 1, &str);
if (err)
{
string_clear (&str);
return nerr_pass(err);
}
if (str.buf == NULL)
{
*s = strdup("");
if (*s == NULL) return nerr_raise(NERR_NOMEM, "Unable to allocate empty string");
}
else
{
*s = str.buf;
}
return STATUS_OK;
}
irom static app_action_t application_function_wlan_client_configure(const string_t *src, string_t *dst)
{
string_clear(&ssid);
string_clear(&passwd);
if((parse_string(1, src, &ssid) == parse_ok) && (parse_string(2, src, &passwd) == parse_ok))
{
strlcpy(config.client_wlan.ssid, string_to_const_ptr(&ssid), sizeof(config.client_wlan.ssid));
strlcpy(config.client_wlan.passwd, string_to_const_ptr(&passwd), sizeof(config.client_wlan.passwd));
}
string_format(dst, "wlan-client-configure: ssid: \"%s\", passwd: \"%s\"\n",
config.client_wlan.ssid, config.client_wlan.passwd);
return(app_action_normal);
}
void clear_map() // always called when not working
{
delete_all_nodes();
delete_all_conns();
delete_all_curves();
delete_all_points();
delete_all_fills();
delete_all_lines();
delete_all_tiles();
delete_all_objects();
map_saved = 1;
string_clear(map_filename);
string_clear(map_path);
char *cwd = get_current_dir_name();
string_cat_text(map_path, cwd);
free(cwd);
}
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);
}
NEOERR * hdf_read_string (HDF *hdf, const char *str)
{
NEOERR *err;
int lineno = 0;
STRING line;
string_init(&line);
err = _hdf_read_string(hdf, &str, &line, "<string>", &lineno, INCLUDE_ERROR);
string_clear(&line);
return nerr_pass(err);
}
irom static app_action_t flash_write_verify(const string_t *src, string_t *dst)
{
char *verify_buffer = string_to_ptr(dst);
char *write_buffer = string_to_ptr(&buffer_4k);
int write_buffer_length = string_length(&buffer_4k);
if(string_size(dst) < 0x1000)
{
string_format(dst, "OTA: string verify buffer too small: %d\n", string_size(dst));
return(app_action_error);
}
if(ota_state == state_write)
{
spi_flash_read(flash_sector * 0x1000, (void *)verify_buffer, write_buffer_length);
if(ets_memcmp(write_buffer, verify_buffer, write_buffer_length))
{
spi_flash_erase_sector(flash_sector);
spi_flash_write(flash_sector * 0x1000, (void *)write_buffer, write_buffer_length);
written++;
}
else
skipped++;
}
spi_flash_read(flash_sector * 0x1000, (void *)verify_buffer, write_buffer_length);
MD5Update(&md5, verify_buffer, write_buffer_length);
if(ets_memcmp(write_buffer, verify_buffer, write_buffer_length))
{
string_copy(dst, "OTA: verify mismatch\n");
return(app_action_error);
}
flash_sector++;
received += write_buffer_length;
string_clear(&buffer_4k);
string_clear(dst);
return(app_action_normal);
}
static void
openvpn_plugin_string_list_item_free (struct openvpn_plugin_string_list *l)
{
if (l)
{
free (l->name);
string_clear (l->value);
free (l->value);
free (l);
}
}
NEOERR * hdf_read_string_ignore (HDF *hdf, const char *str, int ignore)
{
NEOERR *err;
int lineno = 0;
STRING line;
string_init(&line);
err = _hdf_read_string(hdf, &str, &line, "<string>", &lineno,
(ignore ? INCLUDE_IGNORE : INCLUDE_ERROR));
string_clear(&line);
return nerr_pass(err);
}
extern char* file_read_line(xString *const line , FILE* fp)
{
char *result = NULL;
string_clear(line);
if ( NULL == fp )
error(FATAL, "NULL file pointer");
else{
boolean re_readline;
do {
char *const pLastChar = get_string_value(line) + get_string_size (line) -2;
fpos_t startOfLine;
fgetpos (fp, &startOfLine);
re_readline = FALSE;
*pLastChar = '\0';
result = fgets (get_string_value(line), (int) get_string_size(line), fp);
if (result == NULL)
{
if (! feof(fp))
error (FATAL | ERROR, "Failure on attempt to read file");
}
else if (*pLastChar != '\0' &&
*pLastChar != '\n' && *pLastChar != '\r')
{
/* buffer overflow */
re_readline = string_auto_resize(line);
if (re_readline)
fsetpos (fp, &startOfLine);
else
error (FATAL | ERROR, "input line too big; out of memory");
}
else
{
char* eol;
line->length = strlen (line->buffer);
/* canonicalize new line */
eol = get_string_value(line) + get_string_length(line) - 1;
if (*eol == '\r')
*eol = '\n';
else if (*(eol - 1) == '\r' && *eol == '\n')
{
*(eol - 1) = '\n';
*eol = '\0';
--line->length;
}
}
}while(re_readline);
}
return result;
}
static void
vpnconnect_plugin_string_list_item_free (struct vpnconnect_plugin_string_list *l)
{
if (l)
{
free (l->name);
string_clear (l->value);
free (l->value);
free (l);
}
}
