/* process the codebase, archive, and code attributes of an APPLET tag.
*/
static CRAWL_TagError
crawl_addPageApplet(CRAWL_PageInfo pageInfo, char *codebase, char *archive, char *code) {
char *fullCodebase;
if (codebase != NULL) {
fullCodebase = crawl_makeAbsoluteURL(pageInfo, codebase);
if (fullCodebase == NULL) return(CRAWL_TAG_NO_MEMORY);
}
if (archive != NULL) {
char *fullArchive;
if (fullCodebase != NULL) {
fullArchive = NET_MakeAbsoluteURL(fullCodebase, archive);
} else {
fullArchive = crawl_makeAbsoluteURL(pageInfo, archive);
}
if (fullArchive == NULL) return(CRAWL_TAG_NO_MEMORY);
if (crawl_addPageResource(pageInfo, fullArchive) == CRAWL_TAG_NO_MEMORY) return(CRAWL_TAG_NO_MEMORY);
}
if (code != NULL) {
char *fullCode;
/* FIXME can code still be specified with fully qualified package names? */
if (fullCodebase != NULL) fullCode = NET_MakeAbsoluteURL(fullCodebase, code);
else fullCode = crawl_makeAbsoluteURL(pageInfo, code);
if (fullCode == NULL) return(CRAWL_TAG_NO_MEMORY);
if (crawl_addPageResource(pageInfo, fullCode) == CRAWL_TAG_NO_MEMORY) return(CRAWL_TAG_NO_MEMORY);
} else return(CRAWL_TAG_SYNTAX_ERR);
return(CRAWL_TAG_NO_ERR);
}
CRAWL_PageInfo crawl_makePage(char *siteURL, char *pageURL, ExtCacheDBInfo *cache) {
CRAWL_PageInfo pageInfo = PR_NEWZAP(CRAWL_PageInfoStruct);
if (pageInfo == NULL) return NULL;
pageInfo->url = pageURL;
pageInfo->siteURL = siteURL;
pageInfo->url = NET_MakeAbsoluteURL(siteURL, pageURL); /* complete a partial url if necessary */
if (pageInfo->url != NULL) {
pageInfo->url_s = NET_CreateURLStruct(pageInfo->url, NET_NORMAL_RELOAD); /* freed in the exit function */
if (pageInfo->url_s != NULL) {
pageInfo->url_s->load_background = PR_TRUE;
pageInfo->url_s->SARCache = cache;
pageInfo->url_s->owner_data = pageInfo; /* so we can recover the CRAWL_PageInfo in the converter */
} else {
PR_Free(pageInfo->url);
PR_Free(pageInfo);
return NULL;
}
} else {
PR_Free(pageInfo);
return NULL;
}
return pageInfo;
}
/*
* This is an AREA tag. Create the structure, fill it in based on the
* attributes passed, and add it to the map record for the current
* MAP tag.
*/
void
lo_BeginMapArea(MWContext *context, lo_DocState *state, PA_Tag *tag)
{
PA_Block buff;
char *str;
lo_MapRec *map;
lo_MapAreaRec *area;
lo_DocLists *doc_lists;
doc_lists = lo_GetCurrentDocLists(state);
/*
* Get the current map, if there is none, error out.
*/
map = state->top_state->current_map;
if (map == NULL)
{
return;
}
area = XP_NEW(lo_MapAreaRec);
if (area == NULL)
{
state->top_state->out_of_memory = TRUE;
return;
}
area->type = AREA_SHAPE_RECT;
area->coords = NULL;
area->coord_cnt = 0;
area->anchor = NULL;
area->alt = NULL;
area->alt_len = 0;
area->next = NULL;
buff = lo_FetchParamValue(context, tag, PARAM_SHAPE);
if (buff != NULL)
{
PA_LOCK(str, char *, buff);
if (pa_TagEqual(S_AREA_SHAPE_RECT, str))
{
area->type = AREA_SHAPE_RECT;
}
else if (pa_TagEqual(S_AREA_SHAPE_CIRCLE, str))
{
area->type = AREA_SHAPE_CIRCLE;
}
else if (pa_TagEqual(S_AREA_SHAPE_POLY, str))
{
area->type = AREA_SHAPE_POLY;
}
else if (pa_TagEqual(S_AREA_SHAPE_POLYGON, str))
{
area->type = AREA_SHAPE_POLY;
}
else if (pa_TagEqual(S_AREA_SHAPE_DEFAULT, str))
{
area->type = AREA_SHAPE_DEFAULT;
}
else
{
area->type = AREA_SHAPE_UNKNOWN;
}
PA_UNLOCK(buff);
PA_FREE(buff);
}
/*
* Get the alt parameter, and store the resulting
* text, and its length.
*/
buff = lo_FetchParamValue(context, tag, PARAM_ALT);
if (buff != NULL)
{
PA_LOCK(str, char *, buff);
area->alt_len = XP_STRLEN(str);
area->alt_len = (int16)lo_StripTextNewlines(str,
(int32)area->alt_len);
PA_UNLOCK(buff);
}
area->alt = buff;
/*
* Parse the comma separated coordinate list into an
* array of integers.
*/
buff = lo_FetchParamValue(context, tag, PARAM_COORDS);
if (buff != NULL)
{
int32 cnt;
Bool must_be_odd;
must_be_odd = FALSE;
if (area->type == AREA_SHAPE_POLY)
{
must_be_odd = TRUE;
}
PA_LOCK(str, char *, buff);
area->coords = lo_parse_coord_list(str, &cnt, must_be_odd);
if (area->coords != NULL)
{
area->coord_cnt = cnt;
}
PA_UNLOCK(buff);
PA_FREE(buff);
}
/*
* Get the HREF, and if one exists, get the TARGET to go along
* with it.
*/
buff = lo_FetchParamValue(context, tag, PARAM_HREF);
if (buff != NULL)
{
char *target;
PA_Block targ_buff;
PA_Block href_buff;
LO_AnchorData *anchor;
anchor = NULL;
PA_LOCK(str, char *, buff);
if (str != NULL)
{
int32 len;
len = lo_StripTextWhitespace(str, XP_STRLEN(str));
}
str = NET_MakeAbsoluteURL(state->top_state->base_url, str);
if (str == NULL)
{
href_buff = NULL;
}
else
{
href_buff = PA_ALLOC(XP_STRLEN(str) + 1);
if (href_buff != NULL)
{
char *full_url;
PA_LOCK(full_url, char *, href_buff);
XP_STRCPY(full_url, str);
PA_UNLOCK(href_buff);
}
else
{
state->top_state->out_of_memory = TRUE;
}
XP_FREE(str);
}
PA_UNLOCK(buff);
PA_FREE(buff);
if (href_buff != NULL)
{
targ_buff = lo_FetchParamValue(context, tag, PARAM_TARGET);
if (targ_buff != NULL)
{
int32 len;
PA_LOCK(target, char *, targ_buff);
len = lo_StripTextWhitespace(target,
XP_STRLEN(target));
if ((*target == '\0')||
(lo_IsValidTarget(target) == FALSE))
{
PA_UNLOCK(targ_buff);
PA_FREE(targ_buff);
targ_buff = NULL;
}
else
{
PA_UNLOCK(targ_buff);
}
}
/*
* If there was no target use the default one.
* (default provided by BASE tag)
*/
if ((targ_buff == NULL)&&
(state->top_state->base_target != NULL))
{
targ_buff = PA_ALLOC(XP_STRLEN(
state->top_state->base_target) + 1);
if (targ_buff != NULL)
{
char *targ;
PA_LOCK(targ, char *, targ_buff);
XP_STRCPY(targ,
state->top_state->base_target);
PA_UNLOCK(targ_buff);
}
else
{
state->top_state->out_of_memory = TRUE;
}
}
anchor = lo_NewAnchor(state, href_buff, targ_buff);
if (anchor == NULL)
{
PA_FREE(href_buff);
if (targ_buff != NULL)
{
PA_FREE(targ_buff);
}
}
/*
* If the AREA tag has an ALT attribute,
* stick that text into the anchor data.
*/
else if (area->alt != NULL)
{
PA_Block alt_buff;
char *alt_text;
PA_LOCK(alt_text, char *, area->alt);
alt_buff = PA_ALLOC(area->alt_len + 1);
if (alt_buff != NULL)
{
char *new_alt;
PA_LOCK(new_alt, char *, alt_buff);
XP_STRCPY(new_alt, alt_text);
PA_UNLOCK(alt_buff);
}
PA_UNLOCK(area->alt);
anchor->alt = alt_buff;
}
/*
Process a tag, adding urls to the lists of links, images, or resources.
The parser calls this routine whenever a tag or between-tag data has been read.
*/
int crawl_processToken(CRAWL_ParseObj obj, PRBool isTag, void *data) {
CRAWL_TagError err = CRAWL_TAG_NO_ERR;
CRAWL_PageInfo page = (CRAWL_PageInfo)data;
if (isTag) {
CRAWL_Tag tag = CRAWL_GetTagParsed(obj);
char *name = CRAWL_GetTagName(tag);
char *att1, *att2, *att3;
if (CRAWL_IsEndTag(tag)) return PARSE_GET_NEXT_TOKEN;
switch (CRAWL_GetTagToken(tag)) {
case P_ANCHOR:
att1 = CRAWL_GetAttributeValue(tag, PARAM_HREF); /* <A HREF=?> */
if (att1 != NULL) err = crawl_processURL(page, att1, LINK_CONTEXT_HREF);
break;
case P_AREA:
att1 = CRAWL_GetAttributeValue(tag, PARAM_HREF); /* <AREA HREF=?> */
if (att1 != NULL) err = crawl_processURL(page, att1, LINK_CONTEXT_HREF);
break;
case P_BASE:
att1 = CRAWL_GetAttributeValue(tag, PARAM_HREF);
if (att1 != NULL) {
page->baseURL = NET_MakeAbsoluteURL(page->url_s->address, att1); /* XP_STRDUP(att1); */
if (page->baseURL == NULL) err = CRAWL_TAG_NO_MEMORY;
}
break;
case P_IMAGE:
att1 = CRAWL_GetAttributeValue(tag, PARAM_SRC); /* <IMG SRC=?> */
if (att1 != NULL) err = crawl_addPageImage(page, att1);
break;
case P_BODY:
att1 = CRAWL_GetAttributeValue(tag, PARAM_BACKGROUND); /* <BODY BACKGROUND=?> */
if (att1 != NULL) err = crawl_addPageImage(page, att1);
break;
case P_GRID_CELL:
att1 = CRAWL_GetAttributeValue(tag, PARAM_SRC); /* <FRAME SRC=?> */
if (att1 != NULL) err = crawl_processURL(page, att1, LINK_CONTEXT_FRAME);
break;
case P_LAYER:
att1 = CRAWL_GetAttributeValue(tag, PARAM_SRC); /* <LAYER SRC=?> */
if (att1 != NULL) err = crawl_processURL(page, att1, LINK_CONTEXT_LAYER);
att2 = CRAWL_GetAttributeValue(tag, "background"); /* <LAYER BACKGROUND=?> */
if ((att2 != NULL) && (err == CRAWL_TAG_NO_ERR)) err = crawl_addPageImage(page, att2);
break;
case P_EMBED:
att1 = CRAWL_GetAttributeValue(tag, PARAM_SRC); /* <EMBED SRC=?> */
if (att1 != NULL) err = crawl_addPageResource(page, att1);
break;
case P_SCRIPT:
att1 = CRAWL_GetAttributeValue(tag, PARAM_ARCHIVE);
if (att1 != NULL) err = crawl_addPageRequiredResource(page, att1);
att2 = CRAWL_GetAttributeValue(tag, PARAM_SRC);
if ((att2 != NULL) && (err == CRAWL_TAG_NO_ERR)) err = crawl_addPageRequiredResource(page, att2);
break;
case P_JAVA_APPLET:
att1 = CRAWL_GetAttributeValue(tag, PARAM_CODEBASE);
att2 = CRAWL_GetAttributeValue(tag, PARAM_ARCHIVE);
att3 = CRAWL_GetAttributeValue(tag, PARAM_CODE);
err = crawl_addPageApplet(page, att1, att2, att3);
break;
case P_META:
att1 = CRAWL_GetAttributeValue(tag, PARAM_HTTP_EQUIV);
if ((att1 != NULL) && (XP_STRCASECMP(att1, "refresh") == 0)) {
att2 = CRAWL_GetAttributeValue(tag, PARAM_CONTENT);
if (att2 != NULL) err = crawl_addPageMetaRefresh(page, att2);
} else {
/* robots meta tag: we take NOINDEX to mean don't cache (the document is already
cached so we need to remove it from the cache. NOFOLLOW means don't follow the
links, which we'll do by aborting the parsing of this page.
See http://info.webcrawler.com/mak/projects/robots/exclusion.html
*/
att1 = CRAWL_GetAttributeValue(tag, PARAM_NAME);
if ((att1 != NULL) && (XP_STRCASECMP(att1, "robots") == 0)) {
att2 = CRAWL_GetAttributeValue(tag, PARAM_CONTENT);
if (att2 != NULL) {
if (XP_STRCASESTR(att2, "noindex")) {
page->dontIndex = PR_TRUE;
}
if (XP_STRCASESTR(att2, "nofollow")) {
page->dontFollow = PR_TRUE;
return PARSE_STOP;
}
}
}
}
break;
case P_LINK:
att1 = CRAWL_GetAttributeValue(tag, PARAM_REL);
if ((att1 != NULL) && (XP_STRCASECMP(att1, "stylesheet") == 0)) {
att2 = CRAWL_GetAttributeValue(tag, PARAM_HREF);
if (att2 != NULL) {
att3 = CRAWL_GetAttributeValue(tag, PARAM_TYPE);
if ((att3 != NULL) && ((XP_STRCASECMP(att3, "text/javascript") == 0) || (XP_STRCASECMP(att3, "text/css") == 0))) {
err = crawl_addPageRequiredResource(page, att2);
} else err = crawl_addPageResource(page, att2);
}
}
break;
case P_STYLE:
att1 = CRAWL_GetAttributeValue(tag, PARAM_SRC);
if (att1 != NULL) {
att2 = CRAWL_GetAttributeValue(tag, PARAM_TYPE);
if ((att2 != NULL) && ((XP_STRCASECMP(att2, "text/javascript") == 0) || (XP_STRCASECMP(att2, "text/css") == 0))) {
err = crawl_addPageRequiredResource(page, att1);
} else err = crawl_addPageResource(page, att1);
}
break;
default:
break;
}
}
if (err == CRAWL_TAG_NO_MEMORY) return PARSE_OUT_OF_MEMORY;
else return PARSE_GET_NEXT_TOKEN;
}
/*
makes an absolute URL from relURL using the base url if it exists, otherwise uses the
page's url as a base.
*/
static char*
crawl_makeAbsoluteURL(CRAWL_PageInfo pageInfo, char *relURL) {
if ((pageInfo->baseURL != NULL) && (*pageInfo->baseURL != '\0'))
return NET_MakeAbsoluteURL(pageInfo->baseURL, relURL);
else return NET_MakeAbsoluteURL(pageInfo->url_s->address, relURL);
}
void
lo_ProcessScriptTag(MWContext *context, lo_DocState *state, PA_Tag *tag, JSObject *obj)
{
lo_TopState *top_state;
pa_DocData *doc_data;
XP_Bool type_explicitly_set=FALSE;
XP_Bool saw_archive=FALSE;
#ifdef DEBUG_ScriptPlugin
char * mimebuf = NULL;
#endif
top_state = state->top_state;
doc_data = (pa_DocData *)top_state->doc_data;
XP_ASSERT(doc_data != NULL || state->in_relayout || tag->lo_data);
if (tag->is_end == FALSE) {
PA_Block buff;
char *str, *url, *archiveSrc, *id, *codebase;
/* Controversial default language value. */
top_state->version = JSVERSION_DEFAULT;
if (tag->type == P_STYLE || tag->type == P_LINK) {
top_state->in_script = top_state->default_style_script_type;
}
else {
/* in order to get old script behaviour, pretend
* that the content-type is explicitly set for all scripts
*/
type_explicitly_set = TRUE;
top_state->in_script = SCRIPT_TYPE_MOCHA;
}
/* XXX account for HTML comment bytes and "lost" newlines */
if (lo_IsAnyCurrentAncestorSourced(state))
top_state->script_bytes = top_state->layout_bytes;
else
top_state->script_bytes = top_state->layout_bytes - tag->true_len;
if (tag->lo_data != NULL) {
top_state->script_bytes += (int32)tag->lo_data - 1;
tag->lo_data = NULL;
}
else if (doc_data != NULL) {
top_state->script_bytes += doc_data->comment_bytes;
}
else {
XP_ASSERT(state->in_relayout);
}
lo_ParseScriptLanguage(context, tag, &top_state->in_script,
&top_state->version);
#ifdef DEBUG_ScriptPlugin
if (top_state->in_script == SCRIPT_TYPE_UNKNOWN)
{
mimebuf = npl_Script2mimeType(context,tag);
if (mimebuf){
if (NPL_FindPluginEnabledForType(mimebuf)){
top_state->in_script = SCRIPT_TYPE_PLUGIN;
XP_ASSERT(top_state->mimetype == NULL);
StrAllocCopy((char *)top_state->mimetype,mimebuf);
XP_FREE(mimebuf);
mimebuf = NULL;
}
else{
XP_FREE(mimebuf);
mimebuf = NULL;
}
}
}
#endif /* DEBUG_ScriptPlugin */
buff = lo_FetchParamValue(context, tag, PARAM_TYPE);
if (buff != NULL) {
PA_LOCK(str, char *, buff);
if ((XP_STRCASECMP(str, js_content_type) == 0) ||
(!XP_STRCASECMP(str, "text/javascript"))) {
if(tag->type == P_STYLE || tag->type == P_LINK)
{
top_state->in_script = SCRIPT_TYPE_JSSS;
top_state->default_style_script_type = SCRIPT_TYPE_JSSS;
}
else
{
top_state->in_script = SCRIPT_TYPE_MOCHA;
}
type_explicitly_set = TRUE;
}
else if ((XP_STRCASECMP(str, TEXT_CSS) == 0)) {
top_state->in_script = SCRIPT_TYPE_CSS;
top_state->default_style_script_type = SCRIPT_TYPE_CSS;
type_explicitly_set = TRUE;
}
else {
top_state->in_script = SCRIPT_TYPE_UNKNOWN;
top_state->default_style_script_type = SCRIPT_TYPE_UNKNOWN;
}
PA_UNLOCK(buff);
PA_FREE(buff);
}
/* check for media=screen
* don't load the style sheet if there
* is a media not equal to screen
*/
buff = lo_FetchParamValue(context, tag, PARAM_MEDIA);
if (buff) {
if (strcasecomp((char*)buff, "screen")) {
/* set the script type to UNKNOWN
* so that it will get thrown away
*/
top_state->in_script = SCRIPT_TYPE_UNKNOWN;
}
PA_FREE(buff);
}
/*
* Flush the line buffer so we can start storing Mocha script
* source lines in there.
*/
lo_FlushLineBuffer(context, state);
url = archiveSrc = id = codebase = NULL;
if (top_state->in_script != SCRIPT_TYPE_NOT) {
/*
* Check for the archive parameter for known languages.
*/
buff = lo_FetchParamValue(context, tag, PARAM_ARCHIVE);
if (buff != NULL) {
saw_archive = TRUE;
PA_LOCK(str, char *, buff);
url = NET_MakeAbsoluteURL(top_state->base_url, str);
PA_UNLOCK(buff);
PA_FREE(buff);
if (url == NULL) {
top_state->out_of_memory = TRUE;
return;
}
}
/*
* Look for ID attribute. If it's there we have may have
* an inline signed script.
*/
buff = lo_FetchParamValue(context, tag, PARAM_ID);
if (buff != NULL) {
PA_LOCK(str, char *, buff);
StrAllocCopy(id, str);
PA_UNLOCK(buff);
PA_FREE(buff);
if (id == NULL) {
top_state->out_of_memory = TRUE;
XP_FREEIF(url);
return;
}
}
/*
* Now look for a SRC="url" attribute for known languages.
* If found, synchronously load the url.
*/
buff = lo_FetchParamValue(context, tag, PARAM_SRC); /* XXX overloaded rv */
if (buff != NULL) {
XP_Bool allowFileSrc = FALSE;
char *absUrl;
PA_LOCK(str, char *, buff);
PREF_GetBoolPref(lo_jsAllowFileSrcFromNonFile, &allowFileSrc);
absUrl = NET_MakeAbsoluteURL(top_state->base_url, str);
if (absUrl == NULL) {
top_state->out_of_memory = TRUE;
XP_FREEIF(id);
} else if (allowFileSrc == FALSE &&
NET_URL_Type(absUrl) == FILE_TYPE_URL &&
NET_URL_Type(top_state->url) != FILE_TYPE_URL) {
/*
* Deny access from http: to file: via SCRIPT SRC=...
* XXX silently
*/
top_state->in_script = SCRIPT_TYPE_UNKNOWN;
XP_FREE(absUrl);
XP_FREEIF(url);
XP_FREEIF(id);
} else if (url != NULL) {
XP_FREE(absUrl);
StrAllocCopy(archiveSrc, str);
if (archiveSrc == NULL) {
top_state->out_of_memory = TRUE;
XP_FREE(url);
XP_FREEIF(id);
}
} else {
url = absUrl;
}
PA_UNLOCK(buff);
PA_FREE(buff);
if (top_state->out_of_memory)
return;
/*
* If we are doing a <script src=""> mocha script but JS
* is turned off just ignore the tag
*/
if (!LM_CanDoJS(context)) {
top_state->in_script = SCRIPT_TYPE_UNKNOWN;
XP_FREE(url);
XP_FREEIF(id);
XP_FREEIF(archiveSrc);
return;
}
}
}
/*
* Set text_divert so we know to accumulate text in line_buf
* without interpretation.
*/
state->text_divert = tag->type;
/*
* XXX need to stack these to handle blocked SCRIPT tags
*/
top_state->script_lineno = tag->newline_count + 1;
/* if we got here as a result of a LINK tag
* check to make sure rel=stylesheet and then
* check for an HREF and if one does not exist
* fail
*/
if (tag->type == P_LINK) {
char *cbuff = (char*)lo_FetchParamValue(context, tag, PARAM_REL);
if (cbuff && !strcasecomp(cbuff, "stylesheet")) {
XP_FREE(cbuff);
cbuff = (char*)lo_FetchParamValue(context, tag, PARAM_HREF);
if (cbuff) {
if (saw_archive && url) {
archiveSrc = XP_STRDUP(cbuff);
} else {
XP_FREEIF(url);
url = NET_MakeAbsoluteURL(top_state->base_url, cbuff);
}
}
}
XP_FREEIF(cbuff);
}
if (url != NULL || id != NULL || codebase != NULL) {
if ((doc_data != NULL) &&
(state->in_relayout == FALSE) &&
SCRIPT_EXEC_OK(top_state, state, tag->type, P_SCRIPT)) {
ScriptData *data;
data = XP_ALLOC(sizeof(ScriptData));
if (data == NULL) {
top_state->out_of_memory = TRUE;
return;
}
data->context = context;
data->state = state;
data->tag = PA_CloneMDLTag(tag);
if (data->tag == NULL) {
top_state->out_of_memory = TRUE;
XP_FREE(data);
return;
}
data->url = url;
data->archiveSrc = archiveSrc;
data->id = id;
if (codebase == NULL) {
StrAllocCopy(codebase, top_state->base_url);
}
data->codebase = codebase;
data->buffer = NULL;
data->bufferSize = 0;
data->version = top_state->version;
/*
* Only SCRIPT ARCHIVE= ID= without SRC= is an inline signed
* script -- if there is a SRC= attribute, archiveSrc will be
* non-null.
*/
data->inlineSigned = (JSBool)
(url != NULL && archiveSrc == NULL && id != NULL);
/* Reset version accumulator */
top_state->version = JSVERSION_UNKNOWN;
XP_ASSERT (tag->type == P_SCRIPT || tag->type == P_STYLE ||
tag->type == P_LINK);
/*
* Out-of-line included (by src=) or inline signed script.
* Save continuatation data on top_state. If it's signed,
* we'll verify the signature once we see </script> and
* have the inline script to verify.
*/
top_state->scriptData = data;
}
else {
XP_FREE(url);
XP_FREEIF(id);
XP_FREEIF(archiveSrc);
}
}
}
else {
/*
* We are in the </script> tag now...
*/
size_t line_buf_len;
intn script_type;
char *scope_to=NULL;
char *untransformed = NULL;
script_type = top_state->in_script;
top_state->in_script = SCRIPT_TYPE_NOT;
/* guard against superfluous end tags */
if (script_type == SCRIPT_TYPE_NOT)
goto end_tag_out;
/* convert from CSS to JavaScript here */
if (tag->type != P_LINK && script_type == SCRIPT_TYPE_CSS) {
char *new_buffer;
int32 new_buffer_length;
CSS_ConvertToJS((char *)state->line_buf,
state->line_buf_len,
&new_buffer,
&new_buffer_length);
if (!new_buffer) {
/* css translator error, unblock layout and return */
state->text_divert = P_UNKNOWN;
state->line_buf_len = 0; /* clear script text */
goto end_tag_out;
}
untransformed = (char *) state->line_buf;
state->line_buf = (PA_Block) new_buffer;
state->line_buf_len = new_buffer_length;
state->line_buf_size = new_buffer_length;
if (state->line_buf_len)
state->line_buf_len--; /* hack: subtract one to remove final \n */
script_type = SCRIPT_TYPE_JSSS;
}
if (tag->type == P_STYLE) {
/* mocha scoped to document == jsss */
scope_to = "document";
}
/*
* Reset these before potentially recursing indirectly through
* the document.write() built-in function, which writes to the
* very same doc_data->parser_stream that this <SCRIPT> tag
* came in on.
*/
state->text_divert = P_UNKNOWN;
line_buf_len = state->line_buf_len;
state->line_buf_len = 0;
if (script_type != SCRIPT_TYPE_UNKNOWN &&
script_type != SCRIPT_TYPE_NOT) {
/*
* If mocha is disabled or can't be done in this context we
* are going to just ignore the buffer contents
*/
if (!LM_CanDoJS(context)) {
top_state->in_script = SCRIPT_TYPE_UNKNOWN;
goto end_tag_out;
}
if ((doc_data != NULL) &&
(state->in_relayout == FALSE) &&
SCRIPT_EXEC_OK(top_state, state, tag->type, P_SCRIPT)) {
/*
* First off, make sure layout is blocking on us
*/
if (lo_create_script_blockage(context, state,
tag->type == P_SCRIPT ? LO_SCRIPT : LO_UNKNOWN))
{
ScriptData *data;
/*
* Extreme hackery. Hideous and shameful. See the comment
* in lo_BlockScriptTag before similar is_end/overflow code
* and commence vomiting.
*/
lo_BlockScriptTag(context, state, NULL);
if (tag->is_end == (PRPackedBool)1) {
PA_PushOverflow(doc_data);
doc_data->overflow_depth ++;
}
/*
* Set the document.write tag insertion point.
*/
top_state->input_write_point[top_state->input_write_level] = &top_state->tags;
data = top_state->scriptData;
top_state->scriptData = NULL;
if (data && data->url) {
/*
* Three cases:
* 1. SCRIPT SRC=: url non-null
* 2. SCRIPT ARCHIVE= SRC=: url, archiveSrc non-null
* 3. SCRIPT ARCHIVE= ID=: url, id non-null
* In the last case, we copy the inline script into
* data's buffer and let lo_script_archive_exit_fn do
* the eval. We use an inlineSigned flag to avoid a
* bunch of (url != NULL && archiveSrc == NULL && id
* != NULL) tests.
*/
if (data->inlineSigned) {
StrAllocCopy(data->buffer, (char *) state->line_buf);
data->bufferSize = line_buf_len;
}
lo_GetScriptFromURL(data, script_type);
}
else {
JSPrincipals *principals = NULL;
ETEvalStuff * stuff;
if (data) {
principals = LM_NewJSPrincipals(NULL, data->id,
data->codebase);
if (untransformed &&
!LM_SetUntransformedSource(principals,
untransformed,
(char *) state->line_buf))
{
top_state->out_of_memory = TRUE;
}
lo_DestroyScriptData(data);
}
/*
* send the buffer off to be evaluated
*/
#ifdef DEBUG_ScriptPlugin
if (script_type == SCRIPT_TYPE_PLUGIN)
{
XP_ASSERT(mimebuf == NULL);
npl_ScriptPlugin(context, state, tag, line_buf_len,top_state->mimetype);
lo_unblock_script_tag(context, TRUE);
}
else
#endif /* DEBUG_ScriptPlugin */
stuff = (ETEvalStuff *) XP_NEW_ZAP(ETEvalStuff);
if (!stuff)
goto end_tag_out;
stuff->len = line_buf_len;
stuff->line_no = top_state->script_lineno;
if (scope_to)
stuff->scope_to = XP_STRDUP(scope_to);
else
stuff->scope_to = NULL;
stuff->want_result = JS_FALSE;
stuff->data = context;
stuff->version = top_state->version;
stuff->principals = principals;
ET_EvaluateScript(context,
(char *) state->line_buf,
stuff,
lo_ScriptEvalExitFn);
}
/* Reset version accumulator */
top_state->version = JSVERSION_UNKNOWN;
}
}
}
end_tag_out:
/*
* If we got a </SCRIPT> and still have scriptData set here, it must
* be left over from an error case above, so we free it.
*/
if (top_state->scriptData) {
XP_ASSERT(!top_state->layout_blocking_element);
lo_DestroyScriptData(top_state->scriptData);
top_state->scriptData = NULL;
}
XP_FREEIF(untransformed);
}
}
static void
lo_script_archive_exit_fn(URL_Struct *url_struct, int status, MWContext *context)
{
ScriptData *data = NULL;
char *name;
JSPrincipals *principals;
ETEvalStuff * stuff;
data = (ScriptData *) url_struct->fe_data;
stuff = (ETEvalStuff *) XP_NEW_ZAP(ETEvalStuff);
if (!stuff)
return;
stuff->line_no = 1;
stuff->scope_to = NULL;
stuff->want_result = JS_FALSE;
stuff->version = data->version;
stuff->data = context;
#ifndef JAVA
/* No Java; execute without principals. */
if (data->buffer) {
stuff->principals = NULL;
ET_EvaluateScript(context, data->buffer, stuff, lo_ScriptEvalExitFn);
}
else {
XP_FREE(stuff);
}
#else
name = data->archiveSrc ? data->archiveSrc : data->id;
principals = LM_NewJSPrincipals(url_struct, name, data->codebase);
if (principals != NULL) {
char *src;
uint srcSize;
if (data->archiveSrc) {
/* Extract from archive using "SRC=" value */
src = LM_ExtractFromPrincipalsArchive(principals, data->archiveSrc,
&srcSize);
#ifdef JSDEBUGGER
if( src != NULL && LM_GetJSDebugActive() )
{
char *path = lo_BuildJSArchiveURL(url_struct->address,
data->archiveSrc);
if (path)
{
LM_JamSourceIntoJSDebug( path, src, srcSize, context );
XP_FREE(path);
}
}
#endif /* JSDEBUGGER */
if (src == NULL) {
/* Unsuccessful extracting from archive. Now try normal SRC= lookup. */
(*principals->destroy)(NULL, principals);
data->url = NET_MakeAbsoluteURL(data->state->top_state->base_url,
data->archiveSrc);
XP_FREEIF(data->archiveSrc);
data->archiveSrc = NULL;
lo_GetScriptFromURL(data, data->state->top_state->in_script);
goto out;
}
} else {
/* Should be an inline script */
src = data->buffer;
srcSize = data->bufferSize;
}
stuff->len = srcSize;
stuff->principals = principals;
ET_EvaluateScript(context, src, stuff, lo_ScriptEvalExitFn);
if (data->archiveSrc){
ET_SetNestingUrl(context, NULL);
XP_FREE(src);
}
}
else {
XP_FREE(stuff);
}
#endif /* ifdef JAVA */
lo_DestroyScriptData(data);
out:
/* Always free (or drop a ref on) the url_struct before returning. */
NET_FreeURLStruct(url_struct);
}
PRIVATE void
net_ParseHTMLHelpLoadHelpDoc(HTMLHelpParseObj *obj, MWContext *context)
{
URL_Struct *URL_s;
char *frame_address = NULL;
char *content_address = NULL;
MWContext *new_context;
frame_set_struct *fgs;
if(obj->id_value || obj->default_id_value)
content_address = NET_MakeAbsoluteURL(obj->url_to_map_file,
obj->id_value ?
obj->id_value :
obj->default_id_value);
if(!content_address)
{
FE_Alert(context, XP_GetString(MK_CANT_LOAD_HELP_TOPIC));
return;
}
fgs = XP_ListPeekTopObject(obj->frame_group_stack);
if(fgs)
{
if(fgs->address)
{
frame_address = NET_MakeAbsoluteURL(obj->url_to_map_file,
fgs->address);
}
}
if(frame_address)
URL_s = NET_CreateURLStruct(frame_address, NET_DONT_RELOAD);
else
URL_s = NET_CreateURLStruct(content_address, NET_DONT_RELOAD);
if(!URL_s)
goto cleanup;
URL_s->window_chrome = XP_NEW(Chrome);
if(!URL_s->window_chrome)
goto cleanup;
XP_MEMSET(URL_s->window_chrome, 0, sizeof(Chrome));
if(obj->window_name)
URL_s->window_target = XP_STRDUP(obj->window_name);
else
URL_s->window_target = XP_STRDUP(DEFAULT_HELP_WINDOW_NAME);
net_help_init_chrome(URL_s->window_chrome,
obj->window_width,
obj->window_height);
/* We want to revert the character set of the help frame from the standard
character set, not whatever happened to be the last viewed source */
StrAllocCopy(URL_s->charset, INTL_ResourceCharSet());
new_context = XP_FindNamedContextInList(NULL, URL_s->window_target);
if(frame_address)
{
URL_Struct *content_URL_s;
/* if there is a frame_address then we load the
* frame first and then load the contents
* in the frame exit function.
*/
content_URL_s = NET_CreateURLStruct(content_address, NET_DONT_RELOAD);
if(obj->content_target)
content_URL_s->window_target = XP_STRDUP(obj->content_target);
else if(fgs->target)
content_URL_s->window_target = XP_STRDUP(fgs->target);
/* doesn't work: URL_s->fe_data = (void *) content_URL_s; */
/* hack for older versions, see pre_exit_routine_above */
if (obj->helpVersion < 2) {
frame_content_for_pre_exit_routine = content_URL_s;
} else {
frame_content_for_pre_exit_routine = NULL;
NET_FreeURLStruct(content_URL_s);
}
URL_s->pre_exit_fn = net_HelpPreExitRoutine;
}
if(!new_context)
{
/* this will cause the load too */
new_context = FE_MakeNewWindow(context,
URL_s,
(obj->window_name) ? obj->window_name : DEFAULT_HELP_WINDOW_NAME,
URL_s->window_chrome);
if (HELP_INFO_PTR(*new_context) == NULL) {
new_context->pHelpInfo = XP_NEW_ZAP(HelpInfoStruct);
}
if (HELP_INFO_PTR(*new_context)->topicURL != NULL) {
XP_FREE(HELP_INFO_PTR(*new_context)->topicURL);
HELP_INFO_PTR(*new_context)->topicURL = NULL;
}
StrAllocCopy(HELP_INFO_PTR(*new_context)->topicURL, content_address);
}
else
{
if (HELP_INFO_PTR(*new_context) == NULL) {
new_context->pHelpInfo = XP_NEW_ZAP(HelpInfoStruct);
}
if (HELP_INFO_PTR(*new_context)->topicURL != NULL) {
XP_FREE(HELP_INFO_PTR(*new_context)->topicURL);
HELP_INFO_PTR(*new_context)->topicURL = NULL;
}
StrAllocCopy(HELP_INFO_PTR(*new_context)->topicURL, content_address);
FE_RaiseWindow(new_context);
/* Compatibility with earlier versions of NetHelp */
if (obj->helpVersion < 2) {
FE_GetURL(new_context, URL_s);
} else {
LM_SendOnHelp(new_context);
}
}
cleanup:
FREEIF(frame_address);
FREE(content_address);
return;
}
const char *
lm_CheckURL(JSContext *cx, const char *url_string, JSBool checkFile)
{
char *protocol, *absolute;
JSObject *obj;
MochaDecoder *decoder;
protocol = NET_ParseURL(url_string, GET_PROTOCOL_PART);
if (!protocol || *protocol == '\0') {
lo_TopState *top_state;
obj = JS_GetGlobalObject(cx);
decoder = JS_GetPrivate(cx, obj);
LO_LockLayout();
top_state = lo_GetMochaTopState(decoder->window_context);
if (top_state && top_state->base_url) {
absolute = NET_MakeAbsoluteURL(top_state->base_url,
(char *)url_string); /*XXX*/
/*
* Temporarily unlock layout so that we don't hold the lock
* across a call (lm_CheckPermissions) that may result in
* synchronous event handling.
*/
LO_UnlockLayout();
if (!lm_CheckPermissions(cx, obj,
JSTARGET_UNIVERSAL_BROWSER_READ))
{
/* Don't leak information about the url of this page. */
XP_FREEIF(absolute);
return NULL;
}
LO_LockLayout();
} else {
absolute = NULL;
}
if (absolute) {
if (protocol) XP_FREE(protocol);
protocol = NET_ParseURL(absolute, GET_PROTOCOL_PART);
}
LO_UnlockLayout();
} else {
absolute = JS_strdup(cx, url_string);
if (!absolute) {
XP_FREE(protocol);
return NULL;
}
decoder = NULL;
}
if (absolute) {
/* Make sure it's a safe URL type. */
switch (NET_URL_Type(protocol)) {
case FILE_TYPE_URL:
if (checkFile) {
const char *subjectOrigin = lm_GetSubjectOriginURL(cx);
if (subjectOrigin == NULL) {
XP_FREE(protocol);
return NULL;
}
if (NET_URL_Type(subjectOrigin) != FILE_TYPE_URL &&
!lm_CanAccessTarget(cx, JSTARGET_UNIVERSAL_FILE_READ))
{
XP_FREE(absolute);
absolute = NULL;
}
}
break;
case FTP_TYPE_URL:
case GOPHER_TYPE_URL:
case HTTP_TYPE_URL:
case MAILTO_TYPE_URL:
case NEWS_TYPE_URL:
case RLOGIN_TYPE_URL:
case TELNET_TYPE_URL:
case TN3270_TYPE_URL:
case WAIS_TYPE_URL:
case SECURE_HTTP_TYPE_URL:
case URN_TYPE_URL:
case NFS_TYPE_URL:
case MOCHA_TYPE_URL:
case VIEW_SOURCE_TYPE_URL:
case NETHELP_TYPE_URL:
case WYSIWYG_TYPE_URL:
case LDAP_TYPE_URL:
#ifdef JAVA
case MARIMBA_TYPE_URL:
#endif
/* These are "safe". */
break;
case ABOUT_TYPE_URL:
if (XP_STRCASECMP(absolute, "about:blank") == 0)
break;
if (XP_STRNCASECMP(absolute, "about:pics", 10) == 0)
break;
/* these are OK if we are signed */
if (lm_CanAccessTarget(cx, JSTARGET_UNIVERSAL_BROWSER_READ))
break;
/* FALL THROUGH */
default:
/* All others are naughty. */
XP_FREE(absolute);
absolute = NULL;
break;
}
}
if (!absolute) {
JS_ReportError(cx, "illegal URL method '%s'",
protocol && *protocol ? protocol : url_string);
}
if (protocol)
XP_FREE(protocol);
return absolute;
}
