开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
filestub.c
资源名称：nss-3.1.1.tar.gz　[点击查看]
上传用户：lyxiangda
上传日期：2007-01-12
资源大小：3042k
文件大小：31k
源码类别：

CA认证

开发平台：

WINDOWS

filestub.c：源码内容
  1. /* 
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is the Netscape security libraries.
  13.  * 
  14.  * The Initial Developer of the Original Code is Netscape
  15.  * Communications Corporation.  Portions created by Netscape are 
  16.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  17.  * Rights Reserved.
  18.  * 
  19.  * Contributor(s):
  20.  * 
  21.  * Alternatively, the contents of this file may be used under the
  22.  * terms of the GNU General Public License Version 2 or later (the
  23.  * "GPL"), in which case the provisions of the GPL are applicable 
  24.  * instead of those above.  If you wish to allow use of your 
  25.  * version of this file only under the terms of the GPL and not to
  26.  * allow others to use your version of this file under the MPL,
  27.  * indicate your decision by deleting the provisions above and
  28.  * replace them with the notice and other provisions required by
  29.  * the GPL.  If you do not delete the provisions above, a recipient
  30.  * may use your version of this file under either the MPL or the
  31.  * GPL.
  32.  */
  33. #define CMD_STUB 1 /* this is just a stub for security/cmd/*  */
  34. #define MOZ_LITE 1 /* don't need that other stuff, either */
  36. #if 0
  37. #include "stdafx.h"
  38. #include "dialog.h"
  39. #include "mainfrm.h"
  40. #include "custom.h"
  41. #include "shcut.h"
  42. #include "edt.h"
  43. #include "prmon.h"
  44. #include "fegui.h"
  45. #include "prefapi.h"
  46. #include <io.h>
  47. #include "secrng.h"
  48. #include "mailass.h"
  49. #include "ipframe.h"
  50. #include "mnprefs.h"
  52. #else
  54. #include <xp_core.h>
  55. #include <xp_file.h>
  56. #include <xp_mcom.h>
  58. #define ASSERT assert
  59. #endif
  61. #ifdef XP_MAC
  62. #include "prpriv.h" /* For PR_NewNamedMonitor */
  63. #else
  64. #include "private/prpriv.h"
  65. #endif
  67. #ifdef XP_WIN
  69. #ifndef _AFXDLL
  70. /* MSVC Debugging new...goes to regular new in release mode */
  71. #define new DEBUG_NEW  
  72. #endif
  74. #ifdef __BORLANDC__
  75.     #define _lseek lseek
  76. #endif
  77.        
  78. #define WIDTHBYTES(i) ((i + 31) / 32 * 4)
  79. #define MAXREAD 32767
  80.        
  81. MODULE_PRIVATE char * XP_CacheFileName();
  83. #define MAXSTRINGLEN 8192 
  85. #ifndef CMD_STUB
  87. /* Return a string the same as the In string 
  88. ** but with all of the n's replaced with rn's  
  89. */
  90. MODULE_PRIVATE char * 
  91. FE_Windowsify(const char * In)
  92. {
  93.     char *Out;
  94.     char *o, *i; 
  95.     int32 len;
  97.     if(!In)
  98.         return NULL;
  100.     /* if every character is a n then new string is twice as long */
  101.     len = (int32) XP_STRLEN(In) * 2 + 1;
  102.     Out = (char *) XP_ALLOC(len);
  103.     if(!Out)
  104.         return NULL;
  106.   /* Move the characters over one by one.  If the current character is */
  107.   /*  a n replace add a r before moving the n over */
  108.     for(i = (char *) In, o = Out; i && *i; *o++ = *i++)
  109.        if(*i == 'n')
  110.             *o++ = 'r';
  112.     /* Make sure our new string is NULL terminated */
  113.     *o = '';
  114.     return(Out);
  115. }
  118. /*  Return some adjusted out full path on the mac. */
  119. /*  For windows, we just return what was passed in. */
  120. /*  We must provide it in a seperate buffer, otherwise they might change */
  121. /*      the original and change also what they believe to be saved. */
  122. char *
  123. WH_FilePlatformName(const char *pName)    
  124. {
  126.     if(pName)   {
  127.         return XP_STRDUP(pName);
  128.     }
  129.     
  130.     return NULL;
  131. }
  134. char *
  135. FE_GetProgramDirectory(char *buffer, int length)
  136. {
  137.     ::GetModuleFileName(theApp.m_hInstance, buffer, length);
  139.     /* Find the trailing slash. */
  140.     char *pSlash = ::strrchr(buffer, '\');
  141.     if(pSlash) {
  142. *(pSlash+1) = '';
  143.     } else {
  144. buffer[0] = '';
  145.     }
  146.     return (buffer);
  147. }
  150. char*
  151. XP_TempDirName(void)
  152. {
  153.     char *tmp = theApp.m_pTempDir;
  154.     if (!tmp)
  155.         return XP_STRDUP(".");
  156.     return XP_STRDUP(tmp);
  157. }
  159. /* Windows _tempnam() lets the TMP environment variable override things sent 
  160. ** in so it look like we're going to have to make a temp name by hand.
  162. ** The user should *NOT* free the returned string.  
  163. ** It is stored in static space 
  164. ** and so is not valid across multiple calls to this function.
  166. ** The names generated look like 
  167. **   c:netscapecachem0.moz 
  168. **   c:netscapecachem1.moz 
  169. ** up to... 
  170. **   c:netscapecachem9999999.moz 
  171. ** after that if fails 
  172. ** */
  173. PUBLIC char *
  174. xp_TempFileName(int type, const char * request_prefix, const char * extension,
  175. char* file_buf)
  176. {
  177.     const char * directory = NULL; 
  178.     char * ext = NULL;           /* file extension if any */
  179.     char * prefix = NULL;        /* file prefix if any */
  180.   
  181.   
  182.     XP_StatStruct statinfo;
  183.     int status;     
  185.     /* */
  186.     /* based on the type of request determine what directory we should be */
  187.     /*   looking into */
  188.     /*   */
  189.     switch(type) {
  190.     case xpCache:
  191.         directory = theApp.m_pCacheDir;
  192.         ext = ".MOZ";
  193.         prefix = CACHE_PREFIX;
  194.         break;
  195. #ifndef MOZ_LITE        
  196.     case xpSNewsRC:
  197.     case xpNewsRC:
  198.     case xpNewsgroups:
  199.     case xpSNewsgroups:
  200.     case xpTemporaryNewsRC:
  201.         directory = g_MsgPrefs.m_csNewsDir;
  202.         ext = (char *)extension;
  203.         prefix = (char *)request_prefix;
  204.         break;
  205.     case xpMailFolderSummary:
  206.     case xpMailFolder:
  207. directory = g_MsgPrefs.m_csMailDir;
  208.         ext = (char *)extension;
  209.         prefix = (char *)request_prefix;
  210. break;
  211.     case xpAddrBook:
  212. /*changed to support multi-profile */
  213. /*directory = theApp.m_pInstallDir->GetCharValue(); */
  214. directory = (const char *)theApp.m_UserDirectory;
  215. if ((request_prefix == 0) || (XP_STRLEN (request_prefix) == 0))
  216. prefix = "abook";
  217. ext = ".nab";
  218. break;
  219. #endif /* MOZ_LITE       */
  220.     case xpCacheFAT:
  221. directory = theApp.m_pCacheDir;
  222. prefix = "fat";
  223. ext = "db";
  224. break;
  225.     case xpJPEGFile:
  226.         directory = theApp.m_pTempDir;
  227. ext = ".jpg";
  228.         prefix = (char *)request_prefix;
  229. break;
  230.     case xpPKCS12File:
  231. directory = theApp.m_pTempDir;
  232. ext = ".p12";
  233. prefix = (char *)request_prefix;
  234. break;
  235.     case xpTemporary:
  236.     default:
  237.         directory = theApp.m_pTempDir;
  238.         ext = (char *)extension;
  239.         prefix = (char *)request_prefix;
  240.         break;
  241.     }
  243.     if(!directory)
  244.         return(NULL);
  246.     if(!prefix)
  247.         prefix = "X";
  249.     if(!ext)
  250.         ext = ".TMP";
  252.   /*  We need to base our temporary file names on time, and not on sequential */
  253.   /*    addition because of the cache not being updated when the user */
  254.   /*    crashes and files that have been deleted are over written with */
  255.   /*    other files; bad data. */
  256.   /*  The 52 valid DOS file name characters are */
  257.   /*    0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_^$~!#%&-{}@`'() */
  258.   /*  We will only be using the first 32 of the choices. */
  259.   /* */
  260.   /*  Time name format will be M+++++++.MOZ */
  261.   /*    Where M is the single letter prefix (can be longer....) */
  262.   /*    Where +++++++ is the 7 character time representation (a full 8.3 */
  263.   /*      file name will be made). */
  264.   /*    Where .MOZ is the file extension to be used. */
  265.   /* */
  266.   /*  In the event that the time requested is the same time as the last call */
  267.   /*    to this function, then the current time is incremented by one, */
  268.   /*    as is the last time called to facilitate unique file names. */
  269.   /*  In the event that the invented file name already exists (can't */
  270.   /*    really happen statistically unless the clock is messed up or we */
  271.   /*    manually incremented the time), then the times are incremented */
  272.   /*    until an open name can be found. */
  273.   /* */
  274.   /*  time_t (the time) has 32 bits, or 4,294,967,296 combinations. */
  275.   /*  We will map the 32 bits into the 7 possible characters as follows: */
  276.   /*    Starting with the lsb, sets of 5 bits (32 values) will be mapped */
  277.   /*      over to the appropriate file name character, and then */
  278.   /*      incremented to an approprate file name character. */
  279.   /*    The left over 2 bits will be mapped into the seventh file name */
  280.   /*      character. */
  281.   /* */
  282.     
  283.     int i_letter, i_timechars, i_numtries = 0;
  284.     char ca_time[8];
  285.     time_t this_call = (time_t)0;
  286.     
  287.     /*  We have to base the length of our time string on the length */
  288.     /*    of the incoming prefix.... */
  289.     /* */
  290.     i_timechars = 8 - strlen(prefix);
  291.     
  292.     /*  Infinite loop until the conditions are satisfied. */
  293.     /*  There is no danger, unless every possible file name is used. */
  294.     /* */
  295.     while(1)    {
  296.         /*    We used to use the time to generate this. */
  297.         /*    Now, we use some crypto to avoid bug #47027 */
  298.         RNG_GenerateGlobalRandomBytes((void *)&this_call, sizeof(this_call));
  300.         /*  Convert the time into a 7 character string. */
  301.         /*  Strip only the signifigant 5 bits. */
  302.         /*  We'll want to reverse the string to make it look coherent */
  303.         /*    in a directory of file names. */
  304.         /* */
  305.         for(i_letter = 0; i_letter < i_timechars; i_letter++) {
  306.             ca_time[i_letter] = (char)((this_call >> (i_letter * 5)) & 0x1F);
  307.             
  308.           /*  Convert any numbers to their equivalent ascii code */
  309.           /* */
  310.             if(ca_time[i_letter] <= 9)    {
  311.                 ca_time[i_letter] += '0';
  312.             }
  313.           /*  Convert the character to it's equivalent ascii code */
  314.           /* */
  315.             else    {
  316.                 ca_time[i_letter] += 'A' - 10;
  317.             }
  318.         }
  319.         
  320.         /*  End the created time string. */
  321.         /* */
  322.         ca_time[i_letter] = '';
  323.         
  324.         /*  Reverse the time string. */
  325.         /* */
  326.         _strrev(ca_time);
  327.         
  328.         /*  Create the fully qualified path and file name. */
  329.         /* */
  330.         sprintf(file_buf, "%s\%s%s%s", directory, prefix, ca_time, ext);
  332.         /*  Determine if the file exists, and mark that we've tried yet */
  333.         /*    another file name (mark to be used later). */
  334.         /*   */
  335.         /*  Use the system call instead of XP_Stat since we already */
  336.         /*  know the name and we don't want recursion */
  337.         /* */
  338.         status = _stat(file_buf, &statinfo);
  339.         i_numtries++;
  341.         /*  If it does not exists, we are successful, return the name. */
  342.         /* */
  343.         if(status == -1)    {
  344.            /* don't generate a directory as part of the cache temp names.    
  345.     * When the cache file name is passed into the other XP_File 
  346.     * functions we will append the cache directory to the name
  347.             * to get the complete path.
  348.             * This will allow the cache to be moved around
  349.             * and for netscape to be used to generate external cache FAT's.    
  350.             */
  351.             if(type == xpCache )
  352. sprintf(file_buf, "%s%s%s", prefix, ca_time, ext);
  354.             TRACE("Temp file name is %sn", file_buf);
  355.             return(file_buf);
  356.         }
  357.         
  358.         /*  If there is no room for additional characters in the time, */
  359.         /*    we'll have to return NULL here, or we go infinite. */
  360.         /*    This is a one case scenario where the requested prefix is */
  361.         /*    actually 8 letters long!   */
  362.         /*  Infinite loops could occur with a 7, 6, 5, etc character prefixes */
  363.         /*    if available files are all eaten up (rare to impossible), in */
  364.         /*    which case, we should check at some arbitrary frequency of */
  365.         /*    tries before we give up instead of attempting to Vulcanize */
  366.         /*    this code.  Live long and prosper. */
  367.         /* */
  368.         if(i_timechars == 0)    {
  369.             break;
  370.         } else if(i_numtries == 0x00FF) {
  371.             break;
  372.         }
  373.     }
  374.     
  375.     /*  Requested name is thought to be impossible to generate. */
  376.     /* */
  377.     TRACE("No more temp file names....n");
  378.     return(NULL);
  380. }
  382. PUBLIC char *
  383. WH_TempFileName(int type, const char * request_prefix, const char * extension)
  384. {
  385.     static char file_buf[_MAX_PATH]; /* protected by _pr_TempName_lock */
  386.     char* result;
  388.     if (_pr_TempName_lock == NULL)
  389. _pr_TempName_lock = PR_NewNamedMonitor("TempName-lock");
  390.     PR_EnterMonitor(_pr_TempName_lock);
  392.     result = XP_STRDUP(xp_TempFileName(type, request_prefix, extension, file_buf));
  393.     PR_ExitMonitor(_pr_TempName_lock);
  394.     return result;
  395. }
  397. #endif /* CMD_STUB */
  399. /* */
  400. /* Return a string that is equal to the NetName string but with the */
  401. /*  cross-platform characters changed back into DOS characters */
  402. /* The caller is responsible for XP_FREE()ing the string */
  403. /* */
  404. MODULE_PRIVATE char * 
  405. XP_NetToDosFileName(const char * NetName)
  406. {
  407.     char *p, *newName;
  408.     BOOL bChopSlash = FALSE;
  410.     if(!NetName)
  411.         return NULL;
  412.         
  413.     /*  If the name is only '/' or begins '//' keep the */
  414.     /*    whole name else strip the leading '/' */
  416.     if(NetName[0] == '/')
  417.         bChopSlash = TRUE;
  419.     /* save just / as a path */
  420.     if(NetName[0] == '/' && NetName[1] == '')
  421. bChopSlash = FALSE;
  423.     /* spanky Win9X path name */
  424.     if(NetName[0] == '/' && NetName[1] == '/')
  425. bChopSlash = FALSE;
  427.     if(bChopSlash)
  428.         newName = XP_STRDUP(&(NetName[1]));
  429.     else
  430.         newName = XP_STRDUP(NetName);
  432.     if(!newName)
  433.         return NULL;
  435.     for(p = newName; *p; p++) {
  436.         switch(*p) {
  437.             case '|':
  438.                 *p = ':';
  439.                 break;
  440.             case '/':
  441.                 *p = '\';
  442.                 break;
  443.             default:
  444.                 break;
  445.         }
  446.     }
  448.     return(newName);
  450. }
  453. /* */
  454. /* Returns the absolute name of a file  */
  455. /*  */
  456. /* The result of this function can be used with the standard */
  457. /* open/fopen ansi file functions */
  458. /* */
  459. PUBLIC char * 
  460. xp_FileName(const char * name, XP_FileType type, char* *myName)
  461. {
  462.     char * newName    = NULL;
  463.     char * netLibName = NULL;
  464.     char * tempName   = NULL;
  465.     char * prefStr    = NULL;
  466.     BOOL   bNeedToRegister = FALSE;   /* == do we need to register a new  */
  467.                                       /*   newshost->file name mapping */
  468.     struct _stat sInfo;
  469.     int iDot;
  470.     int iColon;
  472. #ifndef CMD_STUB
  473.     CString csHostName;
  474.     CString csHost;
  475.     CString fileName;
  476. #endif
  478.     switch(type) {
  480. #ifndef CMD_STUB
  481.     case xpCacheFAT:
  482. newName = (char *) XP_ALLOC(_MAX_PATH);
  483. sprintf(newName, "%s\fat.db", (const char *)theApp.m_pCacheDir);
  484. break;
  485.     case xpExtCacheIndex:
  486. newName = (char *) XP_ALLOC(_MAX_PATH);
  487. sprintf(newName, "%s\extcache.fat", (const char *)theApp.m_pCacheDir);
  488. break;
  490.     case xpSARCacheIndex:
  491.         newName = (char *) XP_ALLOC(_MAX_PATH);
  492.         sprintf(newName, "%s\archive.fat", theApp.m_pSARCacheDir);
  493.         break;
  495.     case xpHTTPCookie:
  496. newName = (char *) XP_ALLOC(_MAX_PATH);
  497. /*sprintf(newName, "%s\cookies.txt", theApp.m_pInstallDir->GetCharValue()); */
  498. /* changed to support multi-profile */
  499. sprintf(newName, "%s\cookies.txt", (const char *)theApp.m_UserDirectory);
  500. break;
  501. #ifndef MOZ_LITE      
  502.     case xpSNewsRC:
  503.     case xpNewsRC:
  504.         /* see if we are asking about the default news host */
  505.         /* else look up in netlib */
  506.         if ( !name || !strlen(name) )
  507.             name = g_MsgPrefs.m_csNewsHost;
  509.         netLibName = NET_MapNewsrcHostToFilename((char *)name, 
  510.                                                  (type == xpSNewsRC),
  511.                                                  FALSE);
  512.         
  513.         /* if we found something in our map just skip the rest of this */
  514.         if(netLibName && *netLibName) {
  515.             newName = XP_STRDUP(netLibName);
  516.             break;
  517.         }
  519.         /* whatever name we eventually end up with we will need to register it */
  520.         /*   before we leave the function */
  521.         bNeedToRegister = TRUE;
  523.         /* If we are on the default host see if there is a newsrc file in the */
  524.         /*   news directory.  If so, that is what we want */
  525.         if(!stricmp(name, g_MsgPrefs.m_csNewsHost)) {
  526.             csHostName = g_MsgPrefs.m_csNewsDir;
  527.             csHostName += "\newsrc";
  528.             if(_stat((const char *) csHostName, &sInfo) == 0) {
  529.                 newName = XP_STRDUP((const char *) csHostName);
  530.                 break;
  531.             }
  532.         }
  533.                         
  534.         /* See if we are going to be able to build a file name based  */
  535.         /*   on the hostname */
  536.         csHostName = g_MsgPrefs.m_csNewsDir;
  537.         csHostName += '\';
  539.         /* build up '<hostname>.rc' so we can tell how long its going to be */
  540.         /*   we will use that as the default name to try */
  541. if(type == xpSNewsRC)
  542. csHost += 's';
  543.         csHost += name;
  545.         /* if we have a news host news.foo.com we just want to use the "news" */
  546.         /*   part */
  547.         iDot = csHost.Find('.');
  548.         if(iDot != -1)
  549.             csHost = csHost.Left(iDot);
  551. #ifdef XP_WIN16
  552.         if(csHost.GetLength() > 8)
  553.             csHost = csHost.Left(8);
  554. #endif
  556. iColon = csHost.Find(':');
  557. if (iColon != -1) {
  558. /* Windows file system seems to do horrid things if you have */
  559. /* a filename with a colon in it. */
  560. csHost = csHost.Left(iColon);
  561. }
  563.         csHost += ".rc";
  565.         /* csHost is now of the form <hostname>.rc and is in 8.3 format */
  566.         /*   if we are on a Win16 box */
  568.         csHostName += csHost;
  570.         /* looks like a file with that name already exists -- panic */
  571.         if(_stat((const char *) csHostName, &sInfo) != -1) {
  572.             
  573.             char host[5];
  575.             /* else generate a new file in news directory */
  576.             strncpy(host, name, 4);
  577.             host[4] = '';
  579.             newName = WH_TempFileName(type, host, ".rc");
  580.             if(!newName)
  581.                 return(NULL);
  583.         } else {
  585.             newName = XP_STRDUP((const char *) csHostName);
  587.         }
  589.   break;
  590.     case xpNewsrcFileMap:
  591.         /* return name of FAT file in news directory */
  592. newName = (char *) XP_ALLOC(_MAX_PATH);
  593. sprintf(newName, "%s\fat", (const char *)g_MsgPrefs.m_csNewsDir);
  594. break;
  595.     case xpNewsgroups:
  596.     case xpSNewsgroups:
  597.         /* look up in netlib */
  598.         if ( !name || !strlen(name) )
  599.             name = g_MsgPrefs.m_csNewsHost;
  601.         netLibName = NET_MapNewsrcHostToFilename((char *)name, 
  602.                                                  (type == xpSNewsgroups),
  603.                                                  TRUE);
  605.         if(!netLibName) {
  607.             csHostName = g_MsgPrefs.m_csNewsDir;
  608.             csHostName += '\';
  610.     if(type == xpSNewsgroups)
  611.     csHost += 's';
  612.             csHost += name;
  614.             /* see if we can just use "<hostname>.rcg" */
  615.             /* it might be news.foo.com so just take "news" */
  616.             int iDot = csHost.Find('.');
  617.             if(iDot != -1)
  618.                 csHost = csHost.Left(iDot);
  620. #ifdef XP_WIN16
  621.             if(csHost.GetLength() > 8)
  622.                 csHost = csHost.Left(8);
  623. #endif
  625.     iColon = csHost.Find(':');
  626.     if (iColon != -1) {
  627.     /* Windows file system seems to do horrid things if you have */
  628.     /* a filename with a colon in it. */
  629.     csHost = csHost.Left(iColon);
  630.     }
  632.             csHost += ".rcg";
  634.             /* csHost is now of the form <hostname>.rcg */
  636.             csHostName += csHost;
  638.             /* looks like a file with that name already exists -- panic */
  639.             if(_stat((const char *) csHostName, &sInfo) != -1) {
  640.                 
  641.                 char host[5];
  643.                 /* else generate a new file in news directory */
  644.                 strncpy(host, name, 4);
  645.                 host[4] = '';
  647.                 newName = WH_TempFileName(type, host, ".rcg");
  648.                 if(!newName)
  649.                     return(NULL);
  651.             } else {
  653.                 newName = XP_STRDUP((const char *) csHostName);
  655.             }
  657.             if ( !name || !strlen(name))
  658.                 NET_RegisterNewsrcFile(newName,(char *)(const char *)g_MsgPrefs.m_csNewsHost,
  659.                     (type == xpSNewsgroups), TRUE );
  660.             else
  661.                 NET_RegisterNewsrcFile(newName,(char*)name,(type == xpSNewsgroups), TRUE );
  663.         } else {
  665.             newName = XP_STRDUP(netLibName);
  667.         }
  668.         break;
  669.     case xpMimeTypes:
  670. name = NULL;
  671. break;
  672. #endif /* MOZ_LITE       */
  673.     case xpGlobalHistory:
  674. newName = (char *) XP_ALLOC(_MAX_PATH);
  675. /* changed to support multi-profile */
  676. /*sprintf(newName, "%s\netscape.hst", theApp.m_pInstallDir->GetCharValue()); */
  677. sprintf(newName, "%s\netscape.hst", (const char *)theApp.m_UserDirectory);
  678. break;
  679.     case xpGlobalHistoryList:
  680.         newName = (char *) XP_ALLOC(_MAX_PATH);
  681.         sprintf( newName, "%s\ns_hstry.htm" );
  682.         break;
  683.     case xpKeyChain:
  684. name = NULL;
  685. break;
  687.       /* larubbio */
  688.     case xpSARCache:
  689.         if(!name) {
  690.             return NULL;
  691.         }
  692. newName = (char *) XP_ALLOC(_MAX_PATH);
  693. sprintf(newName, "%s\%s", theApp.m_pSARCacheDir, name);
  694. break;
  696.     case xpCache:
  697.         if(!name) {
  698.             tempName = WH_TempFileName(xpCache, NULL, NULL);
  699.     if (!tempName) return NULL;
  700.     name = tempName;
  701. }
  702.         newName = (char *) XP_ALLOC(_MAX_PATH);
  703.         if ((strchr(name,'|')  || strchr(name,':')))  { /* Local File URL if find a | */
  704.             if(name[0] == '/')
  705.              strcpy(newName,name+1); /* skip past extra slash */
  706.     else
  707. strcpy(newName,name); /* absolute path is valid */
  708.         } else {
  709.     sprintf(newName, "%s\%s", (const char *)theApp.m_pCacheDir, name);
  710. }
  711.         break;
  712.     case xpBookmarks:
  713.     case xpHotlist: 
  714. if (!name || !strlen(name)) 
  715.     name = theApp.m_pBookmarkFile;
  716. break;
  717. #endif /* CMD_STUB */
  719.     case xpSocksConfig:
  720. prefStr = NULL;
  721. #ifndef CMD_STUB
  722. PREF_CopyCharPref("browser.socksfile_location", &prefStr);
  723. #else
  724. ASSERT(0);
  725. #endif
  726. name = prefStr;
  727. break;
  729. #ifndef CMD_STUB
  730.     case xpCertDB:
  731.         newName = (char *) XP_ALLOC(_MAX_PATH);
  732.         if ( name ) {
  733.     sprintf(newName, "%s\cert%s.db", (const char *)theApp.m_UserDirectory, name);
  734.         } else {
  735.     sprintf(newName, "%s\cert.db", (const char *)theApp.m_UserDirectory);
  736.         }
  737. break;
  738.     case xpCertDBNameIDX:
  739.         newName = (char *) XP_ALLOC(_MAX_PATH);
  740. sprintf(newName, "%s\certni.db", (const char *)theApp.m_UserDirectory);
  741. break;
  742.     case xpKeyDB:
  743.         newName = (char *) XP_ALLOC(_MAX_PATH);
  744. if ( name ) {
  745.   sprintf(newName, "%s\key%s.db", (const char *)theApp.m_UserDirectory, name);
  746. } else {
  747.   sprintf(newName, "%s\key.db", (const char *)theApp.m_UserDirectory);
  748. }
  749. break;
  750.     case xpSecModuleDB:
  751.         newName = (char *) XP_ALLOC(_MAX_PATH);
  752. sprintf(newName, "%s\secmod.db", (const char *)theApp.m_UserDirectory);
  753. break;
  754.     case xpSignedAppletDB:
  755.         newName = (char *) XP_ALLOC(_MAX_PATH);
  756. if ( name ) {
  757.   sprintf(newName, "%s\signed%s.db", (const char *)theApp.m_UserDirectory, name);
  758. } else {
  759.   sprintf(newName, "%s\signed.db", (const char *)theApp.m_UserDirectory);
  760. }
  761. break;
  762. #ifndef MOZ_LITE      
  763.     case xpAddrBook:
  764. #ifdef XP_WIN16
  765. if(!name || !strlen(name) )
  766.     newName = WH_TempName(type, NULL);
  767. #else
  768. newName = (char *) XP_ALLOC(_MAX_PATH);
  769. strcpy(newName, name);
  771. /* strip off the extension */
  772. {
  773. char * pEnd = max(strrchr(newName, '\'), strrchr(newName, '/'));
  774. if(!pEnd)
  775.     pEnd = newName;
  777. pEnd = strchr(pEnd, '.');
  778. if(pEnd)
  779.     *pEnd = '';
  780. }
  781. strcat(newName, ".nab");
  782. #endif
  783.         break;
  784.     case xpAddrBookNew:
  785. newName = (char *) XP_ALLOC(_MAX_PATH);
  786. sprintf(newName, "%s\%s", (const char *)theApp.m_UserDirectory, name);
  787. break;
  788.     case xpVCardFile:
  789. newName = (char *) XP_ALLOC(_MAX_PATH);
  790. strcpy(newName, name);
  792. /* strip off the extension */
  793. {
  794. char * pEnd = max(strrchr(newName, '\'), strrchr(newName, '/'));
  795. if(!pEnd)
  796.     pEnd = newName;
  798. pEnd = strchr(pEnd, '.');
  799. if(pEnd)
  800.     *pEnd = '';
  801. }
  802. strcat(newName, ".vcf");
  803.         break;
  804.     case xpLDIFFile:
  805. newName = (char *) XP_ALLOC(_MAX_PATH);
  806. strcpy(newName, name);
  808. /* strip off the extension */
  809. {
  810. char * pEnd = max(strrchr(newName, '\'), strrchr(newName, '/'));
  811. if(!pEnd)
  812.     pEnd = newName;
  814. pEnd = strchr(pEnd, '.');
  815. if(pEnd)
  816.     *pEnd = '';
  817. }
  818. #ifdef XP_WIN16
  819. strcat(newName, ".ldi");
  820. #else
  821. strcat(newName, ".ldif");
  822. #endif
  823.         break;
  824.     case xpTemporaryNewsRC:
  825.         {
  826.             CString csHostName = g_MsgPrefs.m_csNewsDir;
  827.             csHostName += "\news.tmp";
  828.             newName = XP_STRDUP((const char *) csHostName);
  829.         }
  830.         break;
  831. #endif /* MOZ_LITE         */
  832.     case xpPKCS12File:
  833. newName = (char *) XP_ALLOC(_MAX_PATH);
  834. strcpy(newName, name);
  836. /* strip off the extension */
  837. {
  838. char * pEnd = max(strrchr(newName, '\'), strrchr(newName, '/'));
  839. if(!pEnd)
  840.     pEnd = newName;
  842. pEnd = strchr(pEnd, '.');
  843. if(pEnd)
  844.     *pEnd = '';
  845. }
  846. strcat(newName, ".p12");
  847. break;
  848.     case xpTemporary:
  849.         if(!name || !strlen(name) )
  850.             newName = WH_TempName(type, NULL);
  851.         break;
  852. #ifndef MOZ_LITE        
  853.     case xpMailFolder:
  854. if(!name)
  855.     name = g_MsgPrefs.m_csMailDir;
  856.         break;
  857.     case xpMailFolderSummary:
  858. newName = (char *) XP_ALLOC(_MAX_PATH);
  859. strcpy(newName, name);
  861. /* strip off the extension */
  862. {
  863. char * pEnd = max(strrchr(newName, '\'), strrchr(newName, '/'));
  864. if(!pEnd)
  865.     pEnd = newName;
  867. #ifdef XP_WIN16 /* backend won't allow '.' in win16 folder names, but just to be safe. */
  868. pEnd = strchr(pEnd, '.');
  869. if(pEnd)
  870.     *pEnd = '';
  871. #endif
  872. }
  873. strcat(newName, ".snm");
  874. break;
  875.     case xpMailSort:
  876.         newName = (char *) XP_ALLOC(_MAX_PATH);
  877.         sprintf(newName, "%s\rules.dat", (const char *)g_MsgPrefs.m_csMailDir);
  878. break;
  879.     case xpMailFilterLog:
  880. newName = (char *) XP_ALLOC(_MAX_PATH);
  881. sprintf(newName, "%s\mailfilt.log", (const char *)g_MsgPrefs.m_csMailDir);
  882. break;
  883.     case xpNewsFilterLog:
  884. newName = (char *) XP_ALLOC(_MAX_PATH);
  885. sprintf(newName, "%s\newsfilt.log", (const char *)g_MsgPrefs.m_csNewsDir);
  886. break;
  887.     case xpMailPopState:
  888.         newName = (char *) XP_ALLOC(_MAX_PATH);
  889.         sprintf(newName, "%s\popstate.dat", (const char *)g_MsgPrefs.m_csMailDir);
  890. break;
  891.     case xpMailSubdirectory:
  892. newName = (char *) XP_ALLOC(_MAX_PATH);
  893. strcpy(newName, name);
  895. /* strip off the trailing slash if any */
  896. {
  897. char * pEnd = max(strrchr(newName, '\'), strrchr(newName, '/'));
  898. if(!pEnd)
  899.     pEnd = newName;
  900. }
  902. strcat(newName, ".sbd");
  903. break;
  904. #endif /* MOZ_LITE       */
  905.     /* name of global cross-platform registry */
  906.     case xpRegistry:
  907.         /* eventually need to support arbitrary names; this is the default */
  908.         newName = (char *) XP_ALLOC(_MAX_PATH);
  909.         if ( newName != NULL ) {
  910.             GetWindowsDirectory(newName, _MAX_PATH);
  911.             int namelen = strlen(newName);
  912.             if ( newName[namelen-1] == '\' )
  913.                 namelen--;
  914.             strcpy(newName+namelen, "\nsreg.dat");
  915.         }
  916.         break;
  917. /* name of news group database  */
  918. #ifndef MOZ_LITE   
  919.     case xpXoverCache:
  920. newName = (char *) XP_ALLOC(_MAX_PATH);
  921. sprintf(newName, "%s\%s", (const char *)g_MsgPrefs.m_csNewsDir, name);
  922. break;
  923. #endif /* MOZ_LITE */
  924.     case xpProxyConfig:
  925.         newName = (char *) XP_ALLOC(_MAX_PATH);
  926.         /*sprintf(newName, "%s\proxy.cfg", theApp.m_pInstallDir->GetCharValue()); */
  927. sprintf(newName, "%s\proxy.cfg", (const char *)theApp.m_UserDirectory);
  928. break;
  930.     /* add any cases where no modification is necessary here   */
  931.     /* The name is fine all by itself, no need to modify it  */
  932.     case xpFileToPost:
  933.     case xpExtCache:
  934.     case xpURL:
  935.         /* name is OK as it is */
  936. break;
  937. #ifndef MOZ_LITE      
  938.     case xpNewsHostDatabase:
  939. newName = (char *) XP_ALLOC(_MAX_PATH);
  940. sprintf(newName, "%s\news.db", (const char *)g_MsgPrefs.m_csNewsDir);
  941. break;
  943.     case xpImapRootDirectory:
  944. newName = PR_smprintf ("%s\ImapMail", (const char *)theApp.m_UserDirectory);
  945. break;
  946.     case xpImapServerDirectory:
  947. {
  948. int len = 0;
  949. char *tempImapServerDir = XP_STRDUP(name);
  950. char *imapServerDir = tempImapServerDir;
  951. #ifdef XP_WIN16
  952. if ((len = XP_STRLEN(imapServerDir)) > 8) {
  953.     imapServerDir = imapServerDir + len - 8;
  954. }
  955. #endif
  956. newName = PR_smprintf ("%s\ImapMail\%s", (const char *)theApp.m_UserDirectory, imapServerDir);
  957. if (tempImapServerDir) XP_FREE(tempImapServerDir);
  958. }
  959. break;
  961.     case xpJSMailFilters:
  962. newName = PR_smprintf("%s\filters.js", (const char *)g_MsgPrefs.m_csMailDir);
  963. break;
  964. #endif /* MOZ_LITE */
  965.     case xpFolderCache:
  966. newName = PR_smprintf ("%s\summary.dat", (const char *)theApp.m_UserDirectory);
  967. break;
  969.     case xpCryptoPolicy:
  970. newName = (char *) XP_ALLOC(_MAX_PATH);
  971. FE_GetProgramDirectory(newName, _MAX_PATH);
  972. strcat(newName, "moz40p3");
  973. break;
  974. #endif /* CMD_STUB */
  976.     default:
  977. ASSERT(0);  /* all types should be covered */
  978.         break;
  979.     }
  981. #ifndef MOZ_LITE    
  982.     /* make sure we have the correct newsrc file registered for next time */
  983. if((type == xpSNewsRC || type == xpNewsRC) && bNeedToRegister)
  984.         NET_RegisterNewsrcFile(newName, (char *)name, (type == xpSNewsRC), FALSE );
  985. #endif
  987.     /* determine what file we are supposed to load and make sure it looks */
  988.     /*   like a DOS pathname and not some unix-like name */
  989.     if(newName) {
  990. *myName = XP_NetToDosFileName((const char*)newName);
  991. XP_FREE(newName); 
  992.     } else {
  993. *myName = XP_NetToDosFileName((const char*)name);
  994.     }
  996.     if (tempName) XP_FREE(tempName);
  998.     if (prefStr) XP_FREE(prefStr);        
  1000.     /* whee, we're done */
  1001.     return(*myName);
  1002. }
  1004. /* */
  1005. /* Open a file with the given name */
  1006. /* If a special file type is provided we might need to get the name */
  1007. /*  out of the preferences list */
  1008. /* */
  1009. PUBLIC XP_File 
  1010. XP_FileOpen(const char * name, XP_FileType type, const XP_FilePerm perm)
  1011. {
  1012.     XP_File fp;
  1013.     char *filename = WH_FileName(name, type);
  1015.     if(!filename)
  1016. return(NULL);
  1018. #ifdef DEBUG_nobody
  1019.     TRACE("Opening a file type (%d) permissions: %s (%s)n", type, perm, filename);
  1020. #endif
  1022. #ifdef XP_WIN32
  1023.     if (type == xpURL) {
  1024. HANDLE hFile;
  1025. DWORD dwType;
  1027. /* Check if we're trying to open a device. We don't allow this */
  1028. hFile = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
  1029. OPEN_EXISTING, 0, NULL);
  1031. if (hFile != INVALID_HANDLE_VALUE) {
  1032.     dwType = GetFileType(hFile);
  1033.     CloseHandle(hFile);
  1035.     if (dwType != FILE_TYPE_DISK) {
  1036. XP_FREE(filename);
  1037. return NULL;
  1038.     }
  1039. }
  1040.     }
  1041. #endif
  1043. #ifdef XP_WIN16
  1044.     /* Windows uses ANSI codepage, DOS uses OEM codepage,  */
  1045.     /* fopen takes OEM codepage */
  1046.     /* That's why we need to do conversion here. */
  1047.     CString oembuff = filename;
  1048.     oembuff.AnsiToOem();
  1049.     fp = fopen(oembuff, (char *) perm);
  1051.     if (fp && type == xpURL) {
  1052. union _REGS inregs, outregs;
  1054. /* Check if we opened a device. Execute an Interrupt 21h to invoke */
  1055. /* MS-DOS system call 44h */
  1056. inregs.x.ax = 0x4400;  /* MS-DOS function to get device information */
  1057. inregs.x.bx = _fileno(fp);
  1058. _int86(0x21, &inregs, &outregs);
  1060. if (outregs.x.dx & 0x80) {
  1061.     /* It's a device. Don't allow any reading/writing */
  1062.     fclose(fp);
  1063.     XP_FREE(filename);
  1064.     return NULL;
  1065. }
  1066.     }
  1067. #else
  1068.     fp = fopen(filename, (char *) perm);
  1069. #endif
  1070.     XP_FREE(filename);
  1071.     return(fp);
  1072. }
  1076. /******************************************************************************/
  1077. /* Thread-safe entry points: */
  1079. extern PRMonitor* _pr_TempName_lock;
  1081. #ifndef CMD_STUB
  1083. char *
  1084. WH_TempName(XP_FileType type, const char * prefix)
  1085. {
  1086.     static char buf[_MAX_PATH]; /* protected by _pr_TempName_lock */
  1087.     char* result;
  1089.     if (_pr_TempName_lock == NULL)
  1090. _pr_TempName_lock = PR_NewNamedMonitor("TempName-lock");
  1091.     PR_EnterMonitor(_pr_TempName_lock);
  1093.     result = XP_STRDUP(xp_TempFileName(type, prefix, NULL, buf));
  1095.     PR_ExitMonitor(_pr_TempName_lock);
  1097.     return result;
  1098. }
  1100. #endif /* CMD_STUB */
  1102. PUBLIC char *
  1103. WH_FileName (const char *name, XP_FileType type)
  1104. {
  1105.     char* myName;
  1106.     char* result;
  1107.     /*
  1108.     ** I'm not sure this lock is really needed by windows, but just
  1109.     ** to be safe:
  1110.     */
  1111.     /* XP_ASSERT(_pr_TempName_lock); */
  1112.     /* PR_EnterMonitor(_pr_TempName_lock); */
  1113.     result = xp_FileName(name, type, &myName);
  1114.     /* PR_ExitMonitor(_pr_TempName_lock); */
  1115.     return myName;
  1116. }
  1118. #endif /* XP_WIN */