/* -*- 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" */