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

1554 строки
37 KiB
C++
Исходник Ответственный История

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
#include "nsNetStubs.h"
#include "nspr.h"
#include "xp_hash.h"
#include "xp_file.h"
#include "libi18n.h"
#include "libevent.h"
#include "mkgeturl.h"
#include "net.h"
#include "nsIRefreshUrl.h"
#include "nsString.h"
#include "nsNetStream.h"
extern "C" {
#include "secnav.h"
#include "preenc.h"
};
/* From libimg */
#define OPAQUE_CONTEXT void
/*
*---------------------------------------------------------------------------
* From ns/lib/libi18n/intl_csi.c
*---------------------------------------------------------------------------
*/
extern "C" {
#if defined(XP_UNIX)
DB *
dbopen(const char *fname, int flags,int mode, DBTYPE type,
const void *openinfo)
{
return NULL;
}
#endif
/* Meta charset is weakest. Only set doc_csid if no http or override */
void
INTL_SetCSIDocCSID (INTL_CharSetInfo c, int16 doc_csid)
{
MOZ_FUNCTION_STUB;
}
int16
INTL_GetCSIDocCSID(INTL_CharSetInfo c)
{
MOZ_FUNCTION_STUB;
return 0;
}
void
INTL_SetCSIWinCSID(INTL_CharSetInfo c, int16 win_csid)
{
MOZ_FUNCTION_STUB;
}
int16
INTL_GetCSIWinCSID(INTL_CharSetInfo c)
{
MOZ_FUNCTION_STUB;
return 0;
}
INTL_CharSetInfo
LO_GetDocumentCharacterSetInfo(MWContext *context)
{
MOZ_FUNCTION_STUB;
return NULL;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/libi18n/acptlang.c
*---------------------------------------------------------------------------
*/
/* INTL_GetAcceptCharset() */
/* return the AcceptCharset from XP Preference */
/* this should be a C style NULL terminated string */
char* INTL_GetAcceptCharset()
{
MOZ_FUNCTION_STUB;
return NULL;
}
/* INTL_GetAcceptLanguage() */
/* return the AcceptLanguage from XP Preference */
/* this should be a C style NULL terminated string */
char* INTL_GetAcceptLanguage()
{
MOZ_FUNCTION_STUB;
return NULL;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/libi18n/net_junk.c
*---------------------------------------------------------------------------
*/
PUBLIC Stream *
INTL_ConvCharCode (int format_out,
void *data_obj,
URL_Struct *URL_s,
MWContext *mwcontext)
{
MOZ_FUNCTION_STUB;
return NULL;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/libi18n/cvchcode.c
*---------------------------------------------------------------------------
*/
/* INTL_GetCharCodeConverter:
* RETURN: 1 if converter found, else 0
* Also, sets:
* obj->cvtfunc: function handle for chararcter
* code set streams converter
* obj->cvtflag: (Optional) flag to converter
* function
* obj->from_csid: Code set converting from
* obj->to_csid: Code set converting to
* If the arg to_csid==0, then use the the conversion for the
* first conversion entry that matches the from_csid.
*/
int
INTL_GetCharCodeConverter(register int16 from_csid,
register int16 to_csid,
CCCDataObject obj)
{
MOZ_FUNCTION_STUB;
return 0;
}
CCCDataObject
INTL_CreateCharCodeConverter()
{
MOZ_FUNCTION_STUB;
return NULL;
}
unsigned char *
INTL_CallCharCodeConverter(CCCDataObject obj, const unsigned char *buf,
int32 bufsz)
{
MOZ_FUNCTION_STUB;
return NULL;
}
void
INTL_DestroyCharCodeConverter(CCCDataObject obj)
{
MOZ_FUNCTION_STUB;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/libi18n/csnamefn.c
*---------------------------------------------------------------------------
*/
int16
INTL_CharSetNameToID(char *charset)
{
MOZ_FUNCTION_STUB;
return 0;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/libi18n/ucs2.c
*---------------------------------------------------------------------------
*/
uint32 INTL_TextToUnicode(
INTL_Encoding_ID encoding,
unsigned char* src,
uint32 srclen,
INTL_Unicode* ustr,
uint32 ubuflen
)
{
MOZ_FUNCTION_STUB;
return 0;
}
uint32 INTL_TextToUnicodeLen(
INTL_Encoding_ID encoding,
unsigned char* src,
uint32 srclen
)
{
MOZ_FUNCTION_STUB;
return 0;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/libi18n/fe_ccc.c
*---------------------------------------------------------------------------
*/
/*
INTL_DocToWinCharSetID,
Based on DefaultDocCSID, it determines which Win CSID to use for Display
*/
/*
To Do: (ftang)
We should seperate the DocToWinCharSetID logic from the cscvt_t table
for Cyrillic users.
*/
int16 INTL_DocToWinCharSetID(int16 csid)
{
MOZ_FUNCTION_STUB;
return CS_FE_ASCII;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/libi18n/doc_ccc.c
*---------------------------------------------------------------------------
*/
PUBLIC void INTL_CCCReportMetaCharsetTag(MWContext *context, char *charset_tag)
{
MOZ_FUNCTION_STUB;
}
/*
*---------------------------------------------------------------------------
* From ns/cmd/winfe/authdll.cpp
*---------------------------------------------------------------------------
*/
char * WFE_BuildCompuserveAuthString(URL_Struct *URL_s)
{
MOZ_FUNCTION_STUB;
return NULL;
}
int
WFE_DoCompuserveAuthenticate(MWContext *context,
URL_Struct *URL_s,
char *authenticate_header_value)
{
MOZ_FUNCTION_STUB;
return NET_AUTH_FAILED_DONT_DISPLAY;
}
/*
*---------------------------------------------------------------------------
* From ns/cmd/winfe/regproto.cpp
*---------------------------------------------------------------------------
*/
// Purpose: See if we're supposed to handle a specific protocol differently.
// Arguments: pContext The context.
// iFormatOut The format out (possibly saving).
// pURL The URL to load.
// pExitFunc The URL exit routine. If we handle the protocol, we use the function.
//Returns: BOOL TRUE We want to handle the protocol here.
// FALSE Netlib continues to handle the protocol.
//Comments: To work with certain DDE topics which can cause URLs of a specific protocol type to be handled by another
// application.
//Revision History:
// 01-17-95 created GAB
//
XP_Bool FE_UseExternalProtocolModule(MWContext *pContext, FO_Present_Types iFormatOut, URL_Struct *pURL,
Net_GetUrlExitFunc *pExitFunc)
{
MOZ_FUNCTION_STUB;
return FALSE;
}
/*
*---------------------------------------------------------------------------
* From ns/cmd/winfe/femess.cpp
*---------------------------------------------------------------------------
*/
//
// Prompt the user for a local file name
//
int FE_PromptForFileName(MWContext *context,
const char *prompt_string,
const char *default_path,
XP_Bool file_must_exist_p,
XP_Bool directories_allowed_p,
ReadFileNameCallbackFunction fn,
void *closure)
{
MOZ_FUNCTION_STUB;
return -1;
}
/*
*---------------------------------------------------------------------------
* From ns/cmd/winfe/fegui.cpp
*---------------------------------------------------------------------------
*/
// Return some spanked out full path on the mac.
// For windows, we just return what was passed in.
// We must provide it in a seperate buffer, otherwise they might change
// the original and change also what they believe to be saved.
char *WH_FilePlatformName(const char *pName)
{
MOZ_FUNCTION_STUB;
return NULL;
}
// Purpose: Set a delayed load timer for a window for a particular URL.
// Arguments: pContext The context that we're in. We are only interested on wether or not there appears to be a Frame/hence document.
// ulSeconds The number of seconds that will pass before we attempt the reload.
// Returns: void
// Comments:
// Revision History:
// 02-17-95 created GAB
// 07-22-95 modified to use new context.
// 05-03-96 modified to use new API outside of idle loop.
//
NS_DEFINE_IID(kRefreshURLIID, NS_IREFRESHURL_IID);
void FE_SetRefreshURLTimer(MWContext *pContext, uint32 seconds, char *pRefreshURL)
{
nsresult rv;
nsIRefreshUrl* IRefreshURL=nsnull;
nsString refreshURL(pRefreshURL);
nsConnectionInfo* pConn;
NS_PRECONDITION((pRefreshURL != nsnull), "Null pointer...");
NS_PRECONDITION((pContext != nsnull), "Null pointer...");
NS_PRECONDITION((pContext->modular_data != nsnull), "Null pointer...");
NS_PRECONDITION((pContext->modular_data->fe_data != nsnull), "Null pointer...");
// Get the nsConnectionInfo out of the context.
// modular_data points to a URL_Struct.
pConn = (nsConnectionInfo*) pContext->modular_data->fe_data;
NS_PRECONDITION((pConn != nsnull), "Null pointer...");
if (pConn) {
/* Get the pointer to the nsIRefreshURL from the nsISupports
* of the nsIContentViewerContainer the nsConnnectionInfo holds.
*/
rv = pConn->pContainer->QueryInterface(kRefreshURLIID, (void**)&IRefreshURL);
if(rv == NS_OK) {
nsIURL* aURL;
rv = NS_NewURL(&aURL, refreshURL);
if (rv == NS_OK) {
rv = IRefreshURL->RefreshURL(aURL, seconds*1000, FALSE);
NS_RELEASE(IRefreshURL);
NS_RELEASE(aURL);
}
}
}
MOZ_FUNCTION_STUB;
}
PUBLIC void
FE_ConnectToRemoteHost(MWContext * context, int url_type, char *
hostname, char * port, char * username)
{
MOZ_FUNCTION_STUB;
}
/*
*---------------------------------------------------------------------------
* From ns/cmd/winfe/feutil.cpp
*---------------------------------------------------------------------------
*/
// The purpose of FEU_AhAhAhAhStayingAlive is to house the one and only
// saturday night fever function; named after Chouck's idol.
// This function will attempt to do all that is necessary in order
// to keep the application's messages flowing and idle loops
// going when we need to finish an asynchronous operation
// synchronously.
// The current cases that cause this are RPC calls into the
// application where we need to return a value or produce output
// from only one entry point before returning to the caller.
//
// If and when you modify this function, get your changes reviewed.
// It is too vital that this work, always.
//
// The function only attempts to look at one message at a time, or
// propigate one idle call at a time, keeping it's own idle count.
// This is not a loop. YOU must provide the loop which calls this function.
//
// Due to the nature and order of which we process windows messages, this
// can seriously mess with the flow of control through the client.
// If there is any chance at all that you can ensure that you are at the
// bottom of the message queue before doing this, then please take those
// measures.
void FEU_StayingAlive()
{
MOZ_FUNCTION_STUB;
}
/*
*---------------------------------------------------------------------------
* From ns/cmd/winfe/cfe.cpp
*---------------------------------------------------------------------------
*/
void FE_RunNetcaster(MWContext *context)
{
MOZ_FUNCTION_STUB;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/xp/xp_cntxt.c
*---------------------------------------------------------------------------
*/
/*
* if the passed context is in the global context list
* TRUE is returned. Otherwise false
*/
Bool XP_IsContextInList(MWContext *context)
{
MOZ_FUNCTION_STUB;
return FALSE;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/xp/xplocale.c
*---------------------------------------------------------------------------
*/
size_t XP_StrfTime(MWContext* context, char *result, size_t maxsize, int format,
const struct tm *timeptr)
{
MOZ_FUNCTION_STUB;
return 0;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/layout/layutil.c
*---------------------------------------------------------------------------
*/
/*
* Return the width of the window for this context in chars in the default
* fixed width font. Return -1 on error.
*/
int16
LO_WindowWidthInFixedChars(MWContext *context)
{
MOZ_FUNCTION_STUB;
return 80;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/layout/layinfo.c
*---------------------------------------------------------------------------
*/
/*
* Prepare a bunch of information about the content of this
* document and prints the information as HTML down
* the passed in stream.
*
* Returns:
* -1 If the context passed does not correspond to any currently
* laid out document.
* 0 If the context passed corresponds to a document that is
* in the process of being laid out.
* 1 If the context passed corresponds to a document that is
* completly laid out and info can be found.
*/
PUBLIC intn
LO_DocumentInfo(MWContext *context, NET_StreamClass *stream)
{
MOZ_FUNCTION_STUB;
return -1;
}
#if 1
/*
*---------------------------------------------------------------------------
* From ns/modules/libimg/src/if.c
*---------------------------------------------------------------------------
*/
/*
* determine what kind of image data we are dealing with
*/
int
IL_Type(const char *buf, int32 len)
{
MOZ_FUNCTION_STUB;
return 0; /* IL_NOTFOUND */
}
/*
*---------------------------------------------------------------------------
* From ns/modules/libimg/src/ilclient.c
*---------------------------------------------------------------------------
*/
/*
* Create an HTML stream and generate HTML describing
* the image cache. Use "about:memory-cache" URL to acess.
*/
int
IL_DisplayMemCacheInfoAsHTML(FO_Present_Types format_out, URL_Struct *urls,
OPAQUE_CONTEXT *cx)
{
MOZ_FUNCTION_STUB;
return 0;
}
char *
IL_HTMLImageInfo(char *url_address)
{
MOZ_FUNCTION_STUB;
return NULL;
}
/* Set limit on approximate size, in bytes, of all pixmap storage used
by the imagelib. */
void
IL_SetCacheSize(uint32 new_size)
{
MOZ_FUNCTION_STUB;
}
/*
*---------------------------------------------------------------------------
* From ns/modules/libimg/src/external.c
*---------------------------------------------------------------------------
*/
NET_StreamClass *
IL_ViewStream(FO_Present_Types format_out, void *newshack, URL_Struct *urls,
OPAQUE_CONTEXT *cx)
{
MOZ_FUNCTION_STUB;
return NULL;
}
#endif
/*
*---------------------------------------------------------------------------
* From ns/lib/libmisc/glhist.c
*---------------------------------------------------------------------------
*/
PUBLIC void
NET_RegisterEnableUrlMatchCallback(void)
{
MOZ_FUNCTION_STUB;
}
/* start global history tracking
*/
PUBLIC void
GH_InitGlobalHistory(void)
{
MOZ_FUNCTION_STUB;
}
/* save the global history to a file while leaving the object in memory
*/
PUBLIC void
GH_SaveGlobalHistory(void)
{
MOZ_FUNCTION_STUB;
}
/* create an HTML stream and push a bunch of HTML about
* the global history
*/
MODULE_PRIVATE int
NET_DisplayGlobalHistoryInfoAsHTML(MWContext *context,
URL_Struct *URL_s,
int format_out)
{
MOZ_FUNCTION_STUB;
return MK_UNABLE_TO_CONVERT;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/libmisc/shist.c
*---------------------------------------------------------------------------
*/
PUBLIC int
SHIST_GetIndex(History * hist, History_entry * entry)
{
MOZ_FUNCTION_STUB;
return -1;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/plugin/npglue.c
*---------------------------------------------------------------------------
*/
XP_Bool
NPL_HandleURL(MWContext *cx, FO_Present_Types iFormatOut, URL_Struct *pURL, Net_GetUrlExitFunc *pExitFunc)
{
MOZ_FUNCTION_STUB;
return FALSE;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/libmocha/lm_taint.c
*---------------------------------------------------------------------------
*/
const char *
LM_SkipWysiwygURLPrefix(const char *url_string)
{
MOZ_FUNCTION_STUB;
return NULL;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/htmldlgs/htmldlgs.c
*---------------------------------------------------------------------------
*/
void
XP_HandleHTMLPanel(URL_Struct *url)
{
MOZ_FUNCTION_STUB;
}
void
XP_HandleHTMLDialog(URL_Struct *url)
{
MOZ_FUNCTION_STUB;
}
/*
*---------------------------------------------------------------------------
* From ns/nav-java/netscape/net/netStubs.c
*---------------------------------------------------------------------------
*/
/*
*---------------------------------------------------------------------------
* From ns/modules/softupdt/src/softupdt.c
*---------------------------------------------------------------------------
*/
/* New stream callback */
/* creates the stream, and a opens up a temporary file */
NET_StreamClass * SU_NewStream (int format_out, void * registration,
URL_Struct * request, MWContext *context)
{
MOZ_FUNCTION_STUB;
return NULL;
}
char **fe_encoding_extensions = NULL;
/*
*---------------------------------------------------------------------------
* From ns/lib/libmisc/glhist.c
*---------------------------------------------------------------------------
*/
PUBLIC void
GH_UpdateGlobalHistory(URL_Struct * URL_s)
{
MOZ_FUNCTION_STUB;
}
/* clear the global history list
*/
PUBLIC void
GH_ClearGlobalHistory(void)
{
MOZ_FUNCTION_STUB;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/libmisc/shist.c
*---------------------------------------------------------------------------
*/
PUBLIC History_entry *
SHIST_GetCurrent(History * hist)
{
MOZ_FUNCTION_STUB;
return NULL;
}
#ifdef XP_MAC
char *
WH_TempName(XP_FileType type, const char * prefix)
{
MOZ_FUNCTION_STUB;
return NULL;
}
#endif
/*
*---------------------------------------------------------------------------
* From ns/cmd/winfe/fegui.cpp
*---------------------------------------------------------------------------
*/
#ifdef XP_PC
/*
//
// Open a file with the given name
// If a special file type is provided we might need to get the name
// out of the preferences list
//
*/
PUBLIC XP_File
XP_FileOpen(const char * name, XP_FileType type, const XP_FilePerm perm)
{
MOZ_FUNCTION_STUB;
switch (type) {
case xpURL:
case xpFileToPost:
case xpHTTPCookie:
{
XP_File fp;
char* newName = WH_FileName(name, type);
if (!newName) return NULL;
fp = fopen(newName, (char *) perm);
XP_FREE(newName);
return fp;
}
default:
break;
}
return NULL;
}
/*
//
// Return 0 on success, -1 on failure.
//
*/
PUBLIC int
XP_FileRemove(const char * name, XP_FileType type)
{
MOZ_FUNCTION_STUB;
return -1;
}
/*
//
// Mimic unix stat call
// Return -1 on error
//
*/
PUBLIC int
XP_Stat(const char * name, XP_StatStruct * info, XP_FileType type)
{
int result = -1;
MOZ_FUNCTION_STUB;
switch (type) {
case xpURL:
case xpFileToPost: {
char *newName = WH_FileName(name, type);
if (!newName) return -1;
result = _stat( newName, info );
XP_FREE(newName);
break;
}
default:
break;
}
return result;
}
/*
// The caller is responsible for XP_FREE()ing the return string
*/
PUBLIC char *
WH_FileName (const char *NetName, XP_FileType type)
{
MOZ_FUNCTION_STUB;
if (type == xpHTTPCookie) {
#ifdef XP_PC
return PL_strdup("cookies.txt");
#else
return PL_strdup("cookies");
#endif
} else if ((type == xpURL) || (type == xpFileToPost)) {
/*
* This is the body of XP_NetToDosFileName(...) which is implemented
* for Windows only in fegui.cpp
*/
BOOL bChopSlash = FALSE;
char *p, *newName;
if(!NetName)
return NULL;
// If the name is only '/' or begins '//' keep the
// whole name else strip the leading '/'
if(NetName[0] == '/')
bChopSlash = TRUE;
// save just / as a path
if(NetName[0] == '/' && NetName[1] == '\0')
bChopSlash = FALSE;
// spanky Win9X path name
if(NetName[0] == '/' && NetName[1] == '/')
bChopSlash = FALSE;
if(bChopSlash)
newName = PL_strdup(&(NetName[1]));
else
newName = PL_strdup(NetName);
if(!newName)
return NULL;
if( newName[1] == '|' )
newName[1] = ':';
for(p = newName; *p; p++){
if( *p == '/' )
*p = '\\';
}
return(newName);
}
return NULL;
}
char *
WH_TempName(XP_FileType type, const char * prefix)
{
MOZ_FUNCTION_STUB;
return NULL;
}
PUBLIC XP_Dir
XP_OpenDir(const char * name, XP_FileType type)
{
MOZ_FUNCTION_STUB;
return NULL;
}
/*
//
// Close the directory
//
*/
PUBLIC void
XP_CloseDir(XP_Dir dir)
{
MOZ_FUNCTION_STUB;
}
PUBLIC XP_DirEntryStruct *
XP_ReadDir(XP_Dir dir)
{
MOZ_FUNCTION_STUB;
return NULL;
}
#endif /* XP_PC */
PUBLIC void *
FE_AboutData (const char *which,
char **data_ret, int32 *length_ret, char **content_type_ret)
{
MOZ_FUNCTION_STUB;
*data_ret = NULL;
*length_ret = 0;
*content_type_ret = NULL;
return NULL;
}
PUBLIC void
FE_FreeAboutData (void * data, const char* which2)
{
MOZ_FUNCTION_STUB;
}
/*
*---------------------------------------------------------------------------
* From ns/cmd/winfe/fenet.cpp
*---------------------------------------------------------------------------
*/
int FE_AsyncDNSLookup(MWContext *context, char * host_port, PRHostEnt ** hoststruct_ptr_ptr, PRFileDesc *socket)
{
MOZ_FUNCTION_STUB;
return -1;
}
/*
// INTL_ResourceCharSet(void)
//
*/
char *INTL_ResourceCharSet(void)
{
MOZ_FUNCTION_STUB;
return NULL;
}
/*
*---------------------------------------------------------------------------
* From ns/cmd/winfe/cfe.cpp
*---------------------------------------------------------------------------
*/
int32 FE_GetContextID(MWContext *pContext)
{
MOZ_FUNCTION_STUB;
return 0;
}
XP_Bool FE_IsNetcasterInstalled(void)
{
MOZ_FUNCTION_STUB;
return FALSE;
}
/*
// A Url has changed context.
// We need to mark it in the new context if it has ncapi_data (which we use
// to track such things under windows).
*/
void FE_UrlChangedContext(URL_Struct *pUrl, MWContext *pOldContext, MWContext *pNewContext)
{
MOZ_FUNCTION_STUB;
}
/*
*---------------------------------------------------------------------------
* From ns/cmd/winfe/urlecho.cpp
*---------------------------------------------------------------------------
*/
void FE_URLEcho(URL_Struct *pURL, int iStatus, MWContext *pContext) {
/*
// Purpose: Echo the URL to all appropriately registered applications that are monitoring such URL traffic.
// Arguments: pURL The URL which is being loaded.
// iStatus The status of the load.
// pContext The context in which the load occurred.
// Returns: void
// Comments: Well, sometimes there isn't a window in which the load occurred, what to do then?
// Just don't report.
// Revision History:
// 01-18-95 created GAB
//
*/
MOZ_FUNCTION_STUB;
}
/*
*---------------------------------------------------------------------------
* From ns/cmd/winfe/edview2.cpp
*---------------------------------------------------------------------------
*/
/*
// Note: This is used by Navigator's HTP UPLOAD as well as Composer's file saving
// DON'T ASSUME ANY EDITOR FUNCTIONALITY!
// Dialog to give feedback and allow canceling, overwrite protection
// when downloading remote files
//
*/
void FE_SaveDialogCreate( MWContext *pMWContext, int iFileCount, ED_SaveDialogType saveType )
{
MOZ_FUNCTION_STUB;
}
void FE_SaveDialogSetFilename( MWContext *pMWContext, char *pFilename )
{
MOZ_FUNCTION_STUB;
}
void FE_SaveDialogDestroy( MWContext *pMWContext, int status, char *pFileURL )
{
MOZ_FUNCTION_STUB;
}
/*
*---------------------------------------------------------------------------
* From ns/cmd/winfe/compmapi.cpp
*---------------------------------------------------------------------------
*/
void FE_AlternateCompose(
char * from, char * reply_to, char * to, char * cc, char * bcc,
char * fcc, char * newsgroups, char * followup_to,
char * organization, char * subject, char * references,
char * other_random_headers, char * priority,
char * attachment, char * newspost_url, char * body)
{
MOZ_FUNCTION_STUB;
}
/*
*---------------------------------------------------------------------------
* From ns/cmd/winfe/nethelp.cpp
*---------------------------------------------------------------------------
*/
MWContext *FE_GetNetHelpContext()
{
MOZ_FUNCTION_STUB;
return NULL;
}
/*
// Called from mkhelp.c to get the standard location of the NetHelp folder as a URL
*/
char * FE_GetNetHelpDir()
{
MOZ_FUNCTION_STUB;
return NULL;
}
/*
*---------------------------------------------------------------------------
* From ns/cmd/winfe/femess.cpp
*---------------------------------------------------------------------------
*/
int FE_GetURL(MWContext *pContext, URL_Struct *pUrl)
{
MOZ_FUNCTION_STUB;
return -1;
}
/*
*---------------------------------------------------------------------------
* From ns/cmd/winfe/fmabstra.cpp
*---------------------------------------------------------------------------
*/
void FE_RaiseWindow(MWContext *pContext)
{
MOZ_FUNCTION_STUB;
}
/*
*---------------------------------------------------------------------------
* From ns/cmd/winfe/fegrid.cpp
*---------------------------------------------------------------------------
*/
/*
// Create a new window.
// If pChrome is NULL, do a FE_MakeBlankWindow....
// pChrome specifies the attributes of a window.
// If you use this call, Toolbar information will not be saved in the preferences.
*/
MWContext *FE_MakeNewWindow(MWContext *pOldContext, URL_Struct *pUrl, char *pContextName, Chrome *pChrome)
{
MOZ_FUNCTION_STUB;
return NULL;
}
/*
*---------------------------------------------------------------------------
* From ns/cmd/winfe/timer.cpp
*---------------------------------------------------------------------------
*/
/* this function should register a function that will
* be called after the specified interval of time has
* elapsed. This function should return an id
* that can be passed to FE_ClearTimeout to cancel
* the Timeout request.
*
* A) Timeouts never fail to trigger, and
* B) Timeouts don't trigger *before* their nominal timestamp expires, and
* C) Timeouts trigger in the same ordering as their timestamps
*
* After the function has been called it is unregistered
* and will not be called again unless re-registered.
*
* func: The function to be invoked upon expiration of
* the Timeout interval
* closure: Data to be passed as the only argument to "func"
* msecs: The number of milli-seconds in the interval
*/
PUBLIC void *
FE_SetTimeout(TimeoutCallbackFunction func, void * closure, uint32 msecs)
{
MOZ_FUNCTION_STUB;
return NULL;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/libmocha/et_moz.c
*---------------------------------------------------------------------------
*/
JSBool
ET_PostMessageBox(MWContext* context, char* szMessage, JSBool bConfirm)
{
MOZ_FUNCTION_STUB;
return JS_FALSE;
}
/*
* Tell the backend about a new load event.
*/
void
ET_SendLoadEvent(MWContext * pContext, int32 type, ETVoidPtrFunc fnClosure,
NET_StreamClass *stream, int32 layer_id, Bool resize_reload)
{
MOZ_FUNCTION_STUB;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/libmocha/lm_doc.c
*---------------------------------------------------------------------------
*/
NET_StreamClass *
LM_WysiwygCacheConverter(MWContext *context, URL_Struct *url_struct,
const char * wysiwyg_url, const char * base_href)
{
MOZ_FUNCTION_STUB;
return NULL;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/libmocha/lm_win.c
*---------------------------------------------------------------------------
*/
/*
* Entry point for front-ends to notify JS code of help events.
*/
void
LM_SendOnHelp(MWContext *context)
{
MOZ_FUNCTION_STUB;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/xp/xplocale.c
*---------------------------------------------------------------------------
*/
const char* INTL_ctime(MWContext* context, time_t *date)
{
static char result[40];
MOZ_FUNCTION_STUB;
*result = '\0';
return result;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/xp/xp_cntxt.c
*---------------------------------------------------------------------------
*/
/*
* Finds a context that should be loaded with the URL, given
* a name and current (refering) context.
*
* If the context returned is not NULL, name is already assigned to context
* structure. You should load the URL into this context.
*
* If you get back a NULL, you should create a new window
*
* Both context and current context can be null.
* Once the grids are in, there should be some kind of a logic that searches
* siblings first.
*/
MWContext * XP_FindNamedContextInList(MWContext * context, char *name)
{
MOZ_FUNCTION_STUB;
return NULL;
}
MWContext*
XP_FindSomeContext()
{
MOZ_FUNCTION_STUB;
return NULL;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/plugin/npglue.c
*---------------------------------------------------------------------------
*/
/*
* This exit routine is used for all streams requested by the
* plug-in: byterange request streams, NPN_GetURL streams, and
* NPN_PostURL streams. NOTE: If the exit routine gets called
* in the course of a context switch, we must NOT delete the
* URL_Struct. Example: FTP post with result from server
* displayed in new window -- the exit routine will be called
* when the upload completes, but before the new context to
* display the result is created, since the display of the
* results in the new context gets its own completion routine.
*/
void
NPL_URLExit(URL_Struct *urls, int status, MWContext *cx)
{
MOZ_FUNCTION_STUB;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/layout/layedit.c
*---------------------------------------------------------------------------
*/
void LO_SetBaseURL( MWContext *context, char *pURL )
{
MOZ_FUNCTION_STUB;
}
/*
*---------------------------------------------------------------------------
* From ns/lib/layout/laysel.c
*---------------------------------------------------------------------------
*/
/*
get first(last) if current element is NULL.
*/
Bool
LO_getNextTabableElement( MWContext *context, LO_TabFocusData *pCurrentFocus, int forward )
{
MOZ_FUNCTION_STUB;
return FALSE;
}
PUBLIC int
NET_ParseNetHelpURL(URL_Struct *URL_s)
{
MOZ_FUNCTION_STUB;
/* return MK_OUT_OF_MEMORY; */
return -207;
}
#ifdef XP_UNIX
PUBLIC NET_StreamClass* NET_ExtViewerConverter ( FO_Present_Types format_out,
void *data_obj,
URL_Struct *URL_s,
MWContext *window_id)
{
return NULL;
}
#endif
/*
* From xp_str.c
*/
/* Allocate a new copy of a block of binary data, and returns it
*/
PUBLIC char *
NET_BACopy (char **destination, const char *source, size_t length)
{
if(*destination)
{
XP_FREE(*destination);
*destination = 0;
}
if (! source)
{
*destination = NULL;
}
else
{
*destination = (char *) PR_Malloc (length);
if (*destination == NULL)
return(NULL);
memcpy(*destination, source, length);
}
return *destination;
}
/* binary block Allocate and Concatenate
*
* destination_length is the length of the existing block
* source_length is the length of the block being added to the
* destination block
*/
PUBLIC char *
NET_BACat (char **destination,
size_t destination_length,
const char *source,
size_t source_length)
{
if (source)
{
if (*destination)
{
*destination = (char *) PR_Realloc (*destination, destination_length + source_length);
if (*destination == NULL)
return(NULL);
memmove (*destination + destination_length, source, source_length);
}
else
{
*destination = (char *) PR_Malloc (source_length);
if (*destination == NULL)
return(NULL);
memcpy(*destination, source, source_length);
}
}
return *destination;
}
/* Very similar to strdup except it free's too
*/
PUBLIC char *
NET_SACopy (char **destination, const char *source)
{
if(*destination)
{
XP_FREE(*destination);
*destination = 0;
}
if (! source)
{
*destination = NULL;
}
else
{
*destination = (char *) PR_Malloc (PL_strlen(source) + 1);
if (*destination == NULL)
return(NULL);
PL_strcpy (*destination, source);
}
return *destination;
}
/* Again like strdup but it concatinates and free's and uses Realloc
*/
PUBLIC char *
NET_SACat (char **destination, const char *source)
{
if (source && *source)
{
if (*destination)
{
int length = PL_strlen (*destination);
*destination = (char *) PR_Realloc (*destination, length + PL_strlen(source) + 1);
if (*destination == NULL)
return(NULL);
PL_strcpy (*destination + length, source);
}
else
{
*destination = (char *) PR_Malloc (PL_strlen(source) + 1);
if (*destination == NULL)
return(NULL);
PL_strcpy (*destination, source);
}
}
return *destination;
}
/* remove front and back white space
* modifies the original string
*/
PUBLIC char *
XP_StripLine (char *string)
{
char * ptr;
/* remove leading blanks */
while(*string=='\t' || *string==' ' || *string=='\r' || *string=='\n')
string++;
for(ptr=string; *ptr; ptr++)
; /* NULL BODY; Find end of string */
/* remove trailing blanks */
for(ptr--; ptr >= string; ptr--)
{
if(*ptr=='\t' || *ptr==' ' || *ptr=='\r' || *ptr=='\n')
*ptr = '\0';
else
break;
}
return string;
}
/************************************************************************/
char *XP_AppendStr(char *in, const char *append)
{
int alen, inlen;
alen = PL_strlen(append);
if (in) {
inlen = PL_strlen(in);
in = (char*) PR_Realloc(in,inlen+alen+1);
if (in) {
memcpy(in+inlen, append, alen+1);
}
} else {
in = (char*) PR_Malloc(alen+1);
if (in) {
memcpy(in, append, alen+1);
}
}
return in;
}
void RDF_AddCookieResource(char* name, char* path, char* host, char* expires)
{
MOZ_FUNCTION_STUB;
}
}; /* end of extern "C" */
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку