/* Constructs a URL_Struct from the the specified URL to the prefetch_list based
on the value of the pre subtag.
*/
PUBLIC void
PRE_AddToList(MWContext* context, char* url, double value)
{
/* Construct a new URL_Struct with this url, and Prefetch priority */
URL_Struct* urls;
PrefetchURLStruct *pus = XP_NEW(PrefetchURLStruct);
if (!pre_enabled || !value || !pus || !pre_OKToPrefetch(url))
return;
urls = NET_CreateURLStruct(url, NET_DONT_RELOAD);
if (!urls)
return;
urls->priority = Prefetch_priority;
urls->load_background = TRUE;
if (prefetch_list == NULL)
{
prefetch_list = XP_ListNew();
}
pus->prevalue = value;
pus->URL_s = urls;
XP_ListAddObjectToEnd(prefetch_list, pus);
}
PUBLIC void
NET_LoadNetHelpTopic(MWContext *pContext, const char *topic)
{
char *pNetHelpURLString;
URL_Struct *pHelpURL;
if (topic == NULL) {
return;
}
/* Convert the fully-specified topic into a nethelp URL: */
pNetHelpURLString = (char *) XP_ALLOC(strlen(topic) + strlen(NETHELP_URL_PREFIX)+1);
if (!pNetHelpURLString) {
return;
}
XP_STRCPY(pNetHelpURLString, NETHELP_URL_PREFIX);
XP_STRCPY(&(pNetHelpURLString[strlen(NETHELP_URL_PREFIX)]), topic);
pHelpURL = NET_CreateURLStruct(pNetHelpURLString, NET_NORMAL_RELOAD);
if (!pHelpURL) {
return;
}
NET_GetURL(pHelpURL, FO_PRESENT, pContext, simple_exit);
XP_FREEIF(pNetHelpURLString);
}
void XFE_ComposeAttachFolderView::openAttachment(int pos)
{
if (pos<0 || pos>=_attachPanel->numItems())
return;
// Disable preview of previously attached item. Need to resolve
// inconsistency when attaching URL pointing to cgi. Preview
// will reload the URL, and the return data may differ from the
// data previously loaded by the mail back-end. i.e. it will
// not be a useful preview.
#if 0
// ensure clicked item is selected
if (pos!=_attachPanel->currentSelectionPos() && _attachPanel->items())
_attachPanel->selectItem(_attachPanel->items()[pos]);
XFE_AttachPanelItem *item=_attachPanel->currentSelection();
if (!item || !item->data())
return;
URL_Struct *url = NET_CreateURLStruct (item->data(),NET_DONT_RELOAD);
if (!MSG_RequiresBrowserWindow(url->address))
fe_GetURL(_context,url,FALSE);
else
fe_MakeWindow(XtParent(CONTEXT_WIDGET (_context)), _context, url, NULL,
MWContextBrowser, FALSE);
fe_UserActivity(_context);
#endif
}
int
rdfRetrievalType (RDFFile f)
{
URL_Struct *urls;
char *url;
int type;
url = f->url;
if (f->localp)
{
urls = NET_CreateURLStruct(url, NET_CACHE_ONLY_RELOAD);
if ((urls != NULL) && (NET_IsURLInDiskCache(urls) || NET_IsURLInMemCache(urls)))
{
type = NET_DONT_RELOAD;
}
else
{
type = NET_DONT_RELOAD;
}
if (urls != NULL) NET_FreeURLStruct(urls);
}
else
{
type = NET_DONT_RELOAD;
}
return(type);
}
void XFE_ReadAttachPanel::saveCb()
{
if (!currentSelection() || !currentSelection()->data())
return;
URL_Struct *url = NET_CreateURLStruct (currentSelection()->data(),NET_DONT_RELOAD);
if (url)
fe_SaveURL(_context,url);
}
void
readCSS (StyleSheet ss)
{
URL_Struct *urls;
urls = NET_CreateURLStruct(ss->address, NET_DONT_RELOAD);
if (urls == NULL) {
ss->xmlFile->numOpenStreams--;
return;
}
urls->fe_data = ss;
NET_GetURL(urls, FO_CACHE_AND_XMLCSS, ss->xmlFile->mwcontext, xmlcss_GetUrlExitFunc);
}
void
readHTML (char* url, XMLHTMLInclusion ss)
{
URL_Struct *urls;
urls = NET_CreateURLStruct(url, NET_DONT_RELOAD);
if (urls == NULL) {
ss->xml->numOpenStreams--;
return;
}
urls->fe_data = ss;
NET_GetURL(urls, FO_CACHE_AND_XMLHTML, ss->xml->mwcontext, xmlhtml_GetUrlExitFunc);
}
int
rdf_GetURL (MWContext *cx, int method, Net_GetUrlExitFunc *exit_routine, RDFFile rdfFile)
{
URL_Struct *urls;
if (cx == NULL) return 0;
urls = NET_CreateURLStruct(rdfFile->url, NET_DONT_RELOAD);
if (urls == NULL) return 0;
/* urls->use_local_copy = rdfFile->localp;*/
urls->fe_data = rdfFile;
if (method) urls->method = method;
NET_GetURL(urls, FO_CACHE_AND_RDF, cx, rdf_GetUrlExitFunc);
return 1;
}
void
xmlhtml_complete (NET_StreamClass *stream)
{
XMLHTMLInclusion ss =stream->data_object;
XMLFile xml = ss->xml;
xml->numOpenStreams--;
if (xml->numOpenStreams == 0) {
/* direct the stream to the html parser */
NET_StreamClass *newstream;
URL_Struct *nurls = NET_CreateURLStruct(copyString(xml->address), NET_DONT_RELOAD);
StrAllocCopy(nurls->content_type, TEXT_HTML);
newstream = NET_StreamBuilder(1, nurls, (MWContext*) xml->mwcontext);
xml->stream = newstream;
convertToHTML(xml);
newstream->complete(newstream);
NET_FreeURLStruct(nurls);
}
}
void XFE_ReadAttachPanel::openCb()
{
if (!currentSelection())
return;
const char *selData=currentSelection()->data();
if (!selData || strlen(selData)==0)
return;
URL_Struct *url = NET_CreateURLStruct (selData,NET_DONT_RELOAD);
if (!MSG_RequiresBrowserWindow(url->address))
fe_GetURL(_context,url,FALSE);
else
fe_MakeWindow(XtParent(CONTEXT_WIDGET (_context)), _context, url, NULL,
MWContextBrowser, FALSE);
fe_UserActivity(_context);
}
char *XFE_ReadAttachDrag::getTargetData(Atom target)
{
// WARNING - data *must* be allocated with Xt malloc API, or Xt
// will spring a leak!
if (!_dragDataURL || !_dragDataName)
return NULL;
if (target==_XA_NETSCAPE_URL) {
// translate drag data to NetscapeURL format
XFE_URLDesktopType urlData;
urlData.createItemList(1);
urlData.url(0,_dragDataURL);
return (char*) XtNewString(urlData.getString());
}
if (target==_XA_FILE_NAME) {
// save url as appropriately named file in a tmp
// directory.
if ((_tmpDirectory=XFE_DesktopType::createTmpDirectory())==NULL)
return NULL;
_tmpFileName=new char[strlen(_tmpDirectory)+1+strlen(_dragDataName)+1];
sprintf(_tmpFileName,"%s/%s",_tmpDirectory,_dragDataName);
URL_Struct *urlStruct=NET_CreateURLStruct(_dragDataURL,NET_DONT_RELOAD);
if (urlStruct) {
lockFrame();
fe_SaveSynchronousURL(_attachPanel->context(),urlStruct,_tmpFileName);
unlockFrame();
}
// return file name
return (char*) XtNewString(_tmpFileName);
}
if (target==XA_STRING) {
// return the URL
return (char*) XtNewString(_dragDataURL);
}
return NULL;
}
// Return TRUE in most cases unless serious error.
// Nothing to draw is OK, but unable to draw is not OK.
BOOL CNetscapeSrvrItem::OnDraw(CDC* pDC, CSize& rSize)
{
TRACE("CNetscapeSrvrItem::OnDraw %p\n", this);
ASSERT_VALID(pDC);
CGenericDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
// Determine the URL we're going to draw.
CString csDraw;
pDoc->GetContextHistoryAddress(csDraw);
if(csDraw.IsEmpty()) {
TRACE("Nothing to draw.\n");
return(TRUE);
}
// Allocate the url.
URL_Struct *pUrl = NET_CreateURLStruct((const char *)csDraw, NET_DONT_RELOAD);
if(pUrl == NULL) {
TRACE("Nothing to draw without URL.\n");
return(TRUE);
}
// Before we do this, make sure we know the current size of the view
// not the document constant extent.
CSize csViewport = pDoc->m_csViewExtent;
// Have a new context draw the item into the metafile.
// We have to block until completion.
DWORD dwBlockID = CMetaFileCX::MetaFileAnchorObject(pDC, csViewport, pUrl);
if(dwBlockID == 0) {
// Counld not create new meta file context.
return(FALSE);
}
// Block return until the context is destroyed.
FEU_BlockUntilDestroyed(dwBlockID);
return(TRUE);
}
/* load the HTML help mapping file and search for
* the id or text to load a specific document
*/
PUBLIC void
NET_GetHTMLHelpFileFromMapFile(MWContext *context,
char *map_file_url,
char *id,
char *search_text)
{
URL_Struct *URL_s;
XP_ASSERT(map_file_url && id);
if(!map_file_url || !id)
return;
URL_s = NET_CreateURLStruct(map_file_url, NET_DONT_RELOAD);
if(!URL_s)
return;
URL_s->fe_data = XP_STRDUP(id);
NET_GetURL(URL_s, FO_CACHE_AND_LOAD_HTML_HELP_MAP_FILE, context, simple_exit);
}
void
xmlcss_complete (NET_StreamClass *stream)
{
StyleSheet ss =stream->data_object;
URL_Struct *urls = ss->urls;
XMLFile xml = ss->xmlFile;
freeMem(ss->holdOver);
freeMem(ss->line);
ss->line = ss->holdOver = NULL;
xml->numOpenStreams--;
if (xml->numOpenStreams == 0) {
/* direct the stream to the html parser */
NET_StreamClass *newstream;
URL_Struct *nurls = NET_CreateURLStruct(copyString(xml->address), NET_DONT_RELOAD);
StrAllocCopy(nurls->content_type, TEXT_HTML);
newstream = NET_StreamBuilder(1, nurls, (MWContext*) xml->mwcontext);
xml->stream = newstream;
convertToHTML(xml);
newstream->complete(newstream);
NET_FreeURLStruct(nurls);
}
}
/** go tell the directory that child got added to parent **/
void
ESAddChild (RDF_Resource parent, RDF_Resource child)
{
URL_Struct *urls;
void *feData, **files_to_post = NULL;
if ((urls = NET_CreateURLStruct(resourceID(parent), NET_SUPER_RELOAD)) != NULL)
{
feData = (void *)esMakeFEData(parent, child, URL_POST_METHOD);
if ((files_to_post = (char **)XP_ALLOC(2*sizeof(char *))) != NULL)
{
files_to_post[0] = nativeFilename(resourceID(child));
files_to_post[1] = NULL;
}
if ((feData != NULL) && (files_to_post != NULL))
{
urls->files_to_post = (void *)files_to_post;
urls->post_to = NULL;
urls->method = URL_POST_METHOD;
urls->fe_data = (void *)feData;
NET_GetURL(urls, FO_PRESENT,
(MWContext *)gRDFMWContext(),
es_GetUrlExitFunc);
}
else
{
if (feData != NULL)
{
esFreeFEData(feData);
}
if (files_to_post != NULL)
{
if (files_to_post[0] != NULL) freeMem(files_to_post[0]);
XP_FREE(files_to_post);
}
NET_FreeURLStruct(urls);
}
}
}
void
xml_complete (NET_StreamClass *stream)
{
NET_StreamClass *newstream;
void *obj=stream->data_object;
URL_Struct *urls = ((XMLFile)obj)->urls;
freeMem(((XMLFile)obj)->holdOver);
freeMem(((XMLFile)obj)->line);
((XMLFile)obj)->line = ((XMLFile)obj)->holdOver = NULL;
((XMLFile)obj)->numOpenStreams--;
if (((XMLFile)obj)->numOpenStreams < 1) {
/* direct the stream to the html parser */
URL_Struct *nurls = NET_CreateURLStruct(copyString(urls->address), NET_DONT_RELOAD);
StrAllocCopy(nurls->content_type, TEXT_HTML);
newstream = NET_StreamBuilder(1, nurls, (MWContext*) ((XMLFile)obj)->mwcontext);
((XMLFile)obj)->stream = newstream;
convertToHTML(((XMLFile)obj));
newstream->complete(newstream);
NET_FreeURLStruct(nurls);
}
}
/** remove the child from the directory **/
void
ESRemoveChild (RDF_Resource parent, RDF_Resource child)
{
URL_Struct *urls;
void *feData;
if ((urls = NET_CreateURLStruct(resourceID(child), NET_SUPER_RELOAD)) != NULL)
{
feData = (void *)esMakeFEData(parent, child, URL_DELETE_METHOD);
if (feData != NULL)
{
urls->method = URL_DELETE_METHOD;
urls->fe_data = (void *)feData;
NET_GetURL(urls, FO_PRESENT,
(MWContext *)gRDFMWContext(),
es_GetUrlExitFunc);
}
else
{
NET_FreeURLStruct(urls);
}
}
}
static JSBool
url_load(JSContext *cx, JSObject *obj, const char *url_string,
NET_ReloadMethod reload_how)
{
JSURL *url;
URL_Struct *url_struct;
const char *referer;
url = JS_GetPrivate(cx, obj);
if (!url)
return JS_TRUE;
url_struct = NET_CreateURLStruct(url_string, reload_how);
if (!url_struct) {
JS_ReportOutOfMemory(cx);
return JS_FALSE;
}
if (!(referer = lm_GetSubjectOriginURL(cx)) ||
!(url_struct->referer = JS_strdup(cx, referer))) {
NET_FreeURLStruct(url_struct);
return JS_FALSE;
}
return lm_GetURL(cx, url->url_decoder, url_struct);
}
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;
}
void
GetPopToRDF (RDFT rdf)
{
MF folder = (MF) rdf->pdata;
if (endsWith("/inbox", rdf->url)) {
char* popurl = getMem(100);
int n = 10;
int l = strlen(rdf->url);
URL_Struct *urls ;
memcpy(popurl, "pop3://", 7);
while (n < l) {
if (rdf->url[n] == '/') break;
popurl[n-3] = rdf->url[n];
n++;
}
urls = NET_CreateURLStruct(popurl, NET_DONT_RELOAD);
if (urls != NULL) {
urls->fe_data = rdf;
NET_GetURL(urls, FO_PRESENT, gRDFMWContext(rdf), Pop_GetUrlExitFunc);
}
}
}
//-----------------------------------------------------------------------------
// NetStream
//-----------------------------------------------------------------------------
CStreamOutNet::CStreamOutNet( MWContext* pContext )
{
URL_Struct * URL_s;
Chrome chrome;
XP_BZERO( &chrome, sizeof( Chrome ) );
chrome.allow_close = TRUE;
chrome.allow_resize = TRUE;
chrome.show_scrollbar = TRUE;
#ifndef XP_WIN
// NOTE: need to verify this change on XP_WIN and remove the
// ifndef... [ works on XP_UNIX & XP_MAC ]
//
chrome.type = MWContextDialog;
#endif
//
// LTNOTE: Ownership of the 'chrome' struct isn't documented in the interface.
// The windows implementation doesn't appear to keep pointers to the struct.
//
MWContext *pNewContext = FE_MakeNewWindow(pContext, NULL, "view-source",
&chrome );
pNewContext->edit_view_source_hack = TRUE;
URL_s = NET_CreateURLStruct(XP_GetString(EDT_VIEW_SOURCE_WINDOW_TITLE), NET_DONT_RELOAD);
URL_s->content_type = XP_STRDUP(TEXT_PLAIN);
m_pStream = NET_StreamBuilder(FO_PRESENT, URL_s, pNewContext);
if(!m_pStream){
XP_ASSERT( FALSE );
m_status = EOS_FileError;
}
m_status = EOS_NoError;
}
int
rdf_GetURL (MWContext *cx, int method, Net_GetUrlExitFunc *exit_routine, RDFFile rdfFile)
{
MozillaEvent_rdf_GetURL *event;
URL_Struct *urls = NULL;
char *url;
#ifdef DEBUG_gagan
return 0;
#endif
if (cx == NULL) return 0;
if (rdfFile->refreshingp && rdfFile->updateURL) {
url = rdfFile->updateURL;
} else {
url = rdfFile->url;
}
if (strcmp(url, gNavCntrUrl) == 0) {
urls = NET_CreateURLStruct(url, NET_CACHE_ONLY_RELOAD);
#ifdef NU_CACHE
if (!CacheManager_Contains(url)) {
#else
if (NET_IsURLInDiskCache(urls) || NET_IsURLInMemCache(urls)) {
} else {
#endif
NET_FreeURLStruct(urls);
urls = NULL;
}
}
if (!urls)
urls = NET_CreateURLStruct(url, (rdfFile->refreshingp ?
NET_SUPER_RELOAD : NET_NORMAL_RELOAD));
if (urls == NULL) return 0;
urls->fe_data = rdfFile;
if (method) urls->method = method;
if (PR_CurrentThread() == mozilla_thread)
{
htLoadBegins(urls, url);
NET_GetURL(urls, FO_CACHE_AND_RDF, cx, rdf_GetUrlExitFunc);
}
else
{
/* send event to Mozilla thread */
if (mozilla_event_queue == NULL) return(0);
event = PR_NEW(MozillaEvent_rdf_GetURL);
if (event == NULL) return(0);
PR_InitEvent(&(event->ce.event), cx,
(PRHandleEventProc)rdf_HandleEvent_GetURL,
(PRDestroyEventProc)rdf_DisposeEvent_GetURL);
event->url = copyString(url);
event->urls = urls;
event->method = FO_CACHE_AND_RDF;
event->cx = cx;
event->exitFunc = rdf_GetUrlExitFunc;
PR_PostEvent(mozilla_event_queue, &(event->ce.event));
}
return 1;
}
#endif /* MOZILLA_CLIENT */
void
possiblyRereadRDFFiles (void* data)
{
possiblyRefreshRDFFiles();
/* timerID = FE_SetTimeout(possiblyRereadRDFFiles, NULL, 1000 * 60 * 10);
once every 10 minutes
diabled for legal reasons.*/
}
void
RDFglueInitialize()
{
#ifdef MOZILLA_CLIENT
timerID = FE_SetTimeout(possiblyRereadRDFFiles, NULL, 1000 * 60 * 10); /* once every 10 minutes */
if (gRLForbiddenDomains != NULL)
{
freeMem(gRLForbiddenDomains);
gRLForbiddenDomains = NULL;
}
if (PREF_CopyCharPref("browser.relatedLinksDisabledForDomains", &gRLForbiddenDomains) != PREF_OK)
{
gRLForbiddenDomains = NULL;
}
#endif /* MOZILLA_CLIENT */
}
void
fe_showNetcaster(Widget toplevel)
/*
* description:
* This function shows the Netcaster window, starting
* Netcaster if necessary. If Netcaster is not installed,
* this function does nothing.
*
****************************************/
{
MWContext * netcasterContext;
if (!fe_IsNetcasterInstalled())
return;
if(!(netcasterContext=FE_IsNetcasterRunning()))
{
Chrome netcasterChrome;
URL_Struct* URL_s;
const char* netcasterURL = xfe_netcaster_url();
if (netcasterURL)
{
if (!LM_GetMochaEnabled() || !LJ_GetJavaEnabled())
{
fe_Alert_2(toplevel, XP_GetString(XP_ALERT_NETCASTER_NO_JS));
return;
}
memset(&netcasterChrome, 0, sizeof(Chrome));
netcasterChrome.w_hint = 21;
netcasterChrome.h_hint = 59;
netcasterChrome.l_hint = -1000;
netcasterChrome.t_hint = -1000;
netcasterChrome.topmost = TRUE;
netcasterChrome.z_lock = TRUE;
netcasterChrome.location_is_chrome = TRUE;
netcasterChrome.disable_commands = TRUE;
netcasterChrome.hide_title_bar = TRUE;
netcasterChrome.restricted_target = TRUE;
URL_s = NET_CreateURLStruct(netcasterURL, NET_DONT_RELOAD);
netcasterContext = xfe2_MakeNewWindow(toplevel,NULL,
URL_s,
netcasterWindowName,
MWContextBrowser,
False,
&netcasterChrome);
}
else
{
fe_Alert_2(toplevel, XP_GetString(XP_ALERT_CANT_RUN_NETCASTER));
}
}
else
{
FE_RaiseWindow(netcasterContext);
}
}
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;
}
/*
* Load a document from an external URL. Assumes that layout is
* already blocked
*/
static void
lo_GetScriptFromURL(ScriptData *data, int script_type)
{
URL_Struct *url_struct;
lo_TopState *top_state = data->state->top_state;
PA_Tag *tag = data->tag;
url_struct = NET_CreateURLStruct(data->url, top_state->force_reload);
if (url_struct == NULL) {
top_state->out_of_memory = TRUE;
lo_DestroyScriptData(data);
return;
}
url_struct->must_cache = TRUE;
url_struct->preset_content_type = TRUE;
if (script_type == SCRIPT_TYPE_CSS) {
StrAllocCopy(url_struct->content_type, TEXT_CSS);
} else {
if (tag->type == P_STYLE || tag->type == P_LINK) {
StrAllocCopy(url_struct->content_type, TEXT_JSSS);
} else {
StrAllocCopy(url_struct->content_type, js_content_type);
}
}
XP_ASSERT(top_state->layout_blocking_element);
if (!url_struct->content_type)
goto out;
if (!data->inlineSigned) {
if (data->archiveSrc) {
/* ARCHIVE= and SRC= */
/*
* Need to set nesting url. Create name of form
* "archive.jar/src.js"
*/
char *path = lo_BuildJSArchiveURL(url_struct->address,
data->archiveSrc);
if (!path)
goto out;
ET_SetNestingUrl(data->context, path);
/* version taken care of in lo_script_archive_exit_fn */
XP_FREE(path);
} else {
/* SRC= but no ARCHIVE= */
ET_SetNestingUrl(data->context, url_struct->address);
ET_SetVersion(data->context, data->version);
}
}
url_struct->fe_data = data;
if (data->archiveSrc != NULL || data->inlineSigned) {
NET_GetURL(url_struct,
FO_CACHE_ONLY,
data->context,
lo_script_archive_exit_fn);
} else {
NET_GetURL(url_struct,
FO_CACHE_AND_PRESENT,
data->context,
lo_script_src_exit_fn);
}
return;
out:
top_state->out_of_memory = TRUE;
NET_FreeURLStruct(url_struct);
lo_DestroyScriptData(data);
return;
}
void npl_ScriptPlugin(MWContext *context, lo_DocState *state, PA_Tag *tag, size_t line_buf_len, char * mimebuf)
{
char * suffix = NULL;
char * fname = NULL;
char * embedtagstr = NULL;
char * NET_suffix = NULL;
PA_Tag * newTag = NULL;
NET_StreamClass* viewstream = NULL;
URL_Struct* urls = NULL;
int streamStatus = 0;
int id = 0;
if (!context || !state || !tag || (line_buf_len <= 0) || !mimebuf){
XP_Trace("npl_ScriptPlugin: Invalid input(s).");
return; /* no need to goto clean_exit, since havn't alloc'd anything */
}
urls = NET_CreateURLStruct("internal_url.", NET_DONT_RELOAD);
ALLOC_CHECK(urls,id,abnormal_exit);
/* NETLib gives me a pointer here instead of a copy of the string, so I have to make
my own, make checks, etc.
*/
NET_suffix = NET_cinfo_find_ext(mimebuf);
if (!NET_suffix)
goto abnormal_exit;
suffix = PR_smprintf("internal_url.%s", NET_suffix);
ALLOC_CHECK(suffix,id,abnormal_exit);
XP_FREEIF(urls->address);
StrAllocCopy(urls->address , suffix);
ALLOC_CHECK(urls->address,id,abnormal_exit);
XP_FREEIF(urls->content_name);
StrAllocCopy(urls->content_name, suffix);
ALLOC_CHECK(urls->content_name,id,abnormal_exit);
XP_FREEIF(urls->content_type);
StrAllocCopy(urls->content_type, mimebuf);
ALLOC_CHECK(urls->content_type,id,abnormal_exit);
urls->must_cache = 1; /* ugly flag for mailto and saveas */
viewstream = NET_StreamBuilder(FO_CACHE_ONLY, urls, context);
ALLOC_CHECK(viewstream,id,abnormal_exit);
streamStatus =
(*viewstream->put_block)(viewstream,(CONST char*)state->line_buf, line_buf_len);
if (streamStatus <= 0)
goto abnormal_exit;
(*viewstream->complete)(viewstream);
/* Now build internal embed tag pointing to this source: */
fname = WH_FileName(urls->cache_file, xpCache);
ALLOC_CHECK(fname,id,abnormal_exit);
embedtagstr = PR_smprintf("<EMBED SRC=file:///%s HIDDEN=TRUE>", fname);
ALLOC_CHECK(embedtagstr,id,abnormal_exit);
newTag = LO_CreateHiddenEmbedTag(tag,embedtagstr);
ALLOC_CHECK(newTag,id,abnormal_exit);
lo_FormatEmbed(context,state,newTag);
goto normal_exit;
abnormal_exit:
XP_Trace("npl_ScriptPlugin: Abnormal termination, id = %d",id);
if (urls) {
XP_FREEIF(urls->content_type);
XP_FREEIF(urls->content_name);
XP_FREEIF(urls->address);
XP_FREE( urls);
}
normal_exit:
XP_FREEIF(newTag);
XP_FREEIF(embedtagstr);
XP_FREEIF(fname);
XP_FREEIF(viewstream);
XP_FREEIF(suffix);
return;
}
