mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/network/protocol/js/mkmocha.c

757 строки
21 KiB
C
Исходник Ответственный История

/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Netscape Public
* License Version 1.1 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.mozilla.org/NPL/
*
* Software distributed under the License is distributed on an "AS
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
* implied. See the License for the specific language governing
* rights and limitations under the License.
*
* The Original Code is mozilla.org code.
*
* The Initial Developer of the Original Code is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All
* Rights Reserved.
*
* Contributor(s):
*/
/* Please leave at the top for windows precompiled headers */
#include "xp.h"
#include "plstr.h"
#include "prmem.h"
#include "netutils.h"
#include "mkselect.h"
#include "mktcp.h"
#include "mkgeturl.h"
#include <stddef.h>
#include <memory.h>
#include <time.h>
#include "net.h"
#include "libmocha.h"
#include "jsurl.h"
#include "libevent.h"
#include "fe_proto.h"
#include "pa_tags.h" /* included via -I../libparse */
#include "libi18n.h" /* unicode */
#include "layout.h" /* for lo_ContextToCell only */
extern char lm_unknown_origin_str[];
extern int MK_OUT_OF_MEMORY;
extern int MK_MALFORMED_URL_ERROR;
typedef struct {
char * buffer;
size_t offset;
size_t length;
MWContext * context;
char * content_type;
int16 char_set;
} MochaStream;
typedef struct {
int32 ref_count;
ActiveEntry * active_entry;
PRPackedBool is_valid;
PRPackedBool eval_what;
PRPackedBool single_shot;
PRPackedBool polling;
char * str;
size_t len;
MWContext * context;
int status;
char * wysiwyg_url;
char * base_href;
NET_StreamClass * stream;
} MochaConData;
#define HOLD_CON_DATA(con_data) ((con_data)->ref_count++)
#define DROP_CON_DATA(con_data) { \
if (--(con_data)->ref_count == 0) \
free_con_data(con_data); \
}
static void
free_con_data(MochaConData * con_data)
{
PR_FREEIF(con_data->str);
PR_FREEIF(con_data->wysiwyg_url);
PR_FREEIF(con_data->base_href);
PR_Free(con_data);
}
#define START_POLLING(ae, con_data) { \
(con_data)->polling = TRUE; \
NET_SetCallNetlibAllTheTime((ae)->window_id, "mkmocha"); \
}
#define STOP_POLLING(ae, con_data) { \
NET_ClearCallNetlibAllTheTime((ae)->window_id, "mkmocha"); \
(con_data)->polling = FALSE; \
}
/* forward decl */
PRIVATE int32 net_ProcessMocha(ActiveEntry * ae);
/*
* Add the new bits to our buffer
*/
PRIVATE int
mocha_process(NET_StreamClass *stream, const char *str, int32 len)
{
MochaStream * mocha_stream = (MochaStream *) stream->data_object;
mocha_stream->length += len;
if (!mocha_stream->buffer) {
mocha_stream->buffer = (char *)PR_Malloc(mocha_stream->length);
}
else {
mocha_stream->buffer = (char *)PR_Realloc(mocha_stream->buffer,
mocha_stream->length);
}
if (!mocha_stream->buffer) {
return MK_OUT_OF_MEMORY;
}
memcpy(mocha_stream->buffer + mocha_stream->offset, str, len);
mocha_stream->offset += len;
return len;
}
PRIVATE unsigned int
mocha_ready(NET_StreamClass *stream)
{
return MAX_WRITE_READY; /* always ready for writing */
}
/*
* All of the processing for this needs to be done in the mocha thread
*/
PRIVATE void
mocha_complete(NET_StreamClass *stream)
{
void * data;
JSBool isUnicode = JS_FALSE;
MochaStream * mocha_stream = (MochaStream *) stream->data_object;
if (mocha_stream->char_set != CS_DEFAULT) {
uint32 len;
INTL_Unicode * unicode;
/* find out how many unicode characters we'll end up with */
len = INTL_TextToUnicodeLen(mocha_stream->char_set,
(unsigned char *) mocha_stream->buffer,
mocha_stream->length);
unicode = PR_Malloc(sizeof(INTL_Unicode) * len);
if (!unicode)
return;
/* do the conversion */
mocha_stream->length = INTL_TextToUnicode(mocha_stream->char_set,
(unsigned char *) mocha_stream->buffer,
mocha_stream->length,
unicode,
len);
data = unicode;
isUnicode = JS_TRUE;
PR_Free(mocha_stream->buffer);
mocha_stream->buffer = NULL;
}
else {
data = mocha_stream->buffer;
}
/* this will grab ownership of data */
ET_MochaStreamComplete(mocha_stream->context, data,
mocha_stream->length,
mocha_stream->content_type,
isUnicode);
PR_FREEIF(mocha_stream->content_type);
PR_Free(mocha_stream);
}
PRIVATE void
mocha_abort(NET_StreamClass *stream, int status)
{
MochaStream * mocha_stream = (MochaStream *) stream->data_object;
ET_MochaStreamAbort(mocha_stream->context, status);
PR_Free(mocha_stream->buffer);
PR_FREEIF(mocha_stream->content_type);
PR_Free(mocha_stream);
}
int16
net_check_for_charset(URL_Struct *url_struct)
{
int i, max;
char *key, *value;
static char charset[] = "charset=";
int len = PL_strlen(charset);
max = url_struct->all_headers.empty_index;
for (i = 0; i < max; i++) {
key = url_struct->all_headers.key[i];
/* keep looking until we find the content type one */
if (PL_strcasecmp(key, "Content-type"))
continue;
value = url_struct->all_headers.value[i];
value = strtok(value, ";");
while (value) {
value = XP_StripLine(value);
if (!PL_strncasecmp(value, charset, len)) {
value += len;
value = XP_StripLine(value);
return (INTL_CharSetNameToID(value));
}
/* move to next arg */
value = strtok(NULL, ";");
}
/* found content-type but no charset */
return CS_DEFAULT;
}
/* didn't find content-type */
return CS_DEFAULT;
}
static char *
getOriginFromURLStruct(MWContext *context, URL_Struct *url_struct)
{
char *referer;
/*
* Look in url_struct->origin_url for this javascript: URL's
* original referrer.
*
* In the basis case, a javascript: or *.js URL targets a context
* from a (the same, or not) context loaded with a non-javascript URL.
* The referring document's URL is in url_struct->referer and we
* duplicate it as origin_url. If we find a non-null origin_url
* later, we know by induction where it came from.
*/
referer = url_struct->origin_url;
if (referer == NULL) {
/*
* url_struct->referer (sic) tells the URL of the page in
* which a javascript: or *.js link or form was clicked or submitted.
* If it's non-null, but the context is a frame cell that's
* being (re-)created for this load, don't use referer as the
* decoder's source URL for the evaluation, because the FE has
* arbitrarily set it to the top frameset's URL. Instead, use
* the immediate parent frameset context's wysiwyg URL to get
* the origin of the generator (or the parent's address URL if
* not wysiwyg).
*
* If referer is null, the user typed this javascript: URL or
* its frameset's URL directly into the Location toolbar.
*/
referer = url_struct->referer;
if (referer) {
lo_GridRec *grid = NULL;
if (context->is_grid_cell &&
!lo_ContextToCell(context, FALSE, &grid)) {
/*
* Context is a frame being (re)created: veto referer.
* The javascript: or *.js URL can't be a LAYER SRC= URL in a
* frame because the frame's cell must point to its
* context by the time the first tag (even LAYER) is
* processed by layout.
*/
referer = NULL;
}
}
if (!referer) {
History_entry *he;
if (context->grid_parent) {
/*
* If grid parent, use its history entry to get the
* wysiwyg or real URL, which tells the subject origin
* of (any code in it that may have generated) this
* javascript: or *.js URL open. If no grid parent, this must
* be a javascript: or *.js URL that was typed directly into
* Location.
*/
context = context->grid_parent;
}
he = SHIST_GetCurrent(&context->hist);
if (!he) {
referer = lm_unknown_origin_str;
} else {
referer = he->wysiwyg_url;
if (!referer)
referer = he->address;
}
}
}
PR_ASSERT(referer);
referer = PL_strdup(referer);
if (!referer) {
return NULL;
}
url_struct->origin_url = referer;
return referer;
}
NET_StreamClass *
NET_CreateMochaConverter(FO_Present_Types format_out,
void *data_object,
URL_Struct *url_struct,
MWContext *context)
{
MochaStream * mocha_stream;
NET_StreamClass *stream;
char *origin;
mocha_stream = (MochaStream *) PR_NEWZAP(MochaStream);
if (!mocha_stream)
return NULL;
mocha_stream->context = context;
mocha_stream->content_type = PL_strdup(url_struct->content_type);
mocha_stream->char_set = net_check_for_charset(url_struct);
/* Get the origin from the URL struct. We don't have to free origin
* here because url_struct->origin_url owns it.
*/
origin = getOriginFromURLStruct(context, url_struct);
if (origin == NULL)
return NULL;
if (NET_URL_Type(url_struct->address) == FILE_TYPE_URL &&
NET_URL_Type(origin) != FILE_TYPE_URL)
{
/*
* Don't allow loading a file: URL from a non-file URL to
* prevent privacy attacks against the local machine from
* web pages.
*/
return NULL;
}
stream = NET_NewStream("mocha", mocha_process, mocha_complete,
mocha_abort, mocha_ready, mocha_stream,
context);
return stream;
}
PRIVATE void
mk_mocha_eval_exit_fn(void * data, char * str, size_t len, char * wysiwyg_url,
char * base_href, Bool valid)
{
MochaConData * con_data = (MochaConData *) data;
if (!valid) {
con_data->status = MK_MALFORMED_URL_ERROR;
con_data->is_valid = TRUE;
return;
}
if (str == NULL) {
con_data->status = MK_DATA_LOADED;
con_data->is_valid = TRUE;
return;
}
con_data->base_href = base_href;
con_data->wysiwyg_url = wysiwyg_url;
con_data->str = str;
con_data->len = len;
con_data->is_valid = TRUE;
}
/*
* Handle both 'mocha:<stuff>' urls and the mocha type-in widget
*/
MODULE_PRIVATE int32
net_MochaLoad(ActiveEntry *ae)
{
MWContext *context;
URL_Struct *url_struct;
char *what;
Bool eval_what, single_shot;
MochaConData * con_data;
context = ae->window_id;
url_struct = ae->URL_s;
what = PL_strchr(url_struct->address, ':');
PR_ASSERT(what);
what++;
eval_what = FALSE;
single_shot = (*what != '?');
if (single_shot) {
/* Don't use an existing Mocha output window's stream. */
if (*what == '\0') {
/* Generate two grid cells, one for output and one for input. */
what = PR_smprintf("<frameset rows=\"75%%,25%%\">\n"
"<frame name=MochaOutput src=about:blank>\n"
"<frame name=MochaInput src=%.*s#input>\n"
"</frameset>",
what - url_struct->address,
url_struct->address);
} else if (!PL_strcmp(what, "#input")) {
/* The input cell contains a form with one magic isindex field. */
what = PR_smprintf("<b>%.*s typein</b>\n"
"<form action=%.*s target=MochaOutput"
" onsubmit='this.isindex.focus()'>\n"
"<input name=isindex size=60>\n"
"</form>",
what - url_struct->address - 1,
url_struct->address,
what - url_struct->address,
url_struct->address);
url_struct->internal_url = TRUE;
} else {
eval_what = TRUE;
}
} else {
/* Use the Mocha output window if it exists. */
url_struct->auto_scroll = 1000;
/* Skip the leading question-mark and clean up the string. */
what++;
NET_PlusToSpace(what);
NET_UnEscape(what);
eval_what = TRUE;
}
/* something got hosed. bail */
if (!what) {
ae->status = MK_OUT_OF_MEMORY;
return -1;
}
/* make space for the connection data */
con_data = PR_NEWZAP(MochaConData);
if (!con_data) {
ae->status = MK_OUT_OF_MEMORY;
return -1;
}
/* remember for next time */
con_data->ref_count = 1;
con_data->active_entry = ae;
ae->con_data = con_data;
/* set up some state so we remember where we are */
con_data->eval_what = eval_what;
con_data->single_shot = single_shot;
con_data->context = context;
/* fake out netlib so we don't select on the socket id */
ae->socket = NULL;
ae->local_file = TRUE;
if (eval_what) {
char *referer;
JSPrincipals *principals;
ETEvalStuff *stuff;
referer = getOriginFromURLStruct(context, url_struct);
if (!referer) {
ae->status = MK_OUT_OF_MEMORY;
return -1;
}
principals = LM_NewJSPrincipals(NULL, NULL, referer);
if (!principals) {
ae->status = MK_OUT_OF_MEMORY;
return -1;
}
/*
* send the buffer off to be evaluated
*/
stuff = (ETEvalStuff *) PR_NEWZAP(ETEvalStuff);
if (!stuff) {
ae->status = MK_OUT_OF_MEMORY;
return -1;
}
stuff->len = PL_strlen(what);
stuff->line_no = 0;
stuff->scope_to = NULL;
stuff->want_result = JS_TRUE;
stuff->data = con_data;
stuff->version = JSVERSION_UNKNOWN;
stuff->principals = principals;
ET_EvaluateScript(context, what, stuff, mk_mocha_eval_exit_fn);
}
else {
/* allocated above, don't need to free */
con_data->str = what;
con_data->len = PL_strlen(what);
con_data->is_valid = TRUE;
}
/* make sure netlib gets called so we know when our data gets back */
START_POLLING(ae, con_data);
/* ya'll come back now, ya'hear? */
return net_ProcessMocha(ae);
}
PRIVATE int
net_process_mocha(MochaConData * con_data)
{
int32 ref_count;
ref_count = con_data->ref_count;
DROP_CON_DATA(con_data);
if (ref_count == 1 || !con_data->active_entry)
return -1;
return net_ProcessMocha(con_data->active_entry);
}
static char nscp_open_tag[] = "<" PT_NSCP_OPEN ">";
/*
* If the mocha has finished evaluation shove the result
* down the stream and continue else just wait
*/
PRIVATE int32
net_ProcessMocha(ActiveEntry * ae)
{
FO_Present_Types output_format;
Bool to_layout;
Bool first_time;
NET_StreamClass *stream = NULL;
MochaConData * con_data = (MochaConData *) ae->con_data;
MWContext * context;
int status;
/* if we haven't gotten our data yet just return and wait */
if (!con_data || !con_data->is_valid)
return 0;
context = ae->window_id;
/*
* Race with the mocha thread until we can grab the JSLock
*/
if (!con_data->single_shot) {
MochaDecoder * decoder;
HOLD_CON_DATA(con_data);
if (!LM_AttemptLockJS(context,
(JSLockReleaseFunc)net_process_mocha, con_data))
return 0;
DROP_CON_DATA(con_data);
decoder = LM_GetMochaDecoder(context);
if (!decoder) {
LM_UnlockJS(context);
ae->status = MK_OUT_OF_MEMORY;
goto done;
}
stream = decoder->stream;
LM_PutMochaDecoder(decoder);
LM_UnlockJS(context);
}
else {
stream = con_data->stream;
}
/* we've gotten valid data, clear the callme all the time flag */
STOP_POLLING(ae, con_data);
/* see if there were any problems */
if (con_data->status < 0 || con_data->str == NULL) {
ET_SendLoadEvent(context, EVENT_LOAD, NULL, NULL,
LO_DOCUMENT_LAYER_ID, FALSE);
ae->status = con_data->status;
goto done;
}
/*
* If we don't already have a stream to take our output create one now
*/
first_time = !stream;
if (first_time) {
StrAllocCopy(ae->URL_s->content_type, TEXT_HTML);
ae->format_out = CLEAR_CACHE_BIT(ae->format_out);
stream = NET_StreamBuilder(ae->format_out, ae->URL_s, ae->window_id);
if (!stream) {
ae->status = MK_UNABLE_TO_CONVERT;
goto done;
}
}
/*
* If the stream we just created isn't ready for writing just
* hold onto the stream and try again later
*/
if (!stream->is_write_ready(stream)) {
con_data->stream = stream;
START_POLLING(ae, con_data);
return 0;
}
/* XXX this condition is fairly bogus */
output_format = CLEAR_CACHE_BIT(ae->format_out);
to_layout = (output_format != FO_INTERNAL_IMAGE &&
output_format != FO_MULTIPART_IMAGE &&
output_format != FO_EMBED &&
output_format != FO_PLUGIN);
if (to_layout) {
/* The string must end in a newline so the parser will flush it. */
if (con_data->len != 0 && con_data->str[con_data->len-1] != '\n') {
size_t new_len = con_data->len + 1;
char * new_str = PR_Malloc((new_len + 1) * sizeof(char));
if (!new_str) {
ae->status = MK_OUT_OF_MEMORY;
goto done;
}
memcpy(new_str, con_data->str, con_data->len);
new_str[new_len-1] = '\n';
new_str[new_len] = '\0';
con_data->str = new_str;
con_data->len = new_len;
}
}
/*
* If this is the first time do some initial setup. We'll set
* the window title and maybe shove out a <BASE> tag
*/
status = 0;
if (to_layout && first_time && con_data->eval_what) {
/* Feed layout an internal tag so it will create a new top state. */
stream->put_block(stream, nscp_open_tag,
sizeof nscp_open_tag - 1);
(void) LM_WysiwygCacheConverter(context, ae->URL_s,
con_data->wysiwyg_url,
con_data->base_href);
if (*con_data->str != '<') {
char * prefix = NULL;
StrAllocCopy(prefix, "<TITLE>");
StrAllocCat(prefix, ae->URL_s->address);
StrAllocCat(prefix, "</TITLE><PLAINTEXT>");
if (!prefix) {
ae->status = MK_OUT_OF_MEMORY;
goto done;
}
status = (*stream->put_block)(stream, prefix,
PL_strlen(prefix));
PR_Free(prefix);
}
else {
if (con_data->base_href) {
status = (*stream->put_block)(stream,
con_data->base_href,
PL_strlen(con_data->base_href));
}
}
}
if (status >= 0) {
status = (*stream->put_block)(stream, con_data->str,
(int32)con_data->len);
}
if (con_data->single_shot && status >= 0)
(*stream->complete)(stream);
if (!con_data->single_shot && status >= 0) {
if (first_time) {
ET_SetDecoderStream(context, stream, ae->URL_s, JS_TRUE);
goto done;
}
} else {
if (status < 0)
(*stream->abort)(stream, status);
if (first_time)
PR_Free(stream);
}
ae->status = MK_DATA_LOADED;
done:
ae->con_data = NULL;
con_data->active_entry = NULL;
DROP_CON_DATA(con_data);
return -1;
}
PRIVATE int32
net_InterruptMocha(ActiveEntry *ae)
{
MochaConData * con_data = (MochaConData *) ae->con_data;
if (!con_data)
return MK_INTERRUPTED;
/* do we need to decrement the callme all the time flag? */
if (con_data->polling) {
STOP_POLLING(ae, con_data);
}
/* ae is about to go away, break its connection with con_data */
ae->con_data = NULL;
con_data->active_entry = NULL;
/* ae is about to go away, better get it off the JS lock waiters list */
if (LM_ClearAttemptLockJS(con_data->context,
(JSLockReleaseFunc)net_process_mocha, con_data))
DROP_CON_DATA(con_data);
return ae->status = MK_INTERRUPTED;
}
PRIVATE void
net_CleanupMocha(void)
{
/* nothing so far needs freeing */
return;
}
MODULE_PRIVATE void
NET_InitMochaProtocol(void)
{
static NET_ProtoImpl mocha_proto_impl;
mocha_proto_impl.init = net_MochaLoad;
mocha_proto_impl.process = net_ProcessMocha;
mocha_proto_impl.interrupt = net_InterruptMocha;
mocha_proto_impl.resume = NULL;
mocha_proto_impl.cleanup = net_CleanupMocha;
NET_RegisterProtocolImplementation(&mocha_proto_impl, MOCHA_TYPE_URL);
}
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку