/*---------------------------------------------------------------------------*/
static
PT_THREAD(handle_output(struct httpd_state *s))
{
PT_BEGIN(&s->outputpt);
petsciiconv_topetscii(s->filename, sizeof(s->filename));
s->fd = cfs_open(s->filename, CFS_READ);
petsciiconv_toascii(s->filename, sizeof(s->filename));
if(s->fd < 0) {
strcpy(s->filename, "notfound.html");
s->fd = cfs_open(s->filename, CFS_READ);
petsciiconv_toascii(s->filename, sizeof(s->filename));
if(s->fd < 0) {
PT_WAIT_THREAD(&s->outputpt,
send_headers(s, http_header_404));
PT_WAIT_THREAD(&s->outputpt,
send_string(s, "not found"));
uip_close();
webserver_log_file(&uip_conn->ripaddr, "404 (no notfound.html)");
PT_EXIT(&s->outputpt);
}
PT_WAIT_THREAD(&s->outputpt,
send_headers(s, http_header_404));
webserver_log_file(&uip_conn->ripaddr, "404 - notfound.html");
} else {
PT_WAIT_THREAD(&s->outputpt,
send_headers(s, http_header_200));
}
PT_WAIT_THREAD(&s->outputpt, send_file(s));
cfs_close(s->fd);
s->fd = -1;
PSOCK_CLOSE(&s->sout);
PT_END(&s->outputpt);
}
/*---------------------------------------------------------------------------*/
static void
write_chunk(struct rudolph2_conn *c, int offset, int flag,
uint8_t *data, int datalen)
{
int fd;
#if CONTIKI_TARGET_NETSIM
{
char buf[100];
sprintf(buf, "%d%%", (100 * (offset + datalen)) / FILESIZE);
ether_set_text(buf);
}
#endif /* CONTIKI_TARGET_NETSIM */
if(flag == RUDOLPH2_FLAG_NEWFILE) {
printf("+++ rudolph2 new file incoming at %lu\n", clock_time());
leds_on(LEDS_RED);
fd = cfs_open("codeprop.out", CFS_WRITE);
} else {
fd = cfs_open("codeprop.out", CFS_WRITE + CFS_APPEND);
}
if(datalen > 0) {
int ret;
cfs_seek(fd, offset, CFS_SEEK_SET);
ret = cfs_write(fd, data, datalen);
printf("+++ rudolph2 offset %d, length %d\n", offset, datalen);
}
cfs_close(fd);
if(flag == RUDOLPH2_FLAG_LASTCHUNK) {
int i;
printf("+++ rudolph2 entire file received at %d, %d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1]);
leds_off(LEDS_RED);
leds_on(LEDS_YELLOW);
fd = cfs_open("hej", CFS_READ);
for(i = 0; i < FILESIZE; ++i) {
unsigned char buf;
int r = cfs_read(fd, &buf, 1);
if (r != 1) {
printf("%d.%d: error: read failed at %d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
i);
break;
}
else if(buf != (unsigned char)i) {
printf("%d.%d: error: diff at %d, %d != %d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
i, (unsigned char)i, buf);
break;
}
}
#if CONTIKI_TARGET_NETSIM
ether_send_done();
#endif
cfs_close(fd);
}
}
PROCESS_THREAD(cfs_write_test, ev, data) {
PROCESS_BEGIN();
char str[20], str2[20];
strcpy(str, "Vot bl'a nahuj!");
int fd = cfs_open("a", CFS_WRITE);
if (fd == -1) {
cfs_close(fd);
fd = cfs_open("a", CFS_WRITE);
if (fd == -1) {
alarma(5);
}
}
cfs_write(fd, (void *)str, strlen(str));
cfs_close(fd);
fd = cfs_open("a", CFS_READ);
cfs_read(fd, (void *)str2, strlen(str));
cfs_close(fd);
strcat(str2, " Da yopt!");
fd = cfs_open("a", CFS_WRITE);
cfs_write(fd, (void *)str2, strlen(str2));
cfs_close(fd);
ledd_on(PB5);
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
static
PT_THREAD(handle_output(struct httpd_state *s))
{
PT_BEGIN(&s->outputpt);
s->fd = cfs_open(s->filename, CFS_READ);
if(s->fd < 0) {
s->fd = cfs_open("404.html", CFS_READ);
if(s->fd < 0) {
uip_abort();
PT_EXIT(&s->outputpt);
}
PT_WAIT_THREAD(&s->outputpt,
send_headers(s, "HTTP/1.0 404 Not found\r\n"));
PT_WAIT_THREAD(&s->outputpt,
send_file(s));
} else {
PT_WAIT_THREAD(&s->outputpt,
send_headers(s, "HTTP/1.0 200 OK\r\n"));
PT_WAIT_THREAD(&s->outputpt,
send_file(s));
cfs_close(s->fd);
}
PSOCK_CLOSE(&s->sout);
PT_END(&s->outputpt);
}
/*-----------------------------------------------------------------------------------*/
static void
apply_tcpipconfig(void)
{
int file = cfs_open("contiki.cfg", CFS_READ);
int size = cfs_read(file, uip_buf, 100);
cfs_close(file);
nullterminate(ipaddr);
uiplib_ipaddrconv(ipaddr, (uip_ipaddr_t *)&uip_buf[0]);
nullterminate(netmask);
uiplib_ipaddrconv(netmask, (uip_ipaddr_t *)&uip_buf[4]);
nullterminate(gateway);
uiplib_ipaddrconv(gateway, (uip_ipaddr_t *)&uip_buf[8]);
#if WITH_DNS
nullterminate(dnsserver);
uiplib_ipaddrconv(dnsserver, (uip_ipaddr_t *)&uip_buf[12]);
#endif /* WITH_DNS */
file = cfs_open("contiki.cfg", CFS_WRITE);
cfs_write(file, uip_buf, size);
cfs_close(file);
}
static int
sendDelugeGroup(void* inst, ContainerRoot* model)
{
// so, we receive a new model to distribute
DelugeGroup* instance = (DelugeGroup*) inst;
PRINTF("Sending with DELUGE %p %p\n", instance->lastReceivedModel, model);
/* we don't want to resend the model as if we were the creators if we just received */
if (instance->lastReceivedModel == model){
return 0;
}
PRINTF("Sending the model through deluge\n");
// TODO serialize model to a file
// TODO calculate number of pages in the file
int fd = cfs_open(instance->fileNameWithModel, CFS_READ);
cfs_offset_t offset = cfs_seek(fd, 0, CFS_SEEK_END);
uint16_t nPages = offset / S_PAGE;
cfs_close(fd);
if (offset % S_PAGE != 0) {
uint16_t mod = offset % S_PAGE;
PRINTF("INFO: +++++++++++++++++++++++++ %d\n", mod);
mod = S_PAGE - mod;
char* buf = (char*)malloc(mod);
memset(buf, ' ', mod);
fd = cfs_open(instance->fileNameWithModel, CFS_WRITE | CFS_APPEND);
cfs_seek(fd, 0, CFS_SEEK_END);
cfs_write(fd, buf, mod);
cfs_close(fd);
free(buf);
nPages++;
}
// set my local announcement to the new version
instance->info.version = instance->info.version + 1;
instance->info.nr_pages = nPages;
// FIXME distribute announcement to other motes
#if 0
announcement_bump(&instance->a);
#endif
// activate deluge
if (deluge_disseminate(instance->fileNameWithModel, 1, NULL)) {
PRINTF("ERROR: some problem dissemineting\n");
}
else {
PRINTF("INFO: dissemineting new version of the file with version %d\n", newVersion);
}
return 0;
}
/*---------------------------------------------------------------------------*/
static int
coffee_test_append(void)
{
int error;
int afd;
unsigned char buf[256], buf2[11];
int r, i, j, total_read;
#define APPEND_BYTES 1000
#define BULK_SIZE 10
cfs_remove("T2");
/* Test 1 and 2: Append data to the same file many times. */
for(i = 0; i < APPEND_BYTES; i += BULK_SIZE) {
afd = cfs_open("T3", CFS_WRITE | CFS_APPEND);
if(afd < 0) {
FAIL(1);
}
for(j = 0; j < BULK_SIZE; j++) {
buf[j] = 1 + ((i + j) & 0x7f);
}
if((r = cfs_write(afd, buf, BULK_SIZE)) != BULK_SIZE) {
printf("r=%d\n", r);
FAIL(2);
}
cfs_close(afd);
}
/* Test 3-6: Read back the data written previously and verify that it
is correct. */
afd = cfs_open("T3", CFS_READ);
if(afd < 0) {
FAIL(3);
}
total_read = 0;
while((r = cfs_read(afd, buf2, sizeof(buf2))) > 0) {
for(j = 0; j < r; j++) {
if(buf2[j] != 1 + ((total_read + j) & 0x7f)) {
FAIL(4);
}
}
total_read += r;
}
if(r < 0) {
FAIL(5);
}
if(total_read != APPEND_BYTES) {
FAIL(6);
}
cfs_close(afd);
error = 0;
end:
cfs_close(afd);
return error;
}
/*-----------------------------------------------------------------------------------*/
static void
savescript(void)
{
char line[40];
/* struct c64_fs_file f;*/
int f;
f = cfs_open("@:config.cfg", CFS_WRITE);
if(f == -1) {
log_message("Could not open config.cfg", "");
return;
}
if(cfs[0] != 0) {
int len = makeline(line, 'c',cfs);
cfs_write(f, line, len);
// cfs_write(f, line, makeline(line, 'c', cfs));
}
if(theme[0] != 0) {
int len = makeline(line, 't',theme);
cfs_write(f, line, len);
// cfs_write(f, line, makeline(line, 't', theme));
}
if(driver[0] != 0) {
int len = makeline(line, 'n',driver);
cfs_write(f, line, len);
// cfs_write(f, line, makeline(line, 'n', driver));
}
if(ipaddr[0] != 0) {
int len = makeline(line, 'i',ipaddr);
cfs_write(f, line, len);
// cfs_write(f, line, makeline(line, 'i', ipaddr));
}
if(netmask[0] != 0) {
int len = makeline(line, 'm',netmask);
cfs_write(f, line, len);
// cfs_write(f, line, makeline(line, 'm', netmask));
}
if(gateway[0] != 0) {
int len = makeline(line, 'r',gateway);
cfs_write(f, line, len);
// cfs_write(f, line, makeline(line, 'r', gateway));
}
if(dnsserver[0] != 0) {
int len = makeline(line, 'd',dnsserver);
cfs_write(f, line, len);
// cfs_write(f, line, makeline(line, 'd', dnsserver));
}
if(screensaver[0] != 0) {
int len = makeline(line, 's',screensaver);
cfs_write(f, line, len);
// cfs_write(f, line, makeline(line, 's', screensaver));
}
strcpy(line, ".\n\0\n\n\n");
cfs_write(f, line, strlen(line));
cfs_close(f);
}
static void
initscript(void)
{
char line[40], *lineptr;
/* struct c64_fs_file f;*/
int f;
if((f = cfs_open("config.cfg", 0)) == -1) {
return;
}
line[0] = ' ';
while(line[0] != '.' &&
line[0] != 0) {
lineptr = line;
do {
if(cfs_read(f, lineptr, 1) != 1) {
cfs_close(f);
return;
}
++lineptr;
} while(*(lineptr - 1) != '\n' &&
*(lineptr - 1) != '\r');
*lineptr = 0;
if(line[0] != '.' &&
line[0] != 0) {
parse(line, initparsetab);
}
}
cfs_close(f);
return;
}
void TestScriptEngine(CuTest *tc)
{
// COPY A SCRIPT FILE FOR SCRIPT TESTING
FILE* fp = fopen("script1.amx", "rb");
int fd = cfs_open("/script1.amx", CFS_WRITE);
if (fp != NULL && fd != -1)
{
// copy the file
char buf[1024];
int length;
length = fread(buf, 1, 1024, fp);
while(length > 0)
{
cfs_write(fd, buf, length);
length = fread(buf, 1, 1024, fp);
}
fclose(fp);
cfs_close(fd);
}
test_window(&script_process, "/script1.amx");
test_window(&script_process, "/notexist.amx");
}
/*---------------------------------------------------------------------------*/
static void request_recv(struct runicast_conn *c, const rimeaddr_t *from, uint8_t seqno)
{
const char *filename;
uint8_t seq;
if(packetbuf_datalen() < 2) {
printf("download: bad filename request (null)\n");
return;
}
seq = ((uint8_t *)packetbuf_dataptr())[0];
if(seq == req_last_seq) {
printf("download: ignoring duplicate request\n");
return;
}
req_last_seq = seq;
filename = ((char *)packetbuf_dataptr()) + 1;
printf("file requested: '%s'\n", filename);
/* Initiate file transfer */
leds_on(LEDS_GREEN);
if(fd >= 0) {
cfs_close(fd);
}
fd = cfs_open(filename, CFS_READ);
if(fd < 0) {
printf("download: bad filename request (no read access): %s\n", filename);
}
rucb_close(&rucb);
rucb_open(&rucb, RUCB_CHANNEL, &rucb_call);
rucb_send(&rucb, from);
}
db_result_t
storage_get_index(index_t *index, relation_t *rel, attribute_t *attr)
{
char filename[INDEX_NAME_LENGTH];
int fd;
int r;
struct index_record record;
db_result_t result;
merge_strings(filename, rel->name, INDEX_NAME_SUFFIX);
fd = cfs_open(filename, CFS_READ);
if(fd < 0) {
return DB_STORAGE_ERROR;
}
for(result = DB_STORAGE_ERROR;;) {
r = cfs_read(fd, &record, sizeof(record));
if(r < sizeof(record)) {
break;
}
if(strcmp(attr->name, record.attribute_name) == 0) {
PRINTF("DB: Found the index record for %s.%s: type %d, filename %s\n",
rel->name, attr->name, record.type, record.file_name);
index->type = record.type;
memcpy(index->descriptor_file, record.file_name,
sizeof(index->descriptor_file));
result = DB_OK;
}
}
cfs_close(fd);
return result;
}
int transfer_file(char* filename)
{
int fd_read = cfs_open(filename, CFS_READ);
if (fd_read == -1)
{
log_error("cfs_open(%s) failed\n", filename);
return -1;
}
cfs_offset_t pos = -1;
if ((pos = cfs_seek(fd_read, 0, CFS_SEEK_END)) == -1)
{
log_error("cfs_seek(%s) to file end failed", filename);
cfs_close(fd_read);
return -1;
}
if ((pos = cfs_seek(fd_read, 0, CFS_SEEK_SET)) == -1)
{
log_error("cfs_seek(%s) to file begin failed", filename);
cfs_close(fd_read);
return -1;
}
init_file_reader(&_f_reader);
strcpy(_f_reader.file_name, filename);
_f_reader.send_fd = begin_send_file(filename);
_f_reader.read_fd = fd_read;
_f_reader.file_size = (uint16_t)pos;
send_file_block(_f_reader.send_fd);
return 0;
}
/*---------------------------------------------------------------------------*/
static void
copy_file_from_romfs_to_cfs(const char * from, const char * to)
{
static char buf[128];
cfs_offset_t filesize, read, pos;
/* Format CFS */
cfs_coffee_format();
/* Open file for writing in CFS */
int cfs_fd = cfs_open(to, CFS_WRITE);
/* Open file for reading in ROMFS */
int rom_fd = romfs_open(from, CFS_READ);
/* Determine file size */
filesize = romfs_seek(rom_fd, 0, CFS_SEEK_END) - 1;
/* Restore offset to start of file */
romfs_seek(rom_fd, 0, CFS_SEEK_SET);
/* Copy file data from romfs to cfs in chunks of 128 bytes */
for (pos = 0; pos < filesize; pos += read) {
read = romfs_read(rom_fd, buf, sizeof(buf));
cfs_write(cfs_fd, buf, read);
}
/* Close both files */
cfs_close(cfs_fd);
romfs_close(rom_fd);
}
/*---------------------------------------------------------------------------*/
static void
serial_interrupt_rollback()
{
int fd = 0;
PAUSE_TIME();
if(SPI_IS_ENABLED()) {
/* SPI is busy, abort */
PRINTF_COMMAND("RB:SPIBUSY\n");
RESUME_TIME();
return;
}
/* Open file */
fd = cfs_open("cp", CFS_READ);
if(fd < 0) {
printf("ERROR: No file access (rb)\n");
RESUME_TIME();
return;
}
/* Rollback */
preset_cmd = COMMAND_ROLLBACK;
preset_fd = fd;
mt_exec(&checkpoint_thread);
/* Close file */
cfs_close(fd);
RESUME_TIME();
}
static int
init_object(struct deluge_object *obj, char *filename, unsigned version)
{
static struct deluge_page *page;
int i;
obj->cfs_fd = cfs_open(filename, CFS_READ | CFS_WRITE);
if(obj->cfs_fd < 0) {
return -1;
}
obj->filename = filename;
obj->object_id = next_object_id++;
obj->size = file_size(filename);
obj->version = obj->update_version = version;
obj->current_rx_page = 0;
obj->nrequests = 0;
obj->tx_set = 0;
obj->pages = malloc(OBJECT_PAGE_COUNT(*obj) * sizeof(*obj->pages));
if(obj->pages == NULL) {
cfs_close(obj->cfs_fd);
return -1;
}
for(i = 0; i < OBJECT_PAGE_COUNT(current_object); i++) {
page = ¤t_object.pages[i];
init_page(¤t_object, i, 1);
}
memset(obj->current_page, 0, sizeof(obj->current_page));
return 0;
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(shell_append_process, ev, data)
{
static int fd = 0;
struct shell_input *input;
PROCESS_EXITHANDLER(cfs_close(fd));
PROCESS_BEGIN();
fd = cfs_open(data, CFS_WRITE | CFS_APPEND);
if(fd < 0) {
shell_output_str(&append_command,
"append: could not open file for writing: ", data);
} else {
while(1) {
PROCESS_WAIT_EVENT_UNTIL(ev == shell_event_input);
input = data;
/* printf("cat input %d %d\n", input->len1, input->len2);*/
if(input->len1 + input->len2 == 0) {
cfs_close(fd);
PROCESS_EXIT();
}
cfs_write(fd, input->data1, input->len1);
cfs_write(fd, input->data2, input->len2);
shell_output(&append_command,
input->data1, input->len1,
input->data2, input->len2);
}
}
PROCESS_END();
}
db_result_t
storage_put_attribute(relation_t *rel, attribute_t *attr)
{
int fd;
struct attribute_record record;
int r;
PRINTF("DB: put_attribute(%s, %s)\n", rel->name, attr->name);
fd = cfs_open(rel->name, CFS_WRITE | CFS_APPEND);
if(fd < 0) {
return DB_STORAGE_ERROR;
}
memset(&record.name, 0, sizeof(record.name));
memcpy(record.name, attr->name, sizeof(record.name));
record.domain = attr->domain;
record.element_size = attr->element_size;
r = cfs_write(fd, &record, sizeof(record));
if(r != sizeof(record)) {
cfs_close(fd);
cfs_remove(rel->name);
return DB_STORAGE_ERROR;
}
cfs_close(fd);
return DB_OK;
}
static void
serial_interrupt_checkpoint()
{
int fd = 0;
PAUSE_TIME();
if(SPI_IS_ENABLED()) {
/* SPI is busy, abort */
PRINTF_COMMAND("CP:SPIBUSY\n");
RESUME_TIME();
return;
}
/* Open file */
cfs_remove("cp");
cfs_coffee_reserve("cp", checkpoint_arch_size());
fd = cfs_open("cp", CFS_WRITE);
if(fd < 0) {
printf("ERROR: No file access (cp)\n");
RESUME_TIME();
return;
}
/* Checkpoint */
preset_cmd = COMMAND_CHECKPOINT;
preset_fd = fd;
mt_exec(&checkpoint_thread);
/* Close file */
cfs_close(fd);
RESUME_TIME();
}
/*-----------------------------------------------------------------------------------*/
unsigned char
load(const char *name)
{
unsigned char res;
/* Now open the file */
ctrl.callerdata = cfs_open(name, 0);
if(ctrl.callerdata < 0) {
/* Could not open the file, display an error and return */
/* ### */
return LOADER_ERR_OPEN;
}
/* Load the module */
res = mod_load(&ctrl);
/* Close the input file */
cfs_close(ctrl.callerdata);
/* Check the return code */
if(res != MLOAD_OK) {
/* Wrong module, out of memory or whatever. Print an error
* message and return.
*/
/* ### */
return res;
}
/* We've successfully loaded the module. */
return LOADER_OK;
}
void manage_acq_setup()
{
for (u8 prn=0; prn<32; prn++) {
acq_prn_param[prn].state = ACQ_PRN_UNTRIED;
acq_prn_param[prn].score = 0;
}
int fd = cfs_open("almanac", CFS_READ);
if (fd != -1) {
cfs_read(fd, almanac, 32*sizeof(almanac_t));
log_info("Loaded almanac from flash\n");
cfs_close(fd);
} else {
log_info("No almanac file present in flash, create an empty one\n");
cfs_coffee_reserve("almanac", 32*sizeof(almanac_t));
cfs_coffee_configure_log("almanac", 256, sizeof(almanac_t));
for (u8 prn=0; prn<32; prn++) {
almanac[prn].valid = 0;
}
}
sbp_register_cbk(
MSG_ALMANAC,
&almanac_callback,
&almanac_callback_node
);
chThdCreateStatic(
wa_manage_acq_thread,
sizeof(wa_manage_acq_thread),
MANAGE_ACQ_THREAD_PRIORITY,
manage_acq_thread, NULL
);
}
/*---------------------------------------------------------------------*/
static int
start_program(void)
{
/* Link, load, and start new program. */
int ret;
s.fd = cfs_open("codeprop.out", CFS_READ);
ret = elfloader_load(s.fd);
/* XXX: Interrupts seems to be turned off a little too long during the
ELF loading process, so we need to "manually" trigger a timer
interrupt here. */
TACCR1 = TAR + 1000;
if(ret == ELFLOADER_OK) {
sprintf(msg, "ok\n");
PRINTF("Ok, starting new program.\n");
/* Start processes. */
autostart_start(elfloader_autostart_processes);
} else {
sprintf(msg, "err %d %s", ret, elfloader_unknown);
PRINTF("Error: '%s'.\n", msg);
}
cfs_close(s.fd);
return ret;
}
db_result_t
storage_put_index(index_t *index)
{
char filename[INDEX_NAME_LENGTH];
int fd;
int r;
struct index_record record;
db_result_t result;
merge_strings(filename, index->rel->name, INDEX_NAME_SUFFIX);
fd = cfs_open(filename, CFS_WRITE | CFS_APPEND);
if(fd < 0) {
return DB_STORAGE_ERROR;
}
strcpy(record.attribute_name, index->attr->name);
memcpy(record.file_name, index->descriptor_file, sizeof(record.file_name));
record.type = index->type;
result = DB_OK;
r = cfs_write(fd, &record, sizeof(record));
if(r < sizeof(record)) {
result = DB_STORAGE_ERROR;
} else {
PRINTF("DB: Wrote an index record for %s.%s, type %d\n",
index->rel->name, index->attr->name, record.type);
}
cfs_close(fd);
return result;
}
/** File read callback.
* Responds to a SBP_MSG_FILEIO_READ_REQUEST message.
*
* Reads a certain length (up to 255 bytes) from a given offset. Returns the
* data in a SBP_MSG_FILEIO_READ_RESPONSE message where the message length field
* indicates how many bytes were succesfully read.
*/
static void read_cb(u16 sender_id, u8 len, u8 msg[], void* context)
{
(void)context;
if (sender_id != SBP_SENDER_ID) {
log_error("Invalid sender!\n");
return;
}
if ((len < 9) || (msg[len-1] != '\0')) {
log_error("Invalid fileio read message!\n");
return;
}
u32 offset = ((u32)msg[3] << 24) | ((u32)msg[2] << 16) | (msg[1] << 8) | msg[0];
u8 readlen = MIN(msg[4], SBP_FRAMING_MAX_PAYLOAD_SIZE - len);
u8 buf[256];
memcpy(buf, msg, len);
int f = cfs_open((char*)&msg[5], CFS_READ);
cfs_seek(f, offset, CFS_SEEK_SET);
len += cfs_read(f, buf + len, readlen);
cfs_close(f);
sbp_send_msg(SBP_MSG_FILEIO_READ_RESPONSE, len, buf);
}
void
urlconv_init(void)
{
int fd = cfs_open("wwwroot.cfg", CFS_READ);
int rd = cfs_read(fd, wwwroot, sizeof(wwwroot));
cfs_close(fd);
if(rd != -1) wwwrootlen = rd;
}
char* getFromConfig(char* value){
int fd;
fd = cfs_open("/config.xml",CFS_READ);
memset(answer,0,100);
int i = 0,j=0,k=0;
uint8_t check = 1;
if (fd!=-1){
char config[128];
int read;
read = cfs_read(fd, config, 128);
cfs_close(fd);
while (config[i]!='\0'){
if (config[i]=='<'){
i++;
for (j=0;j<strlen(value);j++){
if (config[i]!=value[j]){
check = 0;
break;
}
i++;
}
if (check && config[i]=='>'){
i++;
j=0;
while (config[i]!='<' && j<100){
answer[j++]=config[i++];
} break;
}
}
if (config[i]=='>'){
//if (config[i+1]=='\0') break;
k+=i;
cfs_open("/config.xml",CFS_READ);
cfs_seek(fd,++k,CFS_SEEK_SET);
memset(config,0,128);
cfs_read(fd,config,128);
cfs_close(fd);
check = 1;
i=-1;
}
i++;
}
return answer;
} else return "-";
}
db_result_t
storage_get_relation(relation_t *rel, char *name)
{
int fd;
int r;
int i;
struct attribute_record record;
db_result_t result;
fd = cfs_open(name, CFS_READ);
if(fd < 0) {
return DB_STORAGE_ERROR;
}
r = cfs_read(fd, rel->name, sizeof(rel->name));
if(r != sizeof(rel->name)) {
cfs_close(fd);
PRINTF("DB: Failed to read name, got %d of %d bytes\n",
r, sizeof(rel->name));
return DB_STORAGE_ERROR;
}
r = cfs_read(fd, rel->tuple_filename, sizeof(rel->tuple_filename));
if(r != sizeof(rel->name)) {
cfs_close(fd);
PRINTF("DB: Failed to read tuple filename\n");
return DB_STORAGE_ERROR;
}
rel->tuple_filename[sizeof(rel->tuple_filename) - 1] ^= ROW_XOR;
/* Read attribute records. */
result = DB_OK;
for(i = 0;; i++) {
r = cfs_read(fd, &record, sizeof(record));
if(r == 0) {
break;
}
if(r != sizeof(record)) {
PRINTF("DB: Failed to read attribute record %d (r = %d)\n", i, r);
result = DB_STORAGE_ERROR;
break;
}
if(relation_attribute_add(rel, DB_MEMORY, record.name,
record.domain, record.element_size) == NULL) {
PRINTF("DB: Failed to add the attribute %s\n", record.name);
result = DB_STORAGE_ERROR;
break;
}
}
PRINTF("DB: Read %d attributes\n", i);
cfs_close(fd);
return result;
}
/*-----------------------------------------------------------------------------------*/
PROCESS_THREAD(wget_process, ev, data)
{
static char name[32];
static unsigned char i;
PROCESS_BEGIN();
/* Allow other processes to initialize properly. */
for(i = 0; i < 10; ++i) {
PROCESS_PAUSE();
}
fputs("Get url:", stdout);
if(contiki_argc > 1) {
strcpy(url, contiki_argv[1]);
puts(url);
} else {
gets(url);
}
fputs("Save as:", stdout);
if(contiki_argc > 2) {
strcpy(name, contiki_argv[2]);
puts(name);
} else {
gets(name);
}
file = cfs_open(name, CFS_WRITE);
if(file == -1) {
printf("Open error with '%s'\n", name);
app_quit();
} else {
petsciiconv_toascii(url, sizeof(url));
start_get();
}
while(1) {
PROCESS_WAIT_EVENT();
if(ev == tcpip_event) {
webclient_appcall(data);
#if UIP_UDP
} else if(ev == resolv_event_found) {
/* Either found a hostname, or not. */
if((char *)data != NULL &&
resolv_lookup((char *)data, NULL) == RESOLV_STATUS_CACHED) {
start_get();
} else {
puts("Host not found");
app_quit();
}
#endif /* UIP_UDP */
}
}
PROCESS_END();
}
void runReceivedProgram() {
printf("runReceivedProgram\n");
printf("originator: %u\n", filenameOriginatorRecv.originator);
printf("filename: %s\n", filename_download);
fd = cfs_open(filename_download, CFS_READ | CFS_WRITE);
if(fd < 0) {
printf("exec: could not open %s\n", filename_download);
}
else {
int ret;
char *print, *symbol;
ret = elfloader_load(fd);
cfs_close(fd);
symbol = "";
switch(ret) {
case ELFLOADER_OK:
print = "OK";
break;
case ELFLOADER_BAD_ELF_HEADER:
print = "Bad ELF header";
break;
case ELFLOADER_NO_SYMTAB:
print = "No symbol table";
break;
case ELFLOADER_NO_STRTAB:
print = "No string table";
break;
case ELFLOADER_NO_TEXT:
print = "No text segment";
break;
case ELFLOADER_SYMBOL_NOT_FOUND:
print = "Symbol not found: ";
break;
case ELFLOADER_SEGMENT_NOT_FOUND:
print = "Segment not found: ";
break;
case ELFLOADER_NO_STARTPOINT:
print = "No starting point";
break;
default:
print = "Unknown return code from the ELF loader (internal bug)";
break;
}
if(ret == ELFLOADER_OK) {
int i;
for(i = 0; elfloader_autostart_processes[i] != NULL; ++i) {
printf("exec: starting process %s\n", elfloader_autostart_processes[i]->name);
}
autostart_start(elfloader_autostart_processes);
}
}
}
db_result_t
storage_rename_relation(char *old_name, char *new_name)
{
db_result_t result;
int old_fd;
int new_fd;
int r;
char buf[64];
result = DB_STORAGE_ERROR;
old_fd = new_fd = -1;
old_fd = cfs_open(old_name, CFS_READ);
new_fd = cfs_open(new_name, CFS_WRITE);
if(old_fd < 0 || new_fd < 0) {
goto error;
}
for(;;) {
r = cfs_read(old_fd, buf, sizeof(buf));
if(r < 0) {
goto error;
} else if(r == 0) {
break;
}
if(cfs_write(new_fd, buf, r) != r) {
goto error;
}
};
cfs_remove(old_name);
result = DB_OK;
error:
cfs_close(old_fd);
cfs_close(new_fd);
if(result != DB_OK) {
cfs_remove(new_name);
}
return result;
}
