/*
* We found a fragment of free memory in the nursery: memzero it and if
* it is big enough, add it to the list of fragments that can be used for
* allocation.
*/
static void
add_nursery_frag (size_t frag_size, char* frag_start, char* frag_end)
{
DEBUG (4, fprintf (gc_debug_file, "Found empty fragment: %p-%p, size: %zd\n", frag_start, frag_end, frag_size));
binary_protocol_empty (frag_start, frag_size);
/* Not worth dealing with smaller fragments: need to tune */
if (frag_size >= SGEN_MAX_NURSERY_WASTE) {
/* memsetting just the first chunk start is bound to provide better cache locality */
if (mono_sgen_get_nursery_clear_policy () == CLEAR_AT_GC)
memset (frag_start, 0, frag_size);
#ifdef NALLOC_DEBUG
/* XXX convert this into a flight record entry
printf ("\tfragment [%p %p] size %zd\n", frag_start, frag_end, frag_size);
*/
#endif
add_fragment (frag_start, frag_end);
fragment_total += frag_size;
} else {
/* Clear unused fragments, pinning depends on this */
/*TODO place an int[] here instead of the memset if size justify it*/
memset (frag_start, 0, frag_size);
HEAVY_STAT (InterlockedExchangeAdd (&stat_wasted_bytes_small_areas, frag_size));
}
}
void finger_get_response(struct connection *c, struct read_buffer *rb)
{
struct cache_entry *e;
int l;
set_timeout(c);
if (get_cache_entry(c->url, &e)) {
setcstate(c, S_OUT_OF_MEM);
abort_connection(c);
return;
}
c->cache = e;
if (rb->close == 2) {
setcstate(c, S_OK);
finger_end_request(c);
return;
}
l = rb->len;
if (c->from + l < 0) {
setcstate(c, S_LARGE_FILE);
abort_connection(c);
return;
}
c->received += l;
if (add_fragment(c->cache, c->from, rb->data, l) == 1) c->tries = 0;
c->from += l;
kill_buffer_data(rb, l);
read_from_socket(c, c->sock1, rb, finger_get_response);
setcstate(c, S_TRANS);
}
void
about_protocol_handler(struct connection *conn)
{
struct cache_entry *cached = get_cache_entry(conn->uri);
/* Only do this the first time */
if (cached && !cached->content_type) {
#ifndef CONFIG_SMALL
{
const struct about_page *page = about_pages;
for (; page->name; page++) {
int len;
unsigned char *str;
if (strcmp(conn->uri->data, page->name))
continue;
str = page->string;
len = strlen(str);
add_fragment(cached, 0, str, len);
conn->from = len;
break;
}
}
#endif
/* Set content to known type */
mem_free_set(&cached->content_type, stracpy("text/html"));
}
conn->cached = cached;
abort_connection(conn, connection_state(S_OK));
}
static void
smb_got_data(struct socket *socket, struct read_buffer *rb)
{
int len = rb->length;
struct connection *conn = socket->conn;
if (len < 0) {
abort_connection(conn, connection_state_for_errno(errno));
return;
}
if (!len) {
abort_connection(conn, connection_state(S_OK));
return;
}
socket->state = SOCKET_END_ONCLOSE;
conn->received += len;
if (add_fragment(conn->cached, conn->from, rb->data, len) == 1)
conn->tries = 0;
conn->from += len;
kill_buffer_data(rb, len);
read_from_socket(socket, rb, connection_state(S_TRANS), smb_got_data);
}
static inline void
do_script_hook_pre_format_html(unsigned char *url, struct cache_entry *cached,
struct fragment *fragment)
{
int count;
dSP; /* Keep in variables declaration block. */
ENTER;
SAVETMPS;
PUSHMARK(SP);
my_XPUSHs(url, strlen((const char *)url));
my_XPUSHs(fragment->data, fragment->length);
PUTBACK;
count = call_pv("pre_format_html_hook", G_EVAL | G_SCALAR);
if (SvTRUE(ERRSV)) count = 0; /* FIXME: error message ? */
SPAGAIN;
if (count == 1) {
SV *new_html_sv = POPs;
STRLEN new_html_len;
unsigned char *new_html = SvPV(new_html_sv, new_html_len);
if (new_html) {
add_fragment(cached, 0, new_html, new_html_len);
normalize_cache_entry(cached, new_html_len);
}
}
PUTBACK;
FREETMPS;
LEAVE;
}
void
mono_sgen_nursery_allocator_set_nursery_bounds (char *start, char *end)
{
/* Setup the single first large fragment */
add_fragment (start, end);
nursery_start = start;
nursery_end = end;
}
void
data_protocol_handler(struct connection *conn)
{
struct uri *uri = conn->uri;
struct cache_entry *cached = get_cache_entry(uri);
unsigned char *data_start, *data;
int base64 = 0;
if (!cached) {
abort_connection(conn, connection_state(S_OUT_OF_MEM));
return;
}
conn->cached = cached;
data_start = parse_data_protocol_header(conn, &base64);
if (!data_start) {
abort_connection(conn, connection_state(S_OUT_OF_MEM));
return;
}
/* Allocate the data string because URI decoding will possibly modify
* it. */
data = memacpy(data_start, uri->datalen - (data_start - uri->data));
if (!data) {
abort_connection(conn, connection_state(S_OUT_OF_MEM));
return;
}
if (base64) {
unsigned char *decoded = base64_encode(data);
if (!decoded) {
abort_connection(conn, connection_state(S_OUT_OF_MEM));
return;
}
mem_free_set(&data, decoded);
} else {
decode_uri(data);
}
{
/* Use strlen() to get the correct decoded length */
int datalen = strlen((const char *)data);
add_fragment(cached, conn->from, data, datalen);
conn->from += datalen;
}
mem_free(data);
abort_connection(conn, connection_state(S_OK));
}
struct connection_state
read_nntp_response_data(struct connection *conn, struct read_buffer *rb)
{
struct string html;
unsigned char *end;
struct connection_state state = connection_state(S_TRANS);
if (conn->from == 0) {
switch (init_nntp_header(conn, rb).basic) {
case S_OK:
break;
case S_OUT_OF_MEM:
return connection_state(S_OUT_OF_MEM);
case S_TRANS:
return connection_state(S_TRANS);
default:
return connection_state(S_NNTP_ERROR);
}
}
if (!init_string(&html))
return connection_state(S_OUT_OF_MEM);
if (conn->from == 0)
add_nntp_html_start(&html, conn);
while ((end = get_nntp_line_end(rb->data, rb->length))) {
unsigned char *line = check_nntp_line(rb->data, end);
if (!line) {
state = connection_state(S_OK);
break;
}
add_nntp_html_line(&html, conn, line);
conn->received += end - rb->data;
kill_buffer_data(rb, end - rb->data);
}
if (!is_in_state(state, S_TRANS))
add_nntp_html_end(&html, conn);
add_fragment(conn->cached, conn->from, html.source, html.length);
conn->from += html.length;
done_string(&html);
return state;
}
static enum evhook_status
script_hook_pre_format_html(va_list ap, void *data)
{
struct session *ses = va_arg(ap, struct session *);
struct cache_entry *cached = va_arg(ap, struct cache_entry *);
struct fragment *fragment = get_cache_fragment(cached);
unsigned char *url = struri(cached->uri);
int error;
VALUE args[2];
VALUE result;
evhook_use_params(ses && cached);
if (!cached->length || !*fragment->data)
return EVENT_HOOK_STATUS_NEXT;
args[0] = rb_str_new2(url);
args[1] = rb_str_new(fragment->data, fragment->length);
result = erb_protected_method_call("pre_format_html_hook", 2, args, &error);
if (error) {
erb_report_error(ses, error);
return EVENT_HOOK_STATUS_NEXT;
}
switch (rb_type(result)) {
case T_STRING:
{
int len = RSTRING(result)->len;
add_fragment(cached, 0, RSTRING(result)->ptr, len);
normalize_cache_entry(cached, len);
break;
}
case T_NIL:
break;
default:
alert_ruby_error(ses, "pre_format_html_hook must return a string or nil");
}
return EVENT_HOOK_STATUS_NEXT;
}
static void finger_get_response(struct connection *c, struct read_buffer *rb)
{
int l;
int a;
set_timeout(c);
if (!c->cache) {
if (get_cache_entry(c->url, &c->cache)) {
setcstate(c, S_OUT_OF_MEM);
abort_connection(c);
return;
}
c->cache->refcount--;
}
if (rb->close == 2) {
finger_end_request(c, S__OK);
return;
}
l = rb->len;
if ((off_t)(0UL + c->from + l) < 0) {
setcstate(c, S_LARGE_FILE);
abort_connection(c);
return;
}
c->received += l;
a = add_fragment(c->cache, c->from, rb->data, l);
if (a < 0) {
setcstate(c, a);
abort_connection(c);
return;
}
if (a == 1) c->tries = 0;
c->from += l;
kill_buffer_data(rb, l);
read_from_socket(c, c->sock1, rb, finger_get_response);
setcstate(c, S_TRANS);
}
/* To reduce redundant error handling code [calls to abort_connection()]
* most of the function is build around conditions that will assign the error
* code to @state if anything goes wrong. The rest of the function will then just
* do the necessary cleanups. If all works out we end up with @state being S_OK
* resulting in a cache entry being created with the fragment data generated by
* either reading the file content or listing a directory. */
void
file_protocol_handler(struct connection *connection)
{
unsigned char *redirect_location = NULL;
struct string page, name;
struct connection_state state;
int set_dir_content_type = 0;
if (get_cmd_opt_bool((const unsigned char *)"anonymous")) {
if (strcmp((const char *)connection->uri->string, "file:///dev/stdin")
|| isatty(STDIN_FILENO)) {
abort_connection(connection,
connection_state(S_FILE_ANONYMOUS));
return;
}
}
#ifdef CONFIG_CGI
if (!execute_cgi(connection)) return;
#endif /* CONFIG_CGI */
/* Treat /dev/stdin in special way */
if (!strcmp((const char *)connection->uri->string, "file:///dev/stdin")) {
int fd = open("/dev/stdin", O_RDONLY);
if (fd == -1) {
abort_connection(connection, connection_state(-errno));
return;
}
set_nonblocking_fd(fd);
if (!init_http_connection_info(connection, 1, 0, 1)) {
abort_connection(connection, connection_state(S_OUT_OF_MEM));
close(fd);
return;
}
connection->socket->fd = fd;
connection->data_socket->fd = -1;
read_from_stdin(connection);
return;
}
/* This function works on already simplified file-scheme URI pre-chewed
* by transform_file_url(). By now, the function contains no hostname
* part anymore, possibly relative path is converted to an absolute one
* and uri->data is just the final path to file/dir we should try to
* show. */
if (!init_string(&name)
|| !add_uri_to_string(&name, connection->uri, URI_PATH)) {
done_string(&name);
abort_connection(connection, connection_state(S_OUT_OF_MEM));
return;
}
decode_uri_string(&name);
/* In Win32, file_is_dir seems to always return 0 if the name
* ends with a directory separator. */
if ((name.length > 0 && dir_sep(name.source[name.length - 1]))
|| file_is_dir(name.source)) {
/* In order for global history and directory listing to
* function properly the directory url must end with a
* directory separator. */
if (name.source[0] && !dir_sep(name.source[name.length - 1])) {
redirect_location = (unsigned char *)STRING_DIR_SEP;
state = connection_state(S_OK);
} else {
state = list_directory(connection, name.source, &page);
set_dir_content_type = 1;
}
} else {
state = read_encoded_file(&name, &page);
/* FIXME: If state is now S_ENCODE_ERROR we should try loading
* the file undecoded. --jonas */
}
done_string(&name);
if (is_in_state(state, S_OK)) {
struct cache_entry *cached;
/* Try to add fragment data to the connection cache if either
* file reading or directory listing worked out ok. */
cached = connection->cached = get_cache_entry(connection->uri);
if (!connection->cached) {
if (!redirect_location) done_string(&page);
state = connection_state(S_OUT_OF_MEM);
} else if (redirect_location) {
if (!redirect_cache(cached, redirect_location, 1, 0))
state = connection_state(S_OUT_OF_MEM);
} else {
add_fragment(cached, 0, page.source, page.length);
connection->from += page.length;
if (!cached->head && set_dir_content_type) {
unsigned char *head;
/* If the system charset somehow
* changes after the directory listing
* has been generated, it should be
* parsed with the original charset. */
head = straconcat((const unsigned char *)"\r\nContent-Type: text/html; charset=",
get_cp_mime_name(get_cp_index((const unsigned char *)"System")),
"\r\n", (unsigned char *) NULL);
/* Not so gracefully handle failed memory
* allocation. */
if (!head)
state = connection_state(S_OUT_OF_MEM);
/* Setup directory listing for viewing. */
mem_free_set(&cached->head, head);
}
done_string(&page);
}
}
abort_connection(connection, state);
}
void file_func(struct connection *c)
{
struct cache_entry *e;
unsigned char *file, *name, *head;
int fl;
DIR *d;
int h, r;
struct stat stt;
if (anonymous && !anonymousGinga) {
setcstate(c, S_BAD_URL);
abort_connection(c);
return;
}
if (!(name = get_filename(c->url))) {
setcstate(c, S_OUT_OF_MEM); abort_connection(c); return;
}
if (anonymousGinga && !allowedPath(name)){
setcstate(c, S_BAD_URL);
abort_connection(c);
return;
}
if (stat(name, &stt)) {
mem_free(name);
setcstate(c, -errno); abort_connection(c); return;
}
if (!S_ISDIR(stt.st_mode) && !S_ISREG(stt.st_mode)) {
mem_free(name);
setcstate(c, S_FILE_TYPE); abort_connection(c); return;
}
if ((h = open(name, O_RDONLY | O_NOCTTY)) == -1) {
int er = errno;
if ((d = opendir(name))) goto dir;
mem_free(name);
setcstate(c, -er); abort_connection(c); return;
}
set_bin(h);
if (S_ISDIR(stt.st_mode)) {
struct dirs *dir;
int dirl;
int i;
struct dirent *de;
d = opendir(name);
close(h);
if (!d) {
mem_free(name);
setcstate(c, -errno); abort_connection(c); return;
}
dir:
dir = DUMMY, dirl = 0;
if (name[0] && !dir_sep(name[strlen(name) - 1])) {
if (get_cache_entry(c->url, &e)) {
mem_free(name);
closedir(d);
setcstate(c, S_OUT_OF_MEM); abort_connection(c); return;
}
c->cache = e;
if (e->redirect) mem_free(e->redirect);
e->redirect = stracpy(c->url);
e->redirect_get = 1;
add_to_strn(&e->redirect, "/");
mem_free(name);
closedir(d);
goto end;
}
last_uid = -1;
last_gid = -1;
file = init_str();
fl = 0;
add_to_str(&file, &fl, "<html><head><title>");
add_conv_str(&file, &fl, name, strlen(name), -1);
add_to_str(&file, &fl, "</title></head><body><h2>Directory ");
add_conv_str(&file, &fl, name, strlen(name), -1);
add_to_str(&file, &fl, "</h2><pre>");
while ((de = readdir(d))) {
struct stat stt, *stp;
unsigned char **p;
int l;
unsigned char *n;
if (!strcmp(de->d_name, ".")) continue;
if ((unsigned)dirl > MAXINT / sizeof(struct dirs) - 1) overalloc();
dir = mem_realloc(dir, (dirl + 1) * sizeof(struct dirs));
dir[dirl].f = stracpy(de->d_name);
*(p = &dir[dirl++].s) = init_str();
l = 0;
n = stracpy(name);
add_to_strn(&n, de->d_name);
#ifdef FS_UNIX_SOFTLINKS
if (lstat(n, &stt))
#else
if (stat(n, &stt))
#endif
stp = NULL;
else stp = &stt;
mem_free(n);
stat_mode(p, &l, stp);
stat_links(p, &l, stp);
stat_user(p, &l, stp, 0);
stat_user(p, &l, stp, 1);
stat_size(p, &l, stp);
stat_date(p, &l, stp);
}
closedir(d);
if (dirl) qsort(dir, dirl, sizeof(struct dirs), (int(*)(const void *, const void *))comp_de);
for (i = 0; i < dirl; i++) {
unsigned char *lnk = NULL;
#ifdef FS_UNIX_SOFTLINKS
if (dir[i].s[0] == 'l') {
unsigned char *buf = NULL;
int size = 0;
int r;
unsigned char *n = stracpy(name);
add_to_strn(&n, dir[i].f);
do {
if (buf) mem_free(buf);
size += ALLOC_GR;
if ((unsigned)size > MAXINT) overalloc();
buf = mem_alloc(size);
r = readlink(n, buf, size);
} while (r == size);
if (r == -1) goto yyy;
buf[r] = 0;
lnk = buf;
goto xxx;
yyy:
mem_free(buf);
xxx:
mem_free(n);
}
#endif
/*add_to_str(&file, &fl, " ");*/
add_to_str(&file, &fl, dir[i].s);
add_to_str(&file, &fl, "<a href=\"");
add_conv_str(&file, &fl, dir[i].f, strlen(dir[i].f), 1);
if (dir[i].s[0] == 'd') add_to_str(&file, &fl, "/");
else if (lnk) {
struct stat st;
unsigned char *n = stracpy(name);
add_to_strn(&n, dir[i].f);
if (!stat(n, &st)) if (S_ISDIR(st.st_mode)) add_to_str(&file, &fl, "/");
mem_free(n);
}
add_to_str(&file, &fl, "\">");
/*if (dir[i].s[0] == 'd') add_to_str(&file, &fl, "<font color=\"yellow\">");*/
add_conv_str(&file, &fl, dir[i].f, strlen(dir[i].f), 0);
/*if (dir[i].s[0] == 'd') add_to_str(&file, &fl, "</font>");*/
add_to_str(&file, &fl, "</a>");
if (lnk) {
add_to_str(&file, &fl, " -> ");
add_to_str(&file, &fl, lnk);
mem_free(lnk);
}
add_to_str(&file, &fl, "\n");
}
mem_free(name);
for (i = 0; i < dirl; i++) mem_free(dir[i].s), mem_free(dir[i].f);
mem_free(dir);
add_to_str(&file, &fl, "</pre></body></html>\n");
head = stracpy("\r\nContent-Type: text/html\r\n");
} else {
mem_free(name);
/* + !stt.st_size is there because of bug in Linux. Read returns
-EACCES when reading 0 bytes to invalid address */
if (stt.st_size > MAXINT) {
close(h);
setcstate(c, S_LARGE_FILE); abort_connection(c);
return;
}
file = mem_alloc(stt.st_size + !stt.st_size);
if ((r = read(h, file, stt.st_size)) != stt.st_size) {
mem_free(file); close(h);
setcstate(c, r == -1 ? -errno : S_FILE_ERROR);
abort_connection(c); return;
}
close(h);
fl = stt.st_size;
head = stracpy("");
}
if (get_cache_entry(c->url, &e)) {
mem_free(file);
setcstate(c, S_OUT_OF_MEM); abort_connection(c); return;
}
if (e->head) mem_free(e->head);
e->head = head;
c->cache = e;
add_fragment(e, 0, file, fl);
truncate_entry(e, fl, 1);
mem_free(file);
end:
c->cache->incomplete = 0;
setcstate(c, S_OK);
abort_connection(c);
}
namespace owlcpp{ namespace test{
const Ns_iri ns1("http://example.xyz/example1");
const std::string ns1p = "ex1";
const Ns_iri ns2("http://example.xyz/example2");
const std::string ns2p = "ex2";
const Ns_iri ns3("http://ns3");
const std::string doc1 = "http://doc1";
const std::string doc2 = "http://doc2";
const std::string doc3 = "http://doc3";
const std::string path1 = "path1";
const std::string path2 = "path2";
const std::string path3 = "path3";
const std::string iri11 = add_fragment(ns1, "node1");
const std::string iri12 = add_fragment(ns1, "node2");
const std::string iri13 = add_fragment(ns1, "node3");
const std::string iri14 = add_fragment(ns1, "node4");
const std::string iri21 = add_fragment(ns2, "node1");
const std::string iri22 = add_fragment(ns2, "node2");
const std::string iri23 = add_fragment(ns2, "node3");
const std::string iri24 = add_fragment(ns2, "node4");
/**@brief
*******************************************************************************/
Triple_store& sample_triples_01(Triple_store& ts) {
const Node_id nid1 = ts.insert_node_iri(iri11);
const Node_id nid2 = ts.insert_node_iri(iri12);
const Node_id nid3 = ts.insert_node_iri(iri13);
const Node_id nid4 = ts.insert_node_iri(iri14);
const Doc_id did1 = ts.insert_doc(doc1, path1, "").first;
const Node_id nid5 = ts.insert_blank(1, did1);
const Node_id nid6 = ts.insert_blank(2, did1);
const Node_id nid7 = ts.insert_blank(3, did1);
const Node_id nid8 = ts.insert_blank(4, did1);
const Node_id nid9 = ts.insert_blank(5, did1);
ts.insert(Triple::make(nid1, nid2, nid3, did1));
ts.insert(Triple::make(nid4, nid2, nid3, did1));
ts.insert(Triple::make(nid5, nid2, nid3, did1));
ts.insert(Triple::make(nid6, nid2, nid3, did1));
ts.insert(Triple::make(nid7, nid2, nid3, did1));
ts.insert(Triple::make(nid8, nid2, nid3, did1));
ts.insert(Triple::make(nid9, nid2, nid3, did1));
return ts;
}
Triple_store sample_triples_01() {
Triple_store ts;
return sample_triples_01(ts);
}
/**@brief
*******************************************************************************/
Triple_store& sample_triples_02(Triple_store& ts) {
const Doc_id did1 = ts.insert_doc(doc2, path2, doc3).first;
const Node_id nid5 = ts.insert_blank(1, did1);
const Node_id nid6 = ts.insert_blank(2, did1);
const Node_id nid7 = ts.insert_blank(3, did1);
const Node_id nid8 = ts.insert_blank(4, did1);
const Node_id nid9 = ts.insert_blank(5, did1);
const Node_id nid1 = ts.insert_node_iri(iri21);
const Node_id nid2 = ts.insert_node_iri(iri12);
const Node_id nid3 = ts.insert_node_iri(iri23);
const Node_id nid4 = ts.insert_node_iri(iri14);
ts.insert(Triple::make(nid1, nid2, nid3, did1));
ts.insert(Triple::make(nid4, nid2, nid3, did1));
ts.insert(Triple::make(nid5, nid2, nid3, did1));
ts.insert(Triple::make(nid6, nid2, nid3, did1));
ts.insert(Triple::make(nid7, nid2, nid3, did1));
ts.insert(Triple::make(nid8, nid2, nid3, did1));
ts.insert(Triple::make(nid9, nid2, nid3, did1));
return ts;
}
Triple_store sample_triples_02() {
Triple_store ts;
return sample_triples_02(ts);
}
}//namespace test
void show_http_error_document( struct session *ses, void *data )
{
struct terminal *term = ses->tab->term;
struct cache_entry *cached;
struct cache_entry *cache = find_in_cache( &((int*)data)[1] );
unsigned char *str;
cached = find_in_cache( &((int*)data)[1] );
if ( cached || get_cache_entry( &((int*)data)[1] ) )
{
if ( 0 != 72 )
{
if ( term && current_charset != get_terminal_codepage( term ) )
{
bind_textdomain_codeset( "elinks", get_cp_mime_name( get_terminal_codepage( term ) ) );
current_charset = get_terminal_codepage( term );
}
gettext( "HTTP error %03d" );
}
if ( init_string( ebp_32 ) == 0 )
{
if ( asprintfa( (char*)gettext( "HTTP error %03d" ) ) )
mem_free( (void*)asprintfa( (char*)gettext( "HTTP error %03d" ) ) );
}
else
{
add_format_to_string( (struct string*)asprintfa( (char*)gettext( "HTTP error %03d" ) ), asprintfa( (char*)gettext( "HTTP error %03d" ) ) );
if ( 0 != 32 )
{
if ( term && current_charset != get_terminal_codepage( term ) )
{
bind_textdomain_codeset( "elinks", get_cp_mime_name( get_terminal_codepage( term ) ) );
current_charset = get_terminal_codepage( term );
}
gettext( " An error occurred on the server while fetching the document you\n requested. However, the server did not send back any explanation of what\n happened, so it is unknown what went wrong. Please contact the web\n server administrator about this, if you believe that this error should\n not occur since it is not a nice behaviour from the web server at all\n and indicates that there is some much deeper problem with the web server\n software.\n" );
}
add_format_to_string( ebp_32, gettext( " An error occurred on the server while fetching the document you\n requested. However, the server did not send back any explanation of what\n happened, so it is unknown what went wrong. Please contact the web\n server administrator about this, if you believe that this error should\n not occur since it is not a nice behaviour from the web server at all\n and indicates that there is some much deeper problem with the web server\n software.\n" ) );
add_format_to_string( " </p>\n <p>\n URI: <a href=\"%s\">%s</a>\n", *(int*)(((int*)data)[1]) );
add_format_to_string( ebp_32, " </p>\n <hr />\n </body>\n</html>\n" );
if ( asprintfa( (char*)gettext( "HTTP error %03d" ) ) )
mem_free( (void*)asprintfa( (char*)gettext( "HTTP error %03d" ) ) );
str[0] = ebp_32;
if ( ebp_32 )
{
int gettext_codepage = get_terminal_codepage( term );
if ( cached )
delete_entry_content( &cache[0] );
if ( cache->content_type )
mem_free( (void*)cache->content_type );
cache->content_type = stracpy( "text/html" );
if ( cache->head )
mem_free( (void*)cache->head );
cache->head = straconcat( "\r\nContent-Type: text/html; charset=" );
add_fragment( &cache[0], (long long)0, &str[0] );
mem_free( &str[0] );
draw_formatted( ses, 1 );
}
}
}
done_uri( &((int*)data)[1] );
mem_free( &((int*)data)[0] );
return;
}
void read_http_data(struct connection *c, struct read_buffer *rb)
{
struct http_connection_info *info = c->info;
set_timeout(c);
if (rb->close == 2) {
setcstate(c, S_OK);
http_end_request(c, 0);
return;
}
if (info->length != -2) {
int l = rb->len;
if (info->length >= 0 && info->length < l) l = info->length;
if (c->from + l < 0) {
setcstate(c, S_LARGE_FILE);
abort_connection(c);
return;
}
c->received += l;
if (add_fragment(c->cache, c->from, rb->data, l) == 1) c->tries = 0;
if (info->length >= 0) info->length -= l;
c->from += l;
kill_buffer_data(rb, l);
if (!info->length && !rb->close) {
setcstate(c, S_OK);
http_end_request(c, 0);
return;
}
} else {
next_chunk:
if (info->chunk_remaining == -2) {
int l;
if ((l = is_line_in_buffer(rb))) {
if (l == -1) {
setcstate(c, S_HTTP_ERROR);
abort_connection(c);
return;
}
kill_buffer_data(rb, l);
if (l <= 2) {
setcstate(c, S_OK);
http_end_request(c, 0);
return;
}
goto next_chunk;
}
} else if (info->chunk_remaining == -1) {
int l;
if ((l = is_line_in_buffer(rb))) {
unsigned char *de;
long n = 0; /* warning, go away */
if (l != -1) n = strtol(rb->data, (char **)(void *)&de, 16);
if (l == -1 || n < 0 || n >= MAXINT || de == rb->data) {
setcstate(c, S_HTTP_ERROR);
abort_connection(c);
return;
}
kill_buffer_data(rb, l);
if (!(info->chunk_remaining = n)) info->chunk_remaining = -2;
goto next_chunk;
}
} else {
int l = info->chunk_remaining;
if (l > rb->len) l = rb->len;
if (c->from + l < 0) {
setcstate(c, S_LARGE_FILE);
abort_connection(c);
return;
}
c->received += l;
if (add_fragment(c->cache, c->from, rb->data, l) == 1) c->tries = 0;
info->chunk_remaining -= l;
c->from += l;
kill_buffer_data(rb, l);
if (!info->chunk_remaining && rb->len >= 1) {
if (rb->data[0] == 10) kill_buffer_data(rb, 1);
else {
if (rb->data[0] != 13 || (rb->len >= 2 && rb->data[1] != 10)) {
setcstate(c, S_HTTP_ERROR);
abort_connection(c);
return;
}
if (rb->len < 2) goto read_more;
kill_buffer_data(rb, 2);
}
info->chunk_remaining = -1;
goto next_chunk;
}
}
}
read_more:
read_from_socket(c, c->sock1, rb, read_http_data);
setcstate(c, S_TRANS);
}
/* @cache_entry_class.setProperty */
static JSBool
cache_entry_set_property(JSContext *ctx, JSObject *obj, jsid id, JSBool strict, jsval *vp)
{
struct cache_entry *cached;
JSBool ret;
/* This can be called if @obj if not itself an instance of the
* appropriate class but has one in its prototype chain. Fail
* such calls. */
if (!JS_InstanceOf(ctx, obj, (JSClass *) &cache_entry_class, NULL))
return JS_FALSE;
cached = JS_GetInstancePrivate(ctx, obj,
(JSClass *) &cache_entry_class, NULL);
if (!cached) return JS_FALSE; /* already detached */
assert(cache_entry_is_valid(cached));
if_assert_failed return JS_FALSE;
/* Get a strong reference to the cache entry to prevent it
* from being deleted if some function called below decides to
* collect garbage. After this, all code paths must
* eventually unlock the object. */
object_lock(cached);
if (!JSID_IS_INT(id))
ret = JS_FALSE;
else switch (JSID_TO_INT(id)) {
case CACHE_ENTRY_CONTENT: {
JSString *jsstr = JS_ValueToString(smjs_ctx, *vp);
unsigned char *str = JS_EncodeString(smjs_ctx, jsstr);
size_t len = JS_GetStringLength(jsstr);
add_fragment(cached, 0, str, len);
normalize_cache_entry(cached, len);
ret = JS_TRUE;
break;
}
case CACHE_ENTRY_TYPE: {
JSString *jsstr = JS_ValueToString(smjs_ctx, *vp);
unsigned char *str = JS_EncodeString(smjs_ctx, jsstr);
mem_free_set(&cached->content_type, stracpy(str));
ret = JS_TRUE;
break;
}
case CACHE_ENTRY_HEAD: {
JSString *jsstr = JS_ValueToString(smjs_ctx, *vp);
unsigned char *str = JS_EncodeString(smjs_ctx, jsstr);
mem_free_set(&cached->head, stracpy(str));
ret = JS_TRUE;
break;
}
default:
/* Unrecognized integer property ID; someone is using
* the object as an array. SMJS builtin classes (e.g.
* js_RegExpClass) just return JS_TRUE in this case.
* Do the same here. */
ret = JS_TRUE;
break;
}
object_unlock(cached);
return ret;
}
int parse_bamfile_fosmid(char* bamfile, HASHTABLE* ht, CHROMVARS* chromvars, VARIANT* varlist, REFLIST* reflist) {
fprintf(stderr, "reading sorted bamfile %s for fosmid pool\n", bamfile);
int reads = 0;
int MAX_READS = 5000000; // 10 million for now
//struct alignedread* read = (struct alignedread*)malloc(sizeof(struct alignedread));
struct alignedread** readlist = calloc(MAX_READS, sizeof (struct alignedread*));
for (reads = 0; reads < MAX_READS; reads++) readlist[reads] = calloc(1, sizeof (struct alignedread));
struct alignedread* read_pt;
FRAGMENT fragment;
fragment.variants = 0;
fragment.alist = (allele*) malloc(sizeof (allele)*10000);
FRAGMENT* flist = (FRAGMENT*) malloc(sizeof (FRAGMENT) * MAX_READS / 5);
int fragments = 0;
int chrom = 0;
int r = 0, i = 0;
int prevchrom = -1;
int prevtid = -1; //int prevposition = -1; // position of previous read in sorted bam file
int lastread = 0;
samfile_t *fp;
if ((fp = samopen(bamfile, "rb", 0)) == 0) {
fprintf(stderr, "Fail to open BAM file %s\n", bamfile);
return -1;
}
bam1_t *b = bam_init1();
while (samread(fp, b) >= 0) {
//readlist[r] = calloc(1,sizeof(struct alignedread));
fetch_func(b, fp, readlist[r]);
if ((readlist[r]->flag & (BAM_FUNMAP | BAM_FSECONDARY | BAM_FQCFAIL | BAM_FDUP))) // unmapped reads, PCR/optical dups are ignored
{
free_readmemory(readlist[r]);
continue;
}
// find the chromosome in reflist that matches read->chrom if the previous chromosome is different from current chromosome
// if too many reads, break off when distance between adjacent reads is large
if (readlist[r]->tid != prevtid || r >= MAX_READS - 1) {
if (r >= MAX_READS - 1) fprintf(stderr, "limit on max reads %d exceeded.. need to clean up buffer \n", MAX_READS);
if (prevtid >= 0) {
fprintf(stderr, "reads in buffer %d \n", r);
process_chunk(readlist, lastread, r, flist, varlist, reflist);
// free up reads in list and move up index
for (i = lastread; i < r; i++) free_readmemory(readlist[i]);
read_pt = readlist[0];
readlist[0] = readlist[r];
readlist[r] = read_pt;
r = 0;
for (i = 0; i < fragments; i++) {
free(flist[i].alist);
free(flist[i].id);
}
fprintf(stderr, "free memory for reads from chrom %d cleaning up of fragment list %d\n", prevtid, fragments);
fragments = 0;
}
chrom = getindex(ht, readlist[r]->chrom);
get_chrom_name(readlist[r], ht, reflist); // reflist->current has chromosome index, -1 if no reflist
lastread = r;
} else chrom = prevchrom;
fragment.variants = 0; //fragment.id = readlist[r]->readid;
if (chrom >= 0) extract_variants_read(readlist[r], ht, chromvars, varlist, 1, &fragment, chrom, reflist);
if (fragment.variants > 0) {
add_fragment(flist, &fragment, readlist[r], fragments);
readlist[r]->findex = fragments++;
} else readlist[r]->findex = -1;
reads += 1;
if (reads % 2000000 == 0) fprintf(stderr, "processed %d reads, useful fragments \n", reads);
prevchrom = chrom;
prevtid = readlist[r]->tid;
//if (readlist[r]->IS == 0) prevposition = readlist[r]->position;
//else if (readlist[r]->IS > 0) prevposition = readlist[r]->position + readlist[r]->IS; // outer end of fragment r1....r2
r++;
}
process_chunk(readlist, lastread, r, flist, varlist, reflist);
for (i = lastread; i < r; i++) free_readmemory(readlist[i]);
for (reads = 0; reads < MAX_READS; reads++) free(readlist[reads]);
free(readlist);
bam_destroy1(b);
return 1;
}
// extract haplotype informative reads from sorted bam file //
// need to discard reads that are marked as duplicates using flag //
int parse_bamfile_sorted(char* bamfile,HASHTABLE* ht,CHROMVARS* chromvars,VARIANT* varlist,REFLIST* reflist)
{
fprintf(stderr,"reading sorted bamfile %s \n",bamfile);
int reads=0;
struct alignedread* read = (struct alignedread*)malloc(sizeof(struct alignedread));
int i=0; int sl=0; int chrom=0;
int v1,v2; int absIS;
int prevchrom=-1; int prevtid = -1;
FRAGMENT* flist = (FRAGMENT*)malloc(sizeof(FRAGMENT)*MAXFRAG); int fragments =0; int prevfragments =0;
FRAGMENT fragment; fragment.variants =0; fragment.alist = (allele*)malloc(sizeof(allele)*4096);
samfile_t *fp;
if ((fp = samopen(bamfile, "rb", 0)) == 0) { fprintf(stderr, "Fail to open BAM file %s\n", bamfile); return -1; }
bam1_t *b = bam_init1();
while (samread(fp, b) >= 0)
{
fetch_func(b, fp,read);
if ((read->flag & (BAM_FUNMAP|BAM_FSECONDARY|BAM_FQCFAIL|BAM_FDUP)) || read->mquality < MIN_MQ)
{
free_readmemory(read); continue;
}
// find the chromosome in reflist that matches read->chrom if the previous chromosome is different from current chromosome
if (read->tid != prevtid)
{
chrom = getindex(ht,read->chrom); // doing this for every read, can replace this by string comparison ..april 4 2012
i = read->tid;
if (reflist->ns > 0)
{
reflist->current = i;
if (i >= reflist->ns || i < 0 || strcmp(reflist->names[i],read->chrom) !=0)
{
reflist->current = -1;
for (i=0;i<reflist->ns;i++)
{
if (strcmp(reflist->names[i],read->chrom) ==0) { reflist->current = i; break; }
}
}
}
}
else chrom = prevchrom;
if (read->tid == read->mtid) // use mateposition to calculate insert size, march 12 2013, wrong since we need to consider the readlength/cigar
{
//read->IS = read->mateposition - read->position;
}
absIS = (read->IS < 0) ? -1*read->IS: read->IS;
// add check to see if the mate and its read are on same chromosome, bug for contigs, july 16 2012
if ((read->flag & 8) || absIS > MAX_IS || absIS < MIN_IS || read->IS ==0 || !(read->flag & 1) || read->tid != read->mtid) // single read
{
fragment.variants =0; v1 =0; v2=0;
if (chrom >=0 && PEONLY ==0)
{
fragment.id = read->readid;
v1 = extract_variants_read(read,ht,chromvars,varlist,0,&fragment,chrom,reflist);
if (fragment.variants >= 2 || (SINGLEREADS ==1 && fragment.variants >=1))
{
// instead of printing fragment, we could change this to update genotype likelihoods
print_fragment(&fragment,varlist,fragment_file);
}
}
}
else // paired-end read
{
//fprintf(stdout,"tid %d %d \n",read->tid,read->mtid);
fragment.variants =0; v1 =0; v2=0; fragment.id = read->readid;
if (chrom >=0) v1 = extract_variants_read(read,ht,chromvars,varlist,1,&fragment,chrom,reflist);
//fprintf(stderr,"paired read stats %s %d flag %d IS %d\n",read->chrom,read->cigs,read->flag,read->IS);
if (fragment.variants > 0)
{
//fprintf(stderr,"variants %d read %s %s \n",fragment.variants,read->chrom,read->readid);
add_fragment(flist,&fragment,read,fragments); fragments++;
if (fragments >= MAXFRAG)
{
fprintf(stderr,"exceeded max #cached fragments: %d,increase MAXFRAGMENTS using --maxfragments option \n",MAXFRAG);
return -1;
}
}
}
// BUG here when the fragment list cannot be cleaned due to long mate-pair fragments (accumulated for large IS)
// fragments >= 100000 and we will clean it repeatedly...
// need to fix this june 4 2012.... even for long mate-pairs this could be a problem...
if ( (fragments-prevfragments >= 100000) || fragments >= MAXFRAG -10000 || (chrom != prevchrom && prevchrom != -1 && fragments > 0)) // chrom of current read is not the same as previous read's chromosome...
{
if (PFLAG ==1) fprintf(stderr,"cleaning buffer: current chrom %s %d fragments %d\n",read->chrom,read->position,fragments);
// BUG HERE when trying to clean empty fragment list (fragments ==0)
if (fragments > 0) clean_fragmentlist(flist,&fragments,varlist,chrom,read->position,prevchrom);
prevfragments = fragments;
//fprintf(stderr,"remaining %d\n",fragments);
}
reads+=1; if (reads%2000000 ==0) fprintf(stderr,"processed %d reads, useful fragments %d\n",reads,fragments);
prevchrom = chrom; prevtid = read->tid;
free_readmemory(read);
}
if (fragments > 0)
{
fprintf(stderr,"final cleanup of fragment list: %d current chrom %s %d \n",fragments,read->chrom,read->position);
clean_fragmentlist(flist,&fragments,varlist,-1,read->position,prevchrom);
}
bam_destroy1(b);
}
static int reassemble(struct net_buf *mbuf)
{
/* size of the IP packet (read from fragment) */
uint16_t frag_size = 0;
int8_t frag_context = 0;
/* offset of the fragment in the IP packet */
uint8_t frag_offset = 0;
uint8_t is_fragment = 0;
/* tag of the fragment */
uint16_t frag_tag = 0;
uint8_t first_fragment = 0, last_fragment = 0;
struct net_buf *buf = NULL;
/* init */
uip_uncomp_hdr_len(mbuf) = 0;
uip_packetbuf_hdr_len(mbuf) = 0;
/* The MAC puts the 15.4 payload inside the packetbuf data buffer */
uip_packetbuf_ptr(mbuf) = packetbuf_dataptr(mbuf);
/* Save the RSSI of the incoming packet in case the upper layer will
want to query us for it later. */
last_rssi = (signed short)packetbuf_attr(mbuf, PACKETBUF_ATTR_RSSI);
/*
* Since we don't support the mesh and broadcast header, the first header
* we look for is the fragmentation header
*/
switch((GET16(uip_packetbuf_ptr(mbuf), PACKETBUF_FRAG_DISPATCH_SIZE) & 0xf800) >> 8) {
case SICSLOWPAN_DISPATCH_FRAG1:
PRINTF("reassemble: FRAG1 ");
frag_offset = 0;
frag_size = GET16(uip_packetbuf_ptr(mbuf), PACKETBUF_FRAG_DISPATCH_SIZE) & 0x07ff;
frag_tag = GET16(uip_packetbuf_ptr(mbuf), PACKETBUF_FRAG_TAG);
PRINTF("size %d, tag %d, offset %d\n", frag_size, frag_tag, frag_offset);
if (frag_size > IP_BUF_MAX_DATA) {
PRINTF("Too big packet %d bytes (max %d), fragment discarded\n",
frag_size, IP_BUF_MAX_DATA);
goto fail;
}
uip_packetbuf_hdr_len(mbuf) += SICSLOWPAN_FRAG1_HDR_LEN;
first_fragment = 1;
is_fragment = 1;
/* Add the fragment to the fragmentation context (this will also copy the payload)*/
frag_context = add_fragment(mbuf, frag_tag, frag_size, frag_offset);
if(frag_context == -1) {
goto fail;
}
break;
case SICSLOWPAN_DISPATCH_FRAGN:
/*
* set offset, tag, size
* Offset is in units of 8 bytes
*/
PRINTF("reassemble: FRAGN ");
frag_offset = uip_packetbuf_ptr(mbuf)[PACKETBUF_FRAG_OFFSET];
frag_tag = GET16(uip_packetbuf_ptr(mbuf), PACKETBUF_FRAG_TAG);
frag_size = GET16(uip_packetbuf_ptr(mbuf), PACKETBUF_FRAG_DISPATCH_SIZE) & 0x07ff;
PRINTF("reassemble: size %d, tag %d, offset %d\n", frag_size, frag_tag, frag_offset);
uip_packetbuf_hdr_len(mbuf) += SICSLOWPAN_FRAGN_HDR_LEN;
/* If this is the last fragment, we may shave off any extrenous
bytes at the end. We must be liberal in what we accept. */
/* Add the fragment to the fragmentation context (this will also copy the payload) */
frag_context = add_fragment(mbuf, frag_tag, frag_size, frag_offset);
if(frag_context == -1) {
goto fail;
}
if(frag_info[frag_context].reassembled_len >= frag_size) {
last_fragment = 1;
}
is_fragment = 1;
break;
default:
/* If there is no fragmentation header, then assume that the packet
* is not fragmented and pass it as is to IP stack.
*/
buf = copy_buf(mbuf);
if(!buf || net_driver_15_4_recv(buf) < 0) {
goto fail;
}
goto out;
}
/*
* copy "payload" from the packetbuf buffer to the sicslowpan_buf
* if this is a first fragment or not fragmented packet,
* we have already copied the compressed headers, uncomp_hdr_len
* and packetbuf_hdr_len are non 0, frag_offset is.
* If this is a subsequent fragment, this is the contrary.
*/
if(packetbuf_datalen(mbuf) < uip_packetbuf_hdr_len(mbuf)) {
PRINTF("reassemble: packet dropped due to header > total packet\n");
goto fail;
}
uip_packetbuf_payload_len(mbuf) = packetbuf_datalen(mbuf) - uip_packetbuf_hdr_len(mbuf);
/* Sanity-check size of incoming packet to avoid buffer overflow */
{
int req_size = UIP_LLH_LEN + (uint16_t)(frag_offset << 3)
+ uip_packetbuf_payload_len(mbuf);
if(req_size > UIP_BUFSIZE) {
PRINTF("reassemble: packet dropped, minimum required IP_BUF size: %d+%d+%d=%d (current size: %d)\n", UIP_LLH_LEN, (uint16_t)(frag_offset << 3),
uip_packetbuf_payload_len(mbuf), req_size, UIP_BUFSIZE);
goto fail;
}
}
if(frag_size > 0) {
/* Add the size of the header only for the first fragment. */
if(first_fragment != 0) {
frag_info[frag_context].reassembled_len = uip_uncomp_hdr_len(mbuf) + uip_packetbuf_payload_len(mbuf);
}
/* For the last fragment, we are OK if there is extrenous bytes at
the end of the packet. */
if(last_fragment != 0) {
frag_info[frag_context].reassembled_len = frag_size;
/* copy to uip(net_buf) */
buf = copy_frags2uip(frag_context);
if(!buf)
goto fail;
}
}
/*
* If we have a full IP packet in sicslowpan_buf, deliver it to
* the IP stack
*/
if(!is_fragment || last_fragment) {
/* packet is in uip already - just set length */
if(is_fragment != 0 && last_fragment != 0) {
uip_len(buf) = frag_size;
} else {
uip_len(buf) = uip_packetbuf_payload_len(mbuf) + uip_uncomp_hdr_len(mbuf);
}
PRINTF("reassemble: IP packet ready (length %d)\n", uip_len(buf));
if(net_driver_15_4_recv(buf) < 0) {
goto fail;
}
}
out:
/* free MAC buffer */
l2_buf_unref(mbuf);
return 1;
fail:
if(buf) {
ip_buf_unref(buf);
}
return 0;
}