static int resource_open_default(struct sr_resource *res,
const char *name, void *cb_data)
{
int64_t filesize;
#ifdef FIRMWARE_DIR
const char *builtindir;
#endif
const char *subdir;
const char *const *datadirs;
FILE *file;
(void)cb_data;
switch (res->type) {
case SR_RESOURCE_FIRMWARE:
#ifdef FIRMWARE_DIR
builtindir = FIRMWARE_DIR;
#endif
subdir = "sigrok-firmware";
break;
default:
sr_err("%s: unknown type %d.", __func__, res->type);
return SR_ERR_ARG;
}
file = try_open_file(g_get_user_data_dir(), subdir, name);
/*
* Scan the hard-coded directory before the system directories to
* avoid picking up possibly outdated files from a system install.
*/
#ifdef FIRMWARE_DIR
if (!file)
file = try_open_file(builtindir, "", name);
#endif
if (!file) {
datadirs = g_get_system_data_dirs();
while (*datadirs && !file)
file = try_open_file(*datadirs++, subdir, name);
}
if (!file) {
sr_dbg("Failed to locate '%s'.", name);
return SR_ERR;
}
filesize = sr_file_get_size(file);
if (filesize < 0) {
sr_err("Failed to obtain size of '%s': %s",
name, g_strerror(errno));
fclose(file);
return SR_ERR;
}
res->size = filesize;
res->handle = file;
return SR_OK;
}
int dict_group_load(DictGroup* dict_group,
const char* filename,
opencc_dictionary_type type) {
Dict* dictionary;
char* path = try_open_file(filename);
if (path == NULL) {
path = try_find_dictionary_with_config(dict_group, filename);
if (path == NULL) {
errnum = DICTIONARY_ERROR_CANNOT_ACCESS_DICTFILE;
return -1;
}
}
dictionary = dict_new(path, type);
free(path);
if (dictionary == (Dict*)-1) {
errnum = DICTIONARY_ERROR_INVALID_DICT;
return -1;
}
dict_group->dicts[dict_group->count++] = dictionary;
return 0;
}
int static_file_handle(request_t *req, response_t *resp,
handler_ctx_t *ctx) {
mod_static_conf_t *conf;
char path[2048];
int fd = -1, res, use_301;
struct stat st;
size_t len, pathlen, filesize, fileoffset;
ctx_state_t val;
conf = (mod_static_conf_t*) ctx->conf;
len = strlen(conf->root);
strncpy(path, conf->root, 2048);
if (path[len - 1] == '/') {
path[len - 1] = '\0';
}
if (req->path[0] != '/') {
return response_send_status(resp, STATUS_BAD_REQUEST);
}
strncat(path, req->path, 2048 - len);
debug("Request path: %s, real file path: %s", req->path, path);
res = try_open_file(path, &fd, &st);
if (res < 0) {
return static_file_handle_error(resp, fd);
} else if (res > 0) { // Is a directory, try index files.
pathlen = strlen(path);
use_301 = 0;
if (path[pathlen - 1] != '/') {
path[pathlen] = '/';
path[pathlen + 1] = '\0';
pathlen++;
use_301 = 1;
}
//for (i = 0; i < 10 && res != 0 && conf->index[i] != NULL; i++) {
// path[pathlen] = '\0';
// strncat(path, conf->index[i], 2048 - pathlen);
// res = try_open_file(path, &fd, &st);
//}
path[pathlen] = '\0';
strncat(path, conf->index, 2048 - pathlen);
res = try_open_file(path, &fd, &st);
path[pathlen] = '\0';
if (res != 0) {
if (conf->enable_list_dir) {
if (use_301) {
// TODO Support HTTPS
snprintf(path, 2048, "http://%s%s/", req->host, req->path);
response_set_header(resp, "Location", path);
resp->status = STATUS_MOVED;
resp->content_length = 0;
response_send_headers(resp, NULL);
return HANDLER_DONE;
}
show_hidden_file = conf->show_hidden_file;
return static_file_listdir(resp, req->path, path);
} else {
return static_file_handle_error(resp, fd);
}
}
}
fileoffset = 0;
filesize = st.st_size;
res = handle_range(req, resp, &fileoffset, &filesize);
if (res < 0) {
resp->status = STATUS_OK;
} else if (res == 0) {
resp->status = STATUS_PARTIAL_CONTENT;
} else {
return response_send_status(resp, STATUS_RANGE_NOT_SATISFIABLE);
}
resp->content_length = filesize;
handle_content_type(resp, path);
if (handle_cache(req, resp, &st, conf)) {
return response_send_status(resp, STATUS_NOT_MODIFIED);
}
val.as_int = fd;
context_push(ctx, val);
val.as_long = fileoffset;
context_push(ctx, val);
val.as_long = filesize;
context_push(ctx, val);
debug("sending headers");
response_send_headers(resp, static_file_write_content);
return HANDLER_UNFISHED;
}
void Task_SmartPHTApp(void)
{
message_t msg;
adc_voltages_t *v;
sensor_data_t *c;
byte_t comRecvByte;
if (knl_mailbox_pend(&taskMailbox, &msg) == RV_OK) {
switch (msg.MsgId) {
case MSG_ID_SYS_VOLTAGE_UPDATE:
v = (adc_voltages_t*) msg.Param0;
//tiny_printf("SYS: Vbat=%dmV, Vcc=%dmV, Vdd=%dmV, Vtft=%dmV\n", v->vbat, v->vcc, v->vdd, v->vtft);
// if(v->vdd < 3000)
// tty_output("SYS: system voltage is low!\n");
// if(v->vbat < 3300)
// tty_output("SYS: BATTERY LOW! replace or battery can be damaged\n");
break;
case MSG_ID_SYS_BATTERY_STAT:
// if(msg.Param0 == BAT_CHARGE_COMPLETE)
// tty_output("SYS: battery charge complete.\n");
// if(msg.Param0 == BAT_CHARGING)
// tty_output("SYS: charging...\n");
// if(msg.Param0 == BAT_SHUTDOWN)
// tty_output("SYS: charger shtdn.\n");
// break;
break;
case MSG_ID_USB_STATE_CHANGED:
handle_usb_change(msg.Param0);
break;
case MSG_ID_SENSOR_UPDATE:
c = (sensor_data_t*) msg.Param0;
filter(&dashboardData.pressure, c->compensated.hp_pressure);
filter(&dashboardData.humidity, c->compensated.sht_humidity);
filter(&dashboardData.temperature, c->compensated.sht_temperature);
update_min_max(&dashboardData.pressure);
update_min_max(&dashboardData.humidity);
update_min_max(&dashboardData.temperature);
check_alarms();
// update waveforms
wfrm_put_sample(&wfrmPressure, dashboardData.pressure.val);
wfrm_put_sample(&wfrmHumidity, dashboardData.humidity.val);
wfrm_put_sample(&wfrmTemperature, dashboardData.temperature.val);
// Write to file
write_samples_to_file(c, (rtc_time_t*) msg.Param1);
gui_invalidate(&dashb);
gui_invalidate(&lineplot);
break;
case MSG_ID_MEDIA_DETECTED:
//tty_output("SDCARD: inserted.");
//if(msg.Param0) tty_output(" Card is write protected!");
//tty_output("\n");
sd_register();
f_close(&samplesFile);
// Mount filesystem
f_mount(0, &filesystem);
// Try open file;
sampleFileIsOpen = try_open_file();
// Change statusbar
toolbar_set_status(&statusbar, STATUS_SDCARD_PRESENT);
break;
case MSG_ID_MEDIA_DISAPPEARED:
//tty_output("SDCARD: removed\n");
// Dismount file system
f_mount(0, NULL);
// Change statusbar
toolbar_clear_status(&statusbar, STATUS_SDCARD_PRESENT);
break;
case MSG_ID_WDG_PRESSED:
handle_button_press_event(msg.Param0);
break;
case MSG_ID_WDG_DELAYED_OP:
handle_delayed_operation_event(msg.Param0);
break;
case MSG_ID_WDG_CHECKED:
handle_button_checked_event(msg.Param0);
break;
case MSG_ID_WDG_INVALIDATE: // GUI needs to be redrawn
gui_draw();
break;
case MSG_ID_LPM_REQUEST:
enter_sleep_mode();
break;
case MSG_ID_TOUCH_EVENT:
// // Draw cursor
// if(msg.Param0 == TOUCH_EVENT_PANEL_PRESSED)
// {
// uint16_t i, j;
// i = msg.Param1;
// j = msg.Param2;
//
// if(i < 12) i = 12;
// else if(i > 467) i = 467;
// if(j < 12) j = 12;
// else if(j > 260) j = 260;
//
// gfx_set_color(COLOR_WHITE);
// gfx_draw_circle(i, j , 10);
// }
if(!darkenScreen)
{
set_brightness(lightenBrightness);
}
darkenScreen = bTrue;
// no break, gui must get this msg too
default:
gui_msg(&msg);
break;
}
}
// COMMAND PARSER
if(usb_device_state == CONFIGURED_STATE)
if (poll_getc_cdc(&comRecvByte)) {
putc_cdc(comRecvByte); // echo
CDC_Flush_In_Now();
cmd_parse_char(comRecvByte);
}
}
