Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-31 22:25:30 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
6433017be7
gecko-dev/network/module/nsNetStubs.cpp
jdunn%netscape.com 08b49c00de remove compiler warning about no return value
1999-04-12 20:57:11 +00:00

2173 lines
51 KiB
C++
Raw Blame History

/* -*- 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"
#include "intl_csi.h"
#ifdef NS_NET_FILE
extern char *USER_DIR;
extern char *CACHE_DIR;
extern char *DEF_DIR;
// For xp to ns file translation
#include "nsINetFile.h"
#include "nsVoidArray.h"
#include "direct.h"
// The nsINetfile
static nsINetFile *fileMgr = nsnull;
typedef struct _xp_to_nsFile {
nsFile *nsFp;
XP_File xpFp;
} xpNSFile;
// Array of translation structs from xp to ns file.
static nsVoidArray switchBack;
// end xp to ns file translation
#endif // NS_NET_FILE
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) || defined(XP_MAC)
DB *
dbopen(const char *fname, int flags,int mode, DBTYPE type,
const void *openinfo)
{
#if defined(XP_MAC)
PR_ASSERT(FALSE);
#endif
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, URL_Struct *URL_s)
{
nsresult rv;
nsIRefreshUrl* IRefreshURL=nsnull;
nsString refreshURL(URL_s->refresh_url);
nsConnectionInfo* pConn;
NS_PRECONDITION((URL_s != 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 (nsnull != pConn) {
/* Get the pointer to the nsIRefreshURL from the nsISupports
* of the nsIContentViewerContainer the nsConnnectionInfo holds.
*/
if (nsnull != pConn->pURL) {
nsISupports* container;
rv = pConn->pURL->GetContainer(&container);
if (container && (rv == NS_OK)) {
rv = container->QueryInterface(kRefreshURLIID, (void**)&IRefreshURL);
if(NS_SUCCEEDED(rv)) {
nsIURL* newURL;
rv = NS_NewURL(&newURL, refreshURL);
if (NS_SUCCEEDED(rv)) {
rv = IRefreshURL->RefreshURL(newURL, URL_s->refresh*1000, FALSE);
NS_RELEASE(newURL);
}
NS_RELEASE(IRefreshURL);
}
NS_RELEASE(container);
}
}
}
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/edtutil.cpp
*---------------------------------------------------------------------------
*/
void EDT_SavePublishUsername(MWContext *pContext, char *pAddress, char *pUsername)
{
MOZ_FUNCTION_STUB;
}
/*
*---------------------------------------------------------------------------
* 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
*/
#ifndef XP_MAC
int
IL_Type(const char *buf, int32 len)
{
MOZ_FUNCTION_STUB;
return 0; /* IL_NOTFOUND */
}
#endif /* XP_MAC */
/*
*---------------------------------------------------------------------------
* 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.
*/
static int
IL_DisplayMemCacheInfoAsHTML(FO_Present_Types format_out, URL_Struct *urls,
OPAQUE_CONTEXT *cx)
{
MOZ_FUNCTION_STUB;
return 0;
}
#ifndef XP_MAC
char *
IL_HTMLImageInfo(char *url_address)
{
MOZ_FUNCTION_STUB;
return NULL;
}
#endif /* XP_MAC */
/* Set limit on approximate size, in bytes, of all pixmap storage used
by the imagelib. */
#ifndef XP_MAC
void
IL_SetCacheSize(uint32 new_size)
{
MOZ_FUNCTION_STUB;
}
#endif /* XP_MAC */
/*
*---------------------------------------------------------------------------
* From ns/modules/libimg/src/external.c
*---------------------------------------------------------------------------
*/
static 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;
}
/*
*---------------------------------------------------------------------------
* Needed by mkcache.c (at least)
*---------------------------------------------------------------------------
*/
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 NS_NET_FILE
// XXXXXXXXXXXXXXXXXXXXXXXXX NS_NET_FILE BEGIN XXXXXXXXXXXXXXXXXXXXXXXXX
// Begin nsNetFile versions of xp_file routines. These stubs utilize the new
// nsINetFile interface to do file i/o type things.
// Utility routine to remove a transator object from the array and free it.
nsresult deleteTrans(nsFile *nsFp) {
xpNSFile *trans = nsnull;
if (!nsFp)
return NS_OK;
for (PRInt32 i = switchBack.Count(); i > 0; i--) {
trans = (xpNSFile*)switchBack.ElementAt(i-1);
if (trans && trans->nsFp == nsFp) {
switchBack.RemoveElement(trans);
if (trans->xpFp) {
PR_Free(trans->xpFp);
trans->xpFp = nsnull;
}
PR_Free(trans);
return NS_OK;
}
}
return NS_ERROR_FAILURE;
}
// Utility routine to convert an xpFile pointer to a ns file pointer.
nsFile * XpToNsFp(XP_File xpFp) {
nsFile *nsFp = nsnull;
xpNSFile *trans = nsnull;
if (!xpFp)
return nsnull;
for (PRInt32 i = switchBack.Count(); i > 0; i--) {
trans = (xpNSFile*)switchBack.ElementAt(i-1);
if (trans && trans->xpFp == xpFp) {
nsFp = trans->nsFp;
break;
}
}
return nsFp;
}
/*
//
// 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
//
*/
/* List of old xpFile enums we need to support
* Don't need cache stuff as new cache module will do it's own disk i/o
xpCacheFAT
xpCache
xpSARCache
xpExtCacheIndex
xpProxyConfig
xpURL
xpJSConfig
xpTemporary
xpJSCookieFilters
xpFileToPost
xpMimeTypes
xpHTTPCookie
xpHTTPCookiePermission
xpHTTPSingleSignon*/
// Caller is repsonsible for freeing string.
PRIVATE
char *xpFileTypeToName(XP_FileType type) {
char *name = nsnull;
switch (type) {
case (xpCache):
return PL_strdup(CACHE_DIR_TOK);
break;
case (xpCacheFAT):
return PL_strdup(CACHE_DIR_TOK CACHE_DB_F_TOK);
break;
case (xpProxyConfig):
break;
case (xpURL):
break;
case (xpJSConfig):
break;
case (xpTemporary):
break;
case (xpJSCookieFilters):
break;
case (xpFileToPost):
break;
case (xpMimeTypes):
break;
case (xpHTTPCookie):
return PL_strdup("%USER%%COOKIE_F%");
case (xpHTTPCookiePermission):
return PL_strdup("%USER%%COOKIE_PERMISSION_F%");
#ifdef SingleSignon
case (xpHTTPSingleSignon):
return PL_strdup("%USER%%SIGNON_F%");
#endif
default:
break;
}
return nsnull;
}
/*
// The caller is responsible for XP_FREE()ing the return string
*/
PUBLIC char *
WH_FileName (const char *NetName, XP_FileType type)
{
char *path = nsnull, *aName = nsnull;
nsresult rv;
if (!NetName || !*NetName) {
aName = xpFileTypeToName(type);
if (!aName) {
return NULL;
}
}
if (!fileMgr) {
if (NS_NewINetFile(&fileMgr, nsnull) != NS_OK) {
return NULL;
}
}
rv = fileMgr->GetFilePath( (aName ? aName : NetName), &path);
PR_FREEIF(aName);
if (rv != NS_OK)
return NULL;
return path;
}
char *
WH_TempName(XP_FileType type, const char * prefix)
{
char *path = nsnull, *aName = nsnull;
nsresult rv;
aName = xpFileTypeToName(type);
if (!aName) {
return NULL;
}
if (!fileMgr) {
if (NS_NewINetFile(&fileMgr, nsnull) != NS_OK) {
return NULL;
}
}
rv = fileMgr->GetCacheFileName(aName, &path);
PR_FREEIF(aName);
if (rv != NS_OK)
return NULL;
return path;
}
PUBLIC int
NET_I_XP_Fileno(XP_File fp) {
nsFile *nsFp = XpToNsFp(fp); // nsnull ok.
NS_PRECONDITION( (nsFp != nsnull), "Null pointer.");
return (int) nsFp->fd;
}
PUBLIC int
NET_I_XP_FileSeek(XP_File fp, long offset, int origin) {
nsFile *nsFp = XpToNsFp(fp); // nsnull ok.
PRSeekWhence sw;
NS_PRECONDITION( (nsFp != nsnull), "Null pointer.");
/* Need to confirm the origin to PRSeekWhence mapping */
switch (origin) {
case (0):
sw = PR_SEEK_SET;
break;
case (1):
sw = PR_SEEK_CUR;
break;
case (2):
sw = PR_SEEK_END;
break;
default:
sw = PR_SEEK_SET;
}
return PR_Seek(nsFp->fd, offset, sw);
}
// Initialization routine for nsNetFile. This registers all the directories
// and files in the nsNetFile instance. Use the form:
// token = %token%
// value = opaque string
//
// Directories and files are platform specific.
PUBLIC PRBool
NET_InitFilesAndDirs(void) {
PRFileInfo dir;
PRStatus status;
char tmpBuf[_MAX_PATH];
#ifdef XP_PC
char *mDirDel = "\\";
#elif XP_MAC
char *mDirDel = ":";
#else
char *mDirDel = "/";
#endif
// Setup directories, step 1.
USER_DIR = _getcwd(USER_DIR, _MAX_PATH);
CACHE_DIR = _getcwd(CACHE_DIR, _MAX_PATH);
DEF_DIR = _getcwd(DEF_DIR, _MAX_PATH);
// setup the cache dir.
PL_strcpy(tmpBuf, CACHE_DIR);
sprintf(CACHE_DIR,"%s%s%s%s", tmpBuf, mDirDel, "cache", mDirDel);
status = PR_GetFileInfo(CACHE_DIR, &dir);
if (status == PR_FAILURE) {
// Create the dir.
status = PR_MkDir(CACHE_DIR, 0600);
if (status != PR_SUCCESS) {
; // bummer!
}
}
if (!fileMgr) {
if (NS_NewINetFile(&fileMgr, nsnull) != NS_OK) {
return FALSE;
}
}
// Setup directories.
fileMgr->SetDirectory(USER_DIR_TOK, USER_DIR);
fileMgr->SetDirectory(CACHE_DIR_TOK, CACHE_DIR);
fileMgr->SetDirectory(DEF_DIR_TOK, DEF_DIR);
// Setup files.
fileMgr->SetFileAssoc(COOKIE_FILE_TOK, COOKIE_FILE, USER_DIR_TOK);
fileMgr->SetFileAssoc(COOKIE_PERMISSION_FILE_TOK, COOKIE_PERMISSION_FILE, USER_DIR_TOK);
#ifdef SingleSignon
fileMgr->SetFileAssoc(SIGNON_FILE_TOK, SIGNON_FILE, USER_DIR_TOK);
#endif
fileMgr->SetFileAssoc(CACHE_DB_F_TOK, CACHE_DB_FILE, CACHE_DIR_TOK);
return TRUE;
}
PUBLIC XP_File
NET_I_XP_FileOpen(const char * name, XP_FileType type, const XP_FilePerm perm)
{
XP_File xpFp;
xpNSFile *trans = (xpNSFile*)PR_Malloc(sizeof(xpNSFile));
nsFile *nsFp = nsnull;
nsresult rv;
nsFileMode mode;
char *aName = nsnull;
if (!fileMgr) {
if (NS_NewINetFile(&fileMgr, nsnull) != NS_OK) {
return NULL;
}
}
// Just get some random address.
xpFp = (XP_File) PR_Malloc(1);
trans->xpFp= xpFp;
if ((!PL_strcasecmp(perm,XP_FILE_READ)) ||
(!PL_strcasecmp(perm,XP_FILE_READ_BIN))) {
mode = nsRead;
} else if (!PL_strcasecmp(perm,XP_FILE_WRITE)) {
mode = nsOverWrite;
} else if (!PL_strcasecmp(perm,XP_FILE_WRITE_BIN)) {
mode = nsOverWrite;
} else {
mode = nsReadWrite;
}
/* call OpenFile with nsNetFile syntax if necesary. */
if ( (!name || !*name)
|| type == xpCache ) {
char *tmpName = xpFileTypeToName(type);
nsString newName = tmpName;
PR_FREEIF(tmpName)
if (newName.Length() < 1) {
PR_Free(trans);
PR_Free(xpFp);
return NULL;
}
newName.Append(name);
aName = newName.ToNewCString();
}
rv = fileMgr->OpenFile( (aName ? aName : name), mode, &nsFp);
if (aName)
delete[] aName;
if (NS_OK != rv) {
return NULL;
}
trans->nsFp = nsFp;
switchBack.AppendElement(trans);
return xpFp;
}
PUBLIC char *
NET_I_XP_FileReadLine(char *outBuf, int outBufLen, XP_File fp) {
nsFile *nsFp = XpToNsFp(fp); // nsnull ok.
PRInt32 readBytes;
nsresult rv;
NS_PRECONDITION( (nsFp != nsnull), "Null pointer");
if (!nsFp)
return NULL;
if (!fileMgr)
return NULL;
rv = fileMgr->FileReadLine( nsFp, &outBuf, &outBufLen, &readBytes);
if (NS_OK != rv) {
return NULL;
}
return outBuf;
}
PUBLIC int
NET_I_XP_FileRead(char *outBuf, int outBufLen, XP_File fp) {
nsFile *nsFp = XpToNsFp(fp); // nsnull ok.
PRInt32 readBytes;
nsresult rv;
NS_PRECONDITION( (nsFp != nsnull), "Null pointer");
if (!nsFp)
return -1;
if (!fileMgr)
return -1;
rv = fileMgr->FileRead( nsFp, &outBuf, &outBufLen, &readBytes);
if (NS_OK != rv) {
return -1;
}
return (int) readBytes;
}
PUBLIC int
NET_I_XP_FileWrite(const char *buf, int bufLen, XP_File fp) {
nsFile *nsFp = XpToNsFp(fp); // nsnull ok.
PRInt32 wroteBytes;
PRInt32 len;
nsresult rv;
if (bufLen < 0)
len = PL_strlen(buf);
else
len = bufLen;
if (!nsFp)
return -1;
if (!fileMgr)
return NULL;
rv = fileMgr->FileWrite(nsFp, buf, &len, &wroteBytes);;
if (rv != NS_OK)
return NULL;
return (int) wroteBytes;
}
PUBLIC int
NET_I_XP_FileClose(XP_File fp) {
nsFile *nsFp = XpToNsFp(fp); // nsnull ok.
nsresult rv;
NS_PRECONDITION( (nsFp != nsnull), "Null pointer");
if (!fileMgr) {
if (NS_NewINetFile(&fileMgr, nsnull) != NS_OK) {
return 0;
}
}
rv = fileMgr->CloseFile(nsFp);
if (rv != NS_OK)
return 0;
deleteTrans(nsFp);
fp = nsnull;
return 1;
}
/*
//
// Return 0 on success, -1 on failure.
//
*/
PUBLIC int
NET_I_XP_FileRemove(const char * name, XP_FileType type)
{
char *path = nsnull, *aName = nsnull;
nsresult rv;
if ( (!name || !*name)
|| type == xpCache ) {
char *tmpName = xpFileTypeToName(type);
nsString newName = tmpName;
PR_FREEIF(tmpName);
if (newName.Length() < 1) {
return NULL;
}
newName.Append(name);
aName = newName.ToNewCString();
}
if (!fileMgr) {
if (NS_NewINetFile(&fileMgr, nsnull) != NS_OK) {
return NULL;
}
}
rv = fileMgr->FileRemove((aName ? aName : name));
if (aName)
delete[] aName;
if (rv != NS_OK)
return -1;
return 0;
}
PUBLIC int
NET_I_XP_Stat(const char * name, XP_StatStruct * info, XP_FileType type)
{
int result = -1;
PRFileInfo fileInfo;
PRStatus status;
char *newName, *tmpName;
nsString ourName;
char *path;
nsresult rv;
switch (type) {
case xpCache:
tmpName = xpFileTypeToName(type);
if (!tmpName)
return NULL;
ourName = tmpName;
PR_FREEIF(tmpName);
ourName.Append(name);
newName = ourName.ToNewCString();
if (!fileMgr) {
if (NS_NewINetFile(&fileMgr, nsnull) != NS_OK) {
delete[] newName;
return NULL;
}
}
rv = fileMgr->GetFilePath(newName, &path);
if (rv != NS_OK) {
delete[] newName;
return -1;
}
status = PR_GetFileInfo(path, &fileInfo);
PR_Free(path);
delete[] newName;
if (status == PR_SUCCESS) {
// transfer the pr stat info over to the xp stat object.
// right now just moving over the size.
info->st_size = fileInfo.size;
return 0;
}
break;
case xpURL:
case xpFileToPost: {
newName = WH_FileName(name, type);
if (!newName) return -1;
result = _stat( newName, info );
PR_Free(newName);
break;
}
default:
break;
}
return result;
}
PUBLIC XP_Dir
NET_I_XP_OpenDir(const char * name, XP_FileType type)
{
MOZ_FUNCTION_STUB;
return NULL;
}
PUBLIC void
NET_I_XP_CloseDir(XP_Dir dir)
{
MOZ_FUNCTION_STUB;
}
/*
//
// Close the directory
//
*/
PUBLIC XP_DirEntryStruct *
NET_I_XP_ReadDir(XP_Dir dir)
{
MOZ_FUNCTION_STUB;
return NULL;
}
// XXXXXXXXXXXXXXXXXXXXXXXXX NS_NET_FILE END XXXXXXXXXXXXXXXXXXXXXXXXX
#endif /* NS_NET_FILE */
#ifdef XP_MAC
char *
WH_TempName(XP_FileType type, const char * prefix)
{
MOZ_FUNCTION_STUB;
return NULL;
}
#endif
// Begin vanilla versions of xp_file routines. These are simply stubs.
#ifdef XP_PC
#ifndef NS_NET_FILE
char *
WH_TempName(XP_FileType type, const char * prefix)
{
MOZ_FUNCTION_STUB;
return NULL;
}
/*
// 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 == xpHTTPCookiePermission) {
#ifdef XP_PC
return PL_strdup("cookperm.txt");
#else
return PL_strdup("cookperm");
#endif
} else if (type == xpHTTPSingleSignon) {
#ifdef XP_PC
return PL_strdup("signons.txt");
#else
return PL_strdup("signons");
#endif
} else if (type == xpCacheFAT) {
;// sprintf(newName, "%s\\fat.db", (const char *)theApp.m_pCacheDir);
} else if ((type == xpURL) || (type == xpFileToPost)) {
/*
* This is the body of XP_NetToDosFileName(...) which is implemented
* for Windows only in fegui.cpp
*/
XP_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;
}
#endif // !NS_NET_FILE
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:
case xpHTTPCookiePermission:
#ifdef SingleSignon
case xpHTTPSingleSignon:
#endif
{
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;
}
PUBLIC XP_Dir
XP_OpenDir(const char * name, XP_FileType type)
{
MOZ_FUNCTION_STUB;
return NULL;
}
PUBLIC void
XP_CloseDir(XP_Dir dir)
{
MOZ_FUNCTION_STUB;
}
PUBLIC XP_DirEntryStruct *
XP_ReadDir(XP_Dir dir)
{
MOZ_FUNCTION_STUB;
return NULL;
}
PUBLIC int
XP_FileRemove(const char * name, XP_FileType type)
{
if (PR_Delete(name) == PR_SUCCESS)
return 0;
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;
}
#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;
fprintf(stdout, "%c%s (y/n)? ", '\007', szMessage); /* \007 is BELL */
char c;
for (;;) {
c = getchar();
if (tolower(c) == 'y') {
return JS_TRUE;
}
if (tolower(c) == 'n') {
return JS_FALSE;
}
}
return JS_FALSE;
}
JSBool
ET_PostCheckConfirmBox(MWContext* context,
char* szMainMessage, char* szCheckMessage,
char* szOKMessage, char* szCancelMessage,
XP_Bool *bChecked)
{
MOZ_FUNCTION_STUB;
fprintf(stdout, "%c%s (y/n)? ", '\007', szMainMessage); /* \007 is BELL */
char c;
XP_Bool result;
for (;;) {
c = getchar();
if (tolower(c) == 'y') {
result = JS_TRUE;
break;
}
if (tolower(c) == 'n') {
result = JS_FALSE;
break;
}
}
fprintf(stdout, "%c%s y/n? ", '\007', szCheckMessage); /* \007 is BELL */
for (;;) {
c = getchar();
if (tolower(c) == 'y') {
*bChecked = TRUE;
break;
}
if (tolower(c) == 'n') {
*bChecked = FALSE;
break;
}
}
return result;
}
/*
* 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" */
Reference in New Issue View Git Blame Copy Permalink