void html_embed(struct html_context *html_context, unsigned char *a, unsigned char *xxx3, unsigned char *xxx4, unsigned char **xxx5) { unsigned char *type, *extension; unsigned char *object_src; /* This is just some dirty wrapper. We emulate various things through * this, which is anyway in the spirit of <object> element, unifying * <img> and <iframe> etc. */ object_src = get_url_val(a, (unsigned char *)"src", html_context->doc_cp); if (!object_src || !*object_src) { mem_free_set(&object_src, NULL); return; } /* If there is no extension we want to get the default mime/type * anyway? */ extension = (unsigned char *)strrchr((char *)object_src, '.'); if (!extension) extension = object_src; type = get_extension_content_type(extension); if (type && !c_strncasecmp((const char *)type, "image/", 6)) { html_img_do(a, object_src, html_context); } else { /* We will just emulate <iframe>. */ html_iframe_do(a, object_src, html_context); } mem_free_if(type); mem_free_set(&object_src, NULL); }
static inline void do_script_hook_get_proxy(unsigned char **new_proxy_url, unsigned char *url) { int count; dSP; /* Keep in variables declaration block. */ ENTER; SAVETMPS; PUSHMARK(SP); my_XPUSHs(url, strlen((const char *)url)); PUTBACK; count = call_pv("proxy_for_hook", G_EVAL | G_SCALAR); if (SvTRUE(ERRSV)) count = 0; /* FIXME: error message ? */ SPAGAIN; if (count == 1) { if (TOPs == &PL_sv_undef) { (void) POPs; mem_free_set(new_proxy_url, NULL); } else { #ifndef CONFIG_PERL_POPPX_WITHOUT_N_A STRLEN n_a; /* Used by POPpx macro. */ #endif unsigned char *new_url = POPpx; mem_free_set(new_proxy_url, stracpy(new_url)); } } PUTBACK; FREETMPS; LEAVE; }
/** If @a loaded_in_frame is set, this was called just to indicate a move inside * a frameset, and we basically just reset the appropriate frame's view_state in * that case. When clicking on a link inside a frame, the frame URI is somehow * updated and added to the files-to-load queue, then ses_forward() is called * with @a loaded_in_frame unset, duplicating the whole frameset's location, * then later the file-to-load callback calls it for the particular frame with * @a loaded_in_frame set. */ struct view_state * ses_forward(struct session *ses, int loaded_in_frame) { struct location *loc = NULL; struct view_state *vs; if (!loaded_in_frame) { free_files(ses); mem_free_set(&ses->search_word, NULL); } x: if (!loaded_in_frame) { loc = mem_calloc(1, sizeof(*loc)); if (!loc) return NULL; copy_struct(&loc->download, &ses->loading); } if (ses->task.target.frame && *ses->task.target.frame) { struct frame *frame; assertm(have_location(ses), "no location yet"); if_assert_failed return NULL; if (!loaded_in_frame) { copy_location(loc, cur_loc(ses)); add_to_history(&ses->history, loc); } frame = ses_find_frame(ses, ses->task.target.frame); if (!frame) { if (!loaded_in_frame) { del_from_history(&ses->history, loc); destroy_location(loc); } mem_free_set(&ses->task.target.frame, NULL); goto x; } vs = &frame->vs; if (!loaded_in_frame) { destroy_vs(vs, 1); init_vs(vs, ses->loading_uri, vs->plain); } else { done_uri(vs->uri); vs->uri = get_uri_reference(ses->loading_uri); if (vs->doc_view) { /* vs->doc_view itself will get detached in * render_document_frames(), but that's too * late for us. */ vs->doc_view->vs = NULL; vs->doc_view = NULL; } #ifdef CONFIG_ECMASCRIPT vs->ecmascript_fragile = 1; #endif } } else {
void html_a(struct html_context *html_context, unsigned char *a, unsigned char *xxx3, unsigned char *xxx4, unsigned char **xxx5) { unsigned char *href; href = get_url_val(a, (unsigned char *)"href", html_context->doc_cp); if (href) { unsigned char *target; mem_free_set(&format.link, join_urls(html_context->base_href, trim_chars(href, ' ', 0))); mem_free(href); target = get_target(html_context->options, a); if (target) { mem_free_set(&format.target, target); } else { mem_free_set(&format.target, stracpy(html_context->base_target)); } if (0) { ; /* Shut up compiler */ #ifdef CONFIG_GLOBHIST } else if (get_global_history_item(format.link)) { format.style.color.foreground = format.color.vlink; html_top->pseudo_class &= ~ELEMENT_LINK; html_top->pseudo_class |= ELEMENT_VISITED; #endif #ifdef CONFIG_BOOKMARKS } else if (get_bookmark(format.link)) { format.style.color.foreground = format.color.bookmark_link; html_top->pseudo_class &= ~ELEMENT_VISITED; /* XXX: Really set ELEMENT_LINK? --pasky */ html_top->pseudo_class |= ELEMENT_LINK; #endif } else { format.style.color.foreground = format.color.clink; html_top->pseudo_class &= ~ELEMENT_VISITED; html_top->pseudo_class |= ELEMENT_LINK; } mem_free_set(&format.title, get_attr_val(a, (unsigned char *)"title", html_context->doc_cp)); html_focusable(html_context, a); } else { pop_html_element(html_context); } set_fragment_identifier(html_context, a, (unsigned char *)"name"); }
/* @smjs_globhist_item_class.setProperty */ static JSBool smjs_globhist_item_set_property(JSContext *ctx, JSObject *obj, jsid id, JSBool strict, jsval *vp) { struct global_history_item *history_item; /* 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 *) &smjs_globhist_item_class, NULL)) return JS_FALSE; history_item = JS_GetInstancePrivate(ctx, obj, (JSClass *) &smjs_globhist_item_class, NULL); if (!history_item) return JS_FALSE; if (!JSID_IS_INT(id)) return JS_FALSE; switch (JSID_TO_INT(id)) { case GLOBHIST_TITLE: { JSString *jsstr = JS_ValueToString(smjs_ctx, *vp); unsigned char *str = JS_EncodeString(smjs_ctx, jsstr); mem_free_set(&history_item->title, stracpy(str)); return JS_TRUE; } case GLOBHIST_URL: { JSString *jsstr = JS_ValueToString(smjs_ctx, *vp); unsigned char *str = JS_EncodeString(smjs_ctx, jsstr); mem_free_set(&history_item->url, stracpy(str)); return JS_TRUE; } case GLOBHIST_LAST_VISIT: { uint32 seconds; /* Bug 923: Assumes time_t values fit in uint32. */ JS_ValueToECMAUint32(smjs_ctx, *vp, &seconds); history_item->last_visit = seconds; return JS_TRUE; } 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. */ return JS_TRUE; } }
static struct connection_state init_nntp_header(struct connection *conn, struct read_buffer *rb) { struct nntp_connection_info *nntp = conn->info; if (!conn->cached) { conn->cached = get_cache_entry(conn->uri); if (!conn->cached) return connection_state(S_OUT_OF_MEM); } else if (conn->cached->head || conn->cached->content_type) { /* If the head is set wipe out the content to be sure */ delete_entry_content(conn->cached); mem_free_set(&conn->cached->head, NULL); } /* XXX: Override any Content-Type line in the header */ mem_free_set(&conn->cached->content_type, stracpy("text/html")); if (!conn->cached->content_type) return connection_state(S_OUT_OF_MEM); switch (nntp->target) { case NNTP_TARGET_ARTICLE_NUMBER: case NNTP_TARGET_MESSAGE_ID: case NNTP_TARGET_GROUP_MESSAGE_ID: { unsigned char *end; end = get_nntp_message_header_end(rb->data, rb->length); if (!end) { /* Redo the whole cache entry thing next time */ return connection_state(S_TRANS); } /* FIXME: Add the NNTP response code line */ conn->cached->head = stracpy("FIXME NNTP response code\r\n"); if (!conn->cached->head) return connection_state(S_OUT_OF_MEM); add_to_strn(&conn->cached->head, rb->data); /* ... and remove it */ conn->received += end - rb->data; kill_buffer_data(rb, end - rb->data); break; } case NNTP_TARGET_ARTICLE_RANGE: case NNTP_TARGET_GROUP: case NNTP_TARGET_GROUPS: case NNTP_TARGET_QUIT: break; } return connection_state(S_OK); }
static inline void do_script_hook_follow_url(unsigned char **url) { int count; dSP; /* Keep in variables declaration block. */ ENTER; SAVETMPS; PUSHMARK(SP); my_XPUSHs(*url, strlen((const char *)*url)); PUTBACK; count = call_pv("follow_url_hook", G_EVAL | G_SCALAR); if (SvTRUE(ERRSV)) count = 0; /* FIXME: error message ? */ SPAGAIN; if (count == 1) { #ifndef CONFIG_PERL_POPPX_WITHOUT_N_A STRLEN n_a; /* Used by POPpx macro. */ #endif unsigned char *new_url = POPpx; if (new_url) { unsigned char *n = stracpy(new_url); if (n) { mem_free_set(url, n); } } } PUTBACK; FREETMPS; LEAVE; }
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)); }
void html_source(struct html_context *html_context, unsigned char *a, unsigned char *xxx3, unsigned char *xxx4, unsigned char **xxx5) { unsigned char *src, *title; struct document_options *options = html_context->options; int display_style = options->image_link.display_style; src = get_url_val(a, "src", html_context->doc_cp); if (!src) return; title = get_attr_val(a, "title", html_context->doc_cp); if (!title || !*title) { if (display_style == 3) { mem_free_set(&title, get_image_filename_from_src(options->image_link.filename_maxlen, src)); } } html_focusable(html_context, a); if (title && *title) { put_link_line("Source: ", title, src, html_context->options->framename, html_context); } else { put_link_line("", "Source", src, html_context->options->framename, html_context); } mem_free_if(title); mem_free(src); }
/** Convert a jsval to a string and store it in struct bookmark. * * @param ctx * Context for memory allocations and error reports. * @param val * The @c jsval that should be converted. * @param[in,out] result * A string allocated with mem_alloc(). * On success, this function frees the original string, if any. * * @return JS_TRUE if successful. On error, report the error to * SpiderMonkey and return JS_FALSE. */ static JSBool jsval_to_bookmark_string(JSContext *ctx, jsid id, unsigned char **result) { JSString *jsstr = NULL; unsigned char *str; jsval val; /* jsstring_to_utf8() might GC; protect the string to come. */ if (!JS_AddNamedStringRoot(ctx, &jsstr, "jsval_to_bookmark_string")) return JS_FALSE; if (JS_TRUE != JS_IdToValue(ctx, id, &val)) { JS_RemoveStringRoot(ctx, &jsstr); return JS_FALSE; } jsstr = JS_ValueToString(ctx, val); if (jsstr == NULL) { JS_RemoveStringRoot(ctx, &jsstr); return JS_FALSE; } str = jsstring_to_utf8(ctx, jsstr, NULL); if (str == NULL) { JS_RemoveStringRoot(ctx, &jsstr); return JS_FALSE; } JS_RemoveStringRoot(ctx, &jsstr); mem_free_set(result, str); return JS_TRUE; }
void html_hr(struct html_context *html_context, unsigned char *a, unsigned char *html, unsigned char *eof, unsigned char **end) { int i/* = par_format.width - 10*/; unsigned char r = (unsigned char) BORDER_DHLINE; int q = get_num(a, (unsigned char *)"size", html_context->doc_cp); if (q >= 0 && q < 2) r = (unsigned char) BORDER_SHLINE; html_stack_dup(html_context, ELEMENT_KILLABLE); par_format.align = ALIGN_CENTER; mem_free_set(&format.link, NULL); format.form = NULL; html_linebrk(html_context, a, html, eof, end); if (par_format.align == ALIGN_JUSTIFY) par_format.align = ALIGN_CENTER; par_format.leftmargin = par_format.rightmargin = html_context->margin; i = get_width(a, (unsigned char *)"width", 1, html_context); if (i == -1) i = get_html_max_width(); format.style.attr = AT_GRAPHICS; html_context->special_f(html_context, SP_NOWRAP, 1); while (i-- > 0) { put_chrs(html_context, &r, 1); } html_context->special_f(html_context, SP_NOWRAP, 0); ln_break(html_context, 2); pop_html_element(html_context); }
void done_socket(struct socket *socket) { struct socket_weak_ref *ref; close_socket(socket); if (socket->connect_info) done_connection_info(socket); mem_free_set(&socket->read_buffer, NULL); mem_free_set(&socket->write_buffer, NULL); foreach(ref, socket_weak_refs) { if (ref->socket == socket) ref->socket = NULL; } }
static void free_mark_by_index(int i) { assert(is_valid_mark_index(i)); if (!marks[i]) return; destroy_vs(marks[i], 1); mem_free_set(&marks[i], NULL); }
static widget_handler_status_T set_cookie_domain(struct dialog_data *dlg_data, struct widget_data *widget_data) { struct cookie *cookie = (struct cookie *)dlg_data->dlg->udata; unsigned char *value = widget_data->cdata; if (!value || !cookie) return EVENT_NOT_PROCESSED; mem_free_set(&cookie->domain, stracpy(value)); set_cookies_dirty(); return EVENT_PROCESSED; }
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)); }
static void done_connection_info(struct socket *socket) { struct connect_info *connect_info = socket->connect_info; assert(socket->connect_info); if (connect_info->dnsquery) kill_dns_request(&connect_info->dnsquery); mem_free_if(connect_info->addr); done_uri(connect_info->uri); mem_free_set(&socket->connect_info, NULL); }
static void free_task(struct session *ses) { assertm(ses->task.type, "Session has no task"); if_assert_failed return; if (ses->loading_uri) { done_uri(ses->loading_uri); ses->loading_uri = NULL; } ses->task.type = TASK_NONE; mem_free_set(&ses->task.target.frame, NULL); }
/* prefix can have entities in it, but linkname cannot. */ void put_link_line(unsigned char *prefix, unsigned char *linkname, unsigned char *link, unsigned char *target, struct html_context *html_context) { html_context->has_link_lines = 1; html_stack_dup(html_context, ELEMENT_KILLABLE); ln_break(html_context, 1); mem_free_set(&format.link, NULL); mem_free_set(&format.target, NULL); mem_free_set(&format.title, NULL); format.form = NULL; put_chrs(html_context, prefix, strlen((const char *)prefix)); format.link = join_urls(html_context->base_href, link); format.target = stracpy(target); format.style.color.foreground = format.color.clink; /* linkname typically comes from get_attr_val, which * has already expanded character entity references. * Tell put_chrs not to expand them again. */ format.style.attr |= AT_NO_ENTITIES; put_chrs(html_context, linkname, strlen((const char *)linkname)); ln_break(html_context, 1); pop_html_element(html_context); }
static void do_html_select_multiple(struct html_context *html_context, unsigned char *a, unsigned char *html, unsigned char *eof, unsigned char **end) { unsigned char *al = get_attr_val(a, (unsigned char *)"name", html_context->doc_cp); if (!al) return; html_focusable(html_context, a); html_top->type = ELEMENT_DONT_KILL; mem_free_set(&format.select, al); format.select_disabled = has_attr(a, (unsigned char *)"disabled", html_context->doc_cp) ? FORM_MODE_DISABLED : FORM_MODE_NORMAL; }
void ses_load(struct session *ses, struct uri *uri, unsigned char *target_frame, struct location *target_location, enum cache_mode cache_mode, enum task_type task_type) { ses->loading.callback = (download_callback_T *) loading_callback; ses->loading.data = ses; ses->loading_uri = uri; ses->task.type = task_type; mem_free_set(&ses->task.target.frame, null_or_stracpy(target_frame)); ses->task.target.location = target_location; load_uri(ses->loading_uri, ses->referrer, &ses->loading, PRI_MAIN, cache_mode, -1); }
static enum evhook_status script_hook_goto_url(va_list ap, void *data) { unsigned char **url = va_arg(ap, unsigned char **); struct session *ses = va_arg(ap, struct session *); int error; VALUE args[2]; VALUE result; if (*url == NULL) return EVENT_HOOK_STATUS_NEXT; args[0] = rb_str_new(*url, strlen((const char *)*url)); if (!ses || !have_location(ses)) { args[1] = Qnil; } else { args[1] = rb_str_new(struri(cur_loc(ses)->vs.uri), strlen((const char *)struri(cur_loc(ses)->vs.uri))); } result = erb_protected_method_call("goto_url_hook", 2, args, &error); if (error) { erb_report_error(ses, error); return EVENT_HOOK_STATUS_NEXT; } switch (rb_type(result)) { case T_STRING: { unsigned char *new_url; new_url = memacpy(RSTRING(result)->ptr, RSTRING(result)->len); if (new_url) { mem_free_set(url, new_url); } break; } case T_NIL: break; default: alert_ruby_error(ses, "goto_url_hook must return a string or nil"); } return EVENT_HOOK_STATUS_NEXT; }
static void free_itrm(struct itrm *itrm) { if (!itrm) return; if (!itrm->remote) { if (itrm->orig_title && *itrm->orig_title) { set_window_title(itrm->orig_title, itrm->title_codepage); } else if (itrm->touched_title) { /* Set the window title to the value of $TERM if X11 * wasn't compiled in. Should hopefully make at least * half the users happy. (debian bug #312955) */ unsigned char title[MAX_TERM_LEN]; get_terminal_name(title); if (*title) set_window_title(title, get_cp_index("US-ASCII")); } unhandle_terminal_resize(itrm->in.ctl); #ifdef CONFIG_MOUSE disable_mouse(); #endif send_done_sequence(itrm->out.std, itrm->altscreen); tcsetattr(itrm->in.ctl, TCSANOW, &itrm->t); } mem_free_set(&itrm->orig_title, NULL); /* elinks -remote may not have a valid stdin if not run from a tty (bug 938) */ if (!itrm->remote || itrm->in.std >= 0) clear_handlers(itrm->in.std); clear_handlers(itrm->in.sock); clear_handlers(itrm->out.std); clear_handlers(itrm->out.sock); kill_timer(&itrm->timer); if (itrm == ditrm) ditrm = NULL; mem_free_if(itrm->out.queue.data); mem_free_if(itrm->in.queue.data); mem_free(itrm); }
/** Free all resources owned by *@a http_post, but do not free the * structure itself. It is safe to call this multiple times. * * @relates http_post */ void done_http_post(struct http_post *http_post) { size_t i; http_post->total_upload_length = 0; http_post->uploaded = 0; http_post->post_data = NULL; if (http_post->post_fd != -1) { close(http_post->post_fd); http_post->post_fd = -1; } for (i = 0; i < http_post->file_count; i++) mem_free(http_post->files[i].name); http_post->file_index = 0; http_post->file_count = 0; http_post->file_read = 0; mem_free_set(&http_post->files, NULL); }
static inline void compress_node(struct ff_node *leafset, struct fastfind_info *info, int i, int pos) { struct ff_node_c *new_ = mem_alloc(sizeof(*new_)); if (!new_) return; new_->c = 1; new_->e = leafset[pos].e; new_->p = leafset[pos].p; new_->l = leafset[pos].l; new_->ch = pos; mem_free_set(&info->leafsets[i], (struct ff_node *) new_); FF_DBG_cnode(info); FF_DBG_mem(info, sizeof(*new_)); FF_DBG_mem(info, sizeof(*leafset) * -info->uniq_chars_count); }
static inline void do_script_hook_goto_url(struct session *ses, unsigned char **url) { int count; dSP; /* Keep in variables declaration block. */ ENTER; SAVETMPS; PUSHMARK(SP); my_XPUSHs(*url, strlen((const char *)*url)); if (!ses || !have_location(ses)) { XPUSHs(sv_2mortal(newSV(0))); } else { unsigned char *uri = struri(cur_loc(ses)->vs.uri); my_XPUSHs(uri, strlen((const char *)uri)); } PUTBACK; count = call_pv("goto_url_hook", G_EVAL | G_SCALAR); if (SvTRUE(ERRSV)) count = 0; /* FIXME: error message ? */ SPAGAIN; if (count == 1) { #ifndef CONFIG_PERL_POPPX_WITHOUT_N_A STRLEN n_a; /* Used by POPpx macro. */ #endif unsigned char *new_url = POPpx; if (new_url) { unsigned char *n = stracpy(new_url); if (n) { mem_free_set(url, n); } } } PUTBACK; FREETMPS; LEAVE; }
static enum evhook_status script_hook_follow_url(va_list ap, void *data) { unsigned char **url = va_arg(ap, unsigned char **); struct session *ses = va_arg(ap, struct session *); int error; VALUE args[1]; VALUE result; evhook_use_params(url && ses); if (*url == NULL) return EVENT_HOOK_STATUS_NEXT; args[0] = rb_str_new(*url, strlen((const char *)*url)); result = erb_protected_method_call("follow_url_hook", 1, args, &error); if (error) { erb_report_error(ses, error); return EVENT_HOOK_STATUS_NEXT; } switch (rb_type(result)) { case T_STRING: { unsigned char *new_url; new_url = memacpy(RSTRING(result)->ptr, RSTRING(result)->len); if (new_url) { mem_free_set(url, new_url); } break; } case T_NIL: break; default: alert_ruby_error(ses, "follow_url_hook must return a string or nil"); } return EVENT_HOOK_STATUS_NEXT; }
static unsigned char * init_data_protocol_header(struct cache_entry *cached, unsigned char *type, int typelen) { unsigned char *head; assert(typelen); type = memacpy(type, typelen); if (!type) return NULL; /* Set fake content type */ head = straconcat((const unsigned char *)"\r\nContent-Type: ", type, "\r\n", (unsigned char *) NULL); mem_free(type); if (!head) return NULL; mem_free_set(&cached->head, head); return head; }
void abort_preloading(struct session *ses, int interrupt) { if (!ses->task.type) { /* ses->task.target.frame must be freed in the * destroy_session() => abort_loading() => * abort_preloading() call chain. Normally, * free_task() called from here would do that, * but if the task has no type, free_task() * cannot be called because an assertion would * fail. There are several functions that set * ses->task.target.frame without ses->task.type, * so apparently it is allowed. */ mem_free_set(&ses->task.target.frame, NULL); return; } cancel_download(&ses->loading, interrupt); free_task(ses); }
/* The Ruby function can return: * - "PROXY:PORT" to use the specified proxy * - "" to not use any proxy * - nil to use the default proxies */ static enum evhook_status script_hook_get_proxy(va_list ap, void *data) { unsigned char **new_proxy_url = va_arg(ap, unsigned char **); unsigned char *url = va_arg(ap, unsigned char *); int error; VALUE args[1]; VALUE result; if (!new_proxy_url || !url) return EVENT_HOOK_STATUS_NEXT; args[0] = rb_str_new(url, strlen((const char *)url)); result = erb_protected_method_call("proxy_hook", 1, args, &error); if (error) { erb_report_error(NULL, error); return EVENT_HOOK_STATUS_NEXT; } switch (rb_type(result)) { case T_STRING: { unsigned char *proxy; proxy = memacpy(RSTRING(result)->ptr, RSTRING(result)->len); if (proxy) { mem_free_set(new_proxy_url, proxy); } break; } case T_NIL: break; default: alert_ruby_error(NULL, "proxy_hook must return a string or nil"); } return EVENT_HOOK_STATUS_NEXT; }
void html_base(struct html_context *html_context, unsigned char *a, unsigned char *xxx3, unsigned char *xxx4, unsigned char **xxx5) { unsigned char *al; al = get_url_val(a, (unsigned char *)"href", html_context->doc_cp); if (al) { unsigned char *base = join_urls(html_context->base_href, al); struct uri *uri = base ? get_uri(base, 0) : NULL; mem_free(al); mem_free_if(base); if (uri) { done_uri(html_context->base_href); html_context->base_href = uri; } } al = get_target(html_context->options, a); if (al) mem_free_set(&html_context->base_target, al); }