home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / lib / libnet / mkextcac.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  38.6 KB  |  1,562 lines
  1. /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  2.  *
  3.  * The contents of this file are subject to the Netscape Public License
  4.  * Version 1.0 (the "NPL"); you may not use this file except in
  5.  * compliance with the NPL.  You may obtain a copy of the NPL at
  6.  * http://www.mozilla.org/NPL/
  7.  *
  8.  * Software distributed under the NPL is distributed on an "AS IS" basis,
  9.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  10.  * for the specific language governing rights and limitations under the
  11.  * NPL.
  12.  *
  13.  * The Initial Developer of this code under the NPL is Netscape
  14.  * Communications Corporation.  Portions created by Netscape are
  15.  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  16.  * Reserved.
  17.  */
  18. /* Created: Lou Montulli */
  19. /* Modifications/Additions: Gagan Saksena */
  20. /* Please leave outside of ifdef for windows precompiled headers. */
  21. #include "mkutils.h"
  22.  
  23. #ifdef MOZILLA_CLIENT
  24.  
  25. #include "mkcache.h"
  26. #include "glhist.h"
  27. #include "xp_hash.h"
  28. #include "xp_mcom.h"
  29. #include "client.h"
  30. #include "mkgeturl.h"
  31. #include "mkstream.h"
  32. #include "cert.h" /* for CERT_DupCertificate() */
  33. #include "extcache.h"
  34. #include "mkextcac.h"
  35.  
  36. /* For 197 java hookup */
  37. #include "jri.h"
  38.  
  39. #ifdef PROFILE
  40. #pragma profile on
  41. #endif
  42.  
  43. /* for XP_GetString() */
  44. #include "xpgetstr.h"
  45. extern int XP_DATABASE_CANT_BE_VALIDATED_MISSING_NAME_ENTRY;
  46. extern int XP_DB_SELECTED_DB_NAMED;
  47. extern int XP_REQUEST_EXTERNAL_CACHE;
  48.  
  49. PRIVATE XP_List * ext_cache_database_list = 0;
  50. PRIVATE Bool AtLeastOneOpenCache = FALSE;
  51.  
  52.  
  53. /* ************************************ Defines ************************************** */
  54. #define SAR_CACHE_INFO_STRING "CACHE_ExternalSARCacheNameString"
  55.  
  56. #define EXTCACHE      1
  57. #define SARCACHE      2
  58. #define SUCCESS          0
  59. #define FAILURE         -1
  60. #define MIN_MAX_SIZE  1000
  61.  
  62. /* ************************************ Proto's ************************************** */
  63.  
  64. /* Modified existing functions to call these (read Cut n Paste with passed in args) */
  65. PRIVATE void                    cache_ReadCacheInfo(XP_File fp, XP_List **list_ptr, int type);
  66. PRIVATE void                    cache_SaveCacheInfo(XP_File fp, XP_List *list_ptr, int type);
  67. PRIVATE void                    cache_SaveSARCacheInfo(void);
  68.  
  69. /* Newly written functions */
  70. PRIVATE int                        cache_PutSARCacheInfoIntoDB(ExtCacheDBInfo *db_info);
  71. PRIVATE ExtCacheDBInfo *        cache_GetSARCacheInfoFromDB(ExtCacheDBInfo *db_info);
  72. MODULE_PRIVATE DBT *            cache_ExtCacheDBInfoStructToDBData(ExtCacheDBInfo * old_obj);
  73. MODULE_PRIVATE ExtCacheDBInfo * cache_DBDataToExtCacheDBInfoStruct(DBT * db_obj);
  74. MODULE_PRIVATE void                cache_freeExtCacheDBInfoObj (ExtCacheDBInfo * cache_obj);
  75.  
  76. /* ************************************ Variables ************************************** */
  77. PRIVATE XP_List * SAR_cache_database_list = 0;
  78. PRIVATE Bool SARCacheIndexOpen = FALSE;
  79.  
  80.  
  81. /* close an external cache 
  82.  */
  83. PRIVATE void
  84. net_CloseExtCacheFat(ExtCacheDBInfo *db_info)
  85. {
  86.     if(db_info->database)
  87.       {
  88.         (*db_info->database->close)(db_info->database);
  89.         db_info->database = 0;
  90.       }
  91.  
  92. }
  93.  
  94.  
  95. PRIVATE char *
  96. net_GetExtCacheNameFromDB(ExtCacheDBInfo *db_info)
  97. {
  98.     DBT key;
  99.     DBT data;
  100.  
  101.     if(!db_info->database)
  102.         return NULL;
  103.  
  104.     key.data = EXT_CACHE_NAME_STRING;
  105.     key.size = XP_STRLEN(EXT_CACHE_NAME_STRING);
  106.  
  107.     if(0 == (*db_info->database->get)(db_info->database, &key, &data, 0))
  108.       {
  109.         /* make sure it's a valid cstring */
  110.         char *name = (char *)data.data;
  111.         if(name[data.size-1] == '\0')
  112.             return(XP_STRDUP(name));
  113.         else
  114.             return(NULL);
  115.       }
  116.  
  117.     return(NULL);
  118.  
  119. }
  120.  
  121. /* read/open an External Cache File allocation table.
  122.  *
  123.  * Returns a True if successfully opened
  124.  * Returns False if not.
  125.  */
  126. PRIVATE Bool
  127. net_OpenExtCacheFat(MWContext *ctxt, ExtCacheDBInfo *db_info)
  128. {
  129.     char *slash;
  130.     char *db_name;
  131.     XP_Bool close_db=FALSE;
  132.  
  133.     if(!db_info->database)
  134.       {
  135.         /* @@@ add .db to the end of the files
  136.          */
  137.         char* filename = WH_FilePlatformName(db_info->filename);
  138.         db_info->database = dbopen(filename,
  139.                                      O_RDONLY,
  140.                                      0600,
  141.                                      DB_HASH,
  142.                                      0);
  143. #ifdef XP_WIN
  144. /* This is probably the last checkin into Akbar */
  145. /* What really needs to be fixed is that Warren's implementation */
  146. /* of WH_FilePlatformName needs to return a malloc'd string */
  147. /* Right now, on Mac & X, it does not. See xp_file.c */
  148.         FREEIF(filename);
  149. #endif
  150.         if(!db_info->database)
  151.             return(FALSE);
  152.         else
  153.             AtLeastOneOpenCache = TRUE;
  154.  
  155.         StrAllocCopy(db_info->path, db_info->filename);
  156.  
  157.         /* figure out the path to the database */
  158. #if defined(XP_WIN) || defined(XP_OS2)                 /* IBM-SAH */
  159.           slash = XP_STRRCHR(db_info->path, '\\');                        
  160. #elif defined(XP_MAC)
  161.           slash = XP_STRRCHR(db_info->path, '/');                        
  162. #else
  163.           slash = XP_STRRCHR(db_info->path, '/');                        
  164. #endif
  165.  
  166.         if(slash)
  167.           {
  168.             *(slash+1) = '\0';
  169.           }
  170.         else
  171.           {
  172.             *db_info->path = '\0';
  173.           }
  174.  
  175.         db_name = net_GetExtCacheNameFromDB(db_info);
  176.  
  177.         if(!db_name)
  178.           {
  179.             close_db = !FE_Confirm(ctxt,
  180.             XP_GetString( XP_DATABASE_CANT_BE_VALIDATED_MISSING_NAME_ENTRY ) );
  181.           }
  182.         else if(XP_STRCMP(db_name, db_info->name))
  183.           {
  184.             char buffer[2048];
  185.             
  186.             PR_snprintf(buffer, sizeof(buffer),
  187.                               XP_GetString( XP_DB_SELECTED_DB_NAMED ),
  188.                               db_name, db_info->name);
  189.             
  190.             close_db = !FE_Confirm(ctxt, buffer);
  191.           }
  192.  
  193.         if(close_db)
  194.           {
  195.             (*db_info->database->close)(db_info->database);
  196.             db_info->database = 0;
  197.             return(FALSE);
  198.           }
  199.       }
  200.  
  201.      return(TRUE);
  202. }
  203.  
  204.  
  205. PRIVATE void
  206. net_SaveExtCacheInfo(void)
  207. {
  208.     XP_File fp;
  209.     XP_List *list_ptr;
  210.  
  211.     fp = XP_FileOpen("", xpExtCacheIndex, XP_FILE_WRITE);
  212.     list_ptr = ext_cache_database_list;
  213.  
  214.     cache_SaveCacheInfo(fp, list_ptr, EXTCACHE);
  215. }
  216.  
  217. #define BUF_SIZE 2048
  218. PRIVATE void
  219. net_ReadExtCacheInfo(void)
  220. {
  221.     XP_File fp;
  222.  
  223.     fp = XP_FileOpen("", xpExtCacheIndex, XP_FILE_READ);
  224.  
  225.     cache_ReadCacheInfo(fp, &ext_cache_database_list, EXTCACHE);
  226. }
  227.  
  228. PRIVATE void
  229. net_OpenExtCacheFATCallback(MWContext *ctxt, char * filename, void *closure)
  230. {
  231.     ExtCacheDBInfo *db_info = (ExtCacheDBInfo*)closure;
  232.  
  233.     if(!db_info || !filename)
  234.         return;
  235.  
  236.     StrAllocCopy(db_info->filename, filename);
  237.  
  238.     /* once we have the name try and open the
  239.      * cache fat
  240.      */
  241.     if(net_OpenExtCacheFat(ctxt, db_info))
  242.       {
  243.         AtLeastOneOpenCache = TRUE;
  244.       }
  245.     else
  246.       {
  247.         if(FE_Confirm(ctxt, "Unable to open External Cache.  Try again?"))
  248.           {
  249.             /* try and open again */
  250.  
  251.             FE_PromptForFileName (ctxt,                    /* context */
  252.                               db_info->name,            /* prompt string */
  253.                               db_info->filename,    /* default file/path */
  254.                               TRUE,                    /* file must exist */
  255.                               FALSE,                /* directories allowed */
  256.                               net_OpenExtCacheFATCallback, /* callback */
  257.                               (void *)db_info);     /* closure */
  258.  
  259.         
  260.             return; /* don't save ExtCache info */
  261.           }
  262.       }
  263.  
  264.     net_SaveExtCacheInfo();
  265. }
  266.  
  267. PUBLIC void
  268. NET_OpenExtCacheFAT(MWContext *ctxt, char * cache_name, char * instructions)
  269. {
  270.     ExtCacheDBInfo *db_info=0, *db_ptr;
  271.     Bool done = FALSE;
  272.     XP_List *list_ptr;
  273.  
  274.     if(!ext_cache_database_list)
  275.       {
  276.         net_ReadExtCacheInfo();
  277.         if(!ext_cache_database_list)
  278.             return;
  279.       }
  280.  
  281.     /* look up the name in a list and open the file
  282.      * if it's not open already
  283.      */
  284.     list_ptr = ext_cache_database_list;
  285.     while((db_ptr = (ExtCacheDBInfo *)XP_ListNextObject(list_ptr)) != NULL)
  286.       {
  287.         if(db_ptr->name && !XP_STRCMP(db_ptr->name, cache_name))
  288.           {
  289.             db_info = db_ptr;
  290.             break;
  291.           }
  292.       }
  293.  
  294.     if(!db_info)
  295.       {
  296.         db_info = XP_NEW(ExtCacheDBInfo);
  297.         if(!db_info)
  298.             return;
  299.         XP_MEMSET(db_info, 0, sizeof(ExtCacheDBInfo));
  300.         StrAllocCopy(db_info->name, cache_name);
  301.  
  302.         XP_ListAddObject(ext_cache_database_list, db_info);
  303.       }
  304.     else if(db_info->queried_this_session)
  305.       {
  306.         /* don't query or try and open again.
  307.          */
  308.         return;
  309.       }
  310.  
  311.     if(db_info->filename)
  312.       {
  313.         done = net_OpenExtCacheFat(ctxt, db_info);
  314.  
  315.         if(done)
  316.           {
  317.             char buffer[1024];
  318.  
  319.             PR_snprintf(buffer, sizeof(buffer), 
  320.                         "Now using external cache: %.900s", 
  321.                            db_info->name);
  322.             if(!FE_Confirm(ctxt, buffer))
  323.                 net_CloseExtCacheFat(db_info);
  324.           }
  325.       }
  326.  
  327.     /* If we don't have the correct filename, query the
  328.      * user for the name
  329.      */
  330.     if(!done)
  331.       {
  332.  
  333.         if(instructions)
  334.             done = !FE_Confirm(ctxt, instructions);
  335.         else
  336.             done = !FE_Confirm(ctxt, XP_GetString( XP_REQUEST_EXTERNAL_CACHE ) );
  337.  
  338.         if(!done)
  339.             FE_PromptForFileName (ctxt,                    /* context */
  340.                               db_info->name,            /* prompt string */
  341.                               db_info->filename,    /* default file/path */
  342.                               TRUE,                    /* file must exist */
  343.                               FALSE,                /* directories allowed */
  344.                               net_OpenExtCacheFATCallback, /* callback */
  345.                               (void *)db_info);     /* closure */
  346.       }
  347.  
  348.     db_info->queried_this_session = TRUE;
  349.  
  350.     return;
  351. }
  352.  
  353. /* lookup routine
  354.  *
  355.  * builds a key and looks for it in 
  356.  * the database.  Returns an access
  357.  * method and sets a filename in the
  358.  * URL struct if found
  359.  */
  360. MODULE_PRIVATE int
  361. NET_FindURLInExtCache(URL_Struct * URL_s, MWContext *ctxt)
  362. {
  363.     return CACHE_FindURLInCache(URL_s, ctxt);
  364. }
  365.  
  366. /* ****************************************************************************************************************************
  367.  * Exposed Navigator Cache Calls
  368.  * ****************************************************************************************************************************/
  369.  
  370. /*
  371.  * allows java to enumerate through all of the managed cache
  372.  */
  373. PUBLIC XP_List *
  374. CACHE_GetManagedCacheList()
  375. {
  376.     XP_File            fp;
  377.  
  378.     /* If the Cache Index is not open, we can not see if the cache is open now can we */
  379.     if (!SARCacheIndexOpen)
  380.     {
  381.         fp = XP_FileOpen("", xpSARCacheIndex, XP_FILE_READ);
  382.  
  383.         /* check to see if the open succeeds */
  384.         if (fp) 
  385.         {
  386.             cache_ReadCacheInfo(fp, &SAR_cache_database_list, SARCACHE);
  387.             SARCacheIndexOpen = TRUE;
  388.         }
  389.         else
  390.             return NULL;
  391.     }
  392.  
  393.     return SAR_cache_database_list;
  394. }
  395.  
  396.  
  397. MODULE_PRIVATE void
  398. CACHE_CloseAllOpenSARCache()
  399. {
  400.     ExtCacheDBInfo * db_info;
  401.     XP_StatStruct    stat_entry;
  402.  
  403.     if (!SARCacheIndexOpen) return;
  404.  
  405.     if (!SAR_cache_database_list) return;
  406.  
  407.     while(NULL != (db_info = (ExtCacheDBInfo *)XP_ListNextObject(SAR_cache_database_list)))
  408.     {
  409.         CACHE_CloseCache(db_info);
  410.  
  411.         if ( db_info->logFile )
  412.             XP_FileClose(db_info->logFile);
  413.  
  414.         /* stat the db file to see if it exists, if it doesn't remove it from */
  415.         /* the archive.fat file to keep things consistent */
  416.         if(db_info->filename && (XP_Stat(db_info->filename, &stat_entry, xpSARCache) == -1) )
  417.         {
  418.             /* file does not exist!!
  419.              * remove the entry 
  420.              */
  421.              TRACEMSG(("Error! Cache db file missing: %s", db_info->filename));
  422.  
  423.              if ( NULL != SAR_cache_database_list->prev )
  424.                 SAR_cache_database_list = SAR_cache_database_list->prev;
  425.              
  426.              XP_ListRemoveObject(SAR_cache_database_list, db_info);
  427.          }
  428.         cache_freeExtCacheDBInfoObj(db_info);
  429.     }
  430.  
  431.     cache_SaveSARCacheInfo();
  432.  
  433.     SAR_cache_database_list = 0;
  434.     SARCacheIndexOpen = FALSE;
  435. }
  436.  
  437. MODULE_PRIVATE void
  438. CACHE_OpenAllSARCache()
  439. {
  440.     XP_File            fp;
  441.     XP_List            *tmpList;
  442.     ExtCacheDBInfo    *db_info,
  443.                     *tmpDB_info;
  444.     char            * filename,            /* The platform specific filename returned by WH_PlatformFileName */
  445.                     * tmpName;            /* The filename returned by WH_FileName */
  446.  
  447.     if (!SARCacheIndexOpen)
  448.     {
  449.         fp = XP_FileOpen("", xpSARCacheIndex, XP_FILE_READ);
  450.  
  451.         /* check to see if the open succeeds */
  452.         if (fp)
  453.             cache_ReadCacheInfo(fp, &SAR_cache_database_list, SARCACHE);
  454.         else
  455.             return;
  456.     }
  457.  
  458.     SARCacheIndexOpen = TRUE;
  459.  
  460.     if (!SAR_cache_database_list) return;
  461.  
  462.     tmpList = SAR_cache_database_list;
  463.     while(NULL != (db_info = (ExtCacheDBInfo *)XP_ListNextObject(tmpList)))
  464.     {
  465.         if ( !db_info->database )
  466.         {
  467.             tmpName = WH_FileName(db_info->filename, xpSARCache);
  468.             filename = WH_FilePlatformName(tmpName);
  469.  
  470.             /* Open or create the db file they specified */
  471.             db_info->database = dbopen(filename,
  472.                                            O_RDWR | O_CREAT,
  473.                                            0600,
  474.                                            DB_HASH,
  475.                                            0);
  476.  
  477.             /* check to see if the dbopen failed */
  478.             if ( NULL == db_info->database )
  479.             {
  480.                 CACHE_CloseCache(db_info);
  481.                 FREEIF(db_info);
  482.                 db_info = NULL;
  483.             }
  484.  
  485.             /* Do stuff to get the type, and name */
  486.             tmpDB_info = cache_GetSARCacheInfoFromDB(db_info);
  487.  
  488.             if ( !tmpDB_info ) return;
  489.  
  490.             /* Since they can access this one, fill in the cache name value */
  491.             db_info->DiskCacheSize       = tmpDB_info->DiskCacheSize;
  492.             db_info->NumberInDiskCache = tmpDB_info->NumberInDiskCache;
  493.             db_info->MaxSize           = tmpDB_info->MaxSize;
  494.             db_info->name               = XP_STRDUP(tmpDB_info->name);
  495.             db_info->logFile           = NULL;    
  496.  
  497.             cache_freeExtCacheDBInfoObj(tmpDB_info);
  498. #ifdef XP_WIN
  499.             FREEIF(filename);
  500. #endif
  501.         }
  502.     }    
  503.  
  504. }
  505.  
  506.  
  507. /*
  508.  * Closes the cache db
  509.  */
  510. PUBLIC int 
  511. CACHE_CloseCache(ExtCacheDBInfo *db)
  512. {
  513.     /* If there is no Cache Struct return */
  514.     if (!db) return 0;
  515.  
  516.     /* If there is no db return */
  517.     if (!db->database) return 0;
  518.  
  519.     if(-1 == (*db->database->close)(db->database))
  520.     {
  521.         TRACEMSG(("Error closing cache database"));
  522.  
  523.         return 0;
  524.     }
  525.  
  526.     db->database = 0;
  527.  
  528.     return SUCCESS;
  529. }
  530.  
  531. /*
  532.  * Closes the cache db
  533.  */
  534. PUBLIC void 
  535. CACHE_UpdateCache(ExtCacheDBInfo *db)
  536. {
  537.     if ( db )
  538.         cache_PutSARCacheInfoIntoDB(db);
  539. }
  540.  
  541.     
  542. /*
  543.  * Returns a handle to the desired persitent cache,
  544.  * It also adds this newly opened cache to the list
  545.  * of opened caches
  546.  */
  547. PUBLIC ExtCacheDBInfo * 
  548. CACHE_GetCache(ExtCacheDBInfo *db)
  549. {
  550.     XP_File            fp;
  551.     char            * filename,            /* The platform specific filename returned by WH_PlatformFileName */
  552.                     * tmpName;            /* The filename returned by WH_FileName */
  553.  
  554.     ExtCacheDBInfo    *db_info,
  555.                     *tmpDB_info;
  556.     XP_Bool            inIndex = FALSE,
  557.                     add2Index = FALSE;
  558.     XP_List            *tmpList;
  559.     uint32            maxSize;
  560.  
  561.     /* If there is no Cache Struct return */
  562.     if (!db) return NULL;
  563.  
  564. /* **************************************************************************************************
  565.        This is a hack.  It is a temp fix for bug 69098.  The plan is to go with this for 4.0 and
  566.        do the right thing in 4.1
  567. ************************************************************************************************** */
  568.     if ( -1 == db->type ) {
  569.         tmpName = WH_FileName(db->filename, xpSARCache);
  570. #ifndef XP_MAC
  571.         filename = WH_FilePlatformName(tmpName);
  572. #else
  573.         filename = tmpName;
  574. #endif
  575.  
  576.         /* Open or create the db file they specified */
  577.         db->database = dbopen(filename,
  578.                                        O_RDWR | O_CREAT,
  579.                                        0600,
  580.                                        DB_HASH,
  581.                                        0);
  582.         return db;
  583.     }
  584. /* **************************************************************************************************
  585.        The above was a hack.
  586. ************************************************************************************************** */
  587.  
  588.  
  589.     /* Set up the max size for the cache */
  590.     if (db->MaxSize < 0) {
  591.         maxSize = NET_GetDiskCacheSize();
  592.  
  593.         if (maxSize < MIN_MAX_SIZE)
  594.             maxSize = MIN_MAX_SIZE;
  595.     }
  596.     else {
  597.         maxSize = db->MaxSize;
  598.     }
  599.  
  600.     /* Kludge to prevent NULL writes to the Cache Index */
  601.     if ( db->path == NULL || *(db->path) == '\0' || *(db->path) == ' ')
  602.     {
  603.         db->path = XP_STRDUP("\\");
  604.     }
  605.  
  606.     /* If the Cache Index is not open, we can not see if the cache is open now can we */
  607.     if (!SARCacheIndexOpen)
  608.     {
  609.         fp = XP_FileOpen("", xpSARCacheIndex, XP_FILE_READ);
  610.  
  611.         /* check to see if the open succeeds */
  612.         if (fp)
  613.             cache_ReadCacheInfo(fp, &SAR_cache_database_list, SARCACHE);
  614.         else
  615.         {
  616.             /* I guess the index isn't there, let's make a new one */
  617.             SAR_cache_database_list = XP_ListNew();
  618.             if(!SAR_cache_database_list)
  619.                 return NULL;
  620.  
  621.             /* set the db_info values here since they will not be retrieved later */
  622.             db_info                          = (ExtCacheDBInfo *)XP_ALLOC(sizeof(ExtCacheDBInfo));
  623.             db_info->name                  = XP_STRDUP(db->name);
  624.             db_info->filename              = XP_STRDUP(db->filename);
  625.             db_info->path                  = XP_STRDUP(db->path);
  626.             db_info->queried_this_session = FALSE;
  627.             db_info->type                  = db->type;
  628.             db_info->database              = NULL;
  629.             db_info->DiskCacheSize          = 0;
  630.             db_info->NumberInDiskCache      = 0;
  631.             db_info->MaxSize              = maxSize;
  632.             db_info->logFile              = NULL;
  633.  
  634.             add2Index = TRUE;
  635.         }
  636.         SARCacheIndexOpen = TRUE;
  637.     }
  638.  
  639.     if (!SAR_cache_database_list) return NULL;
  640.  
  641.     /* If I have to add it, I already know it's not there */
  642.     if ( !add2Index )
  643.     {
  644.         tmpList = SAR_cache_database_list;
  645.         while( NULL != (db_info = (ExtCacheDBInfo *)XP_ListNextObject(tmpList)))
  646.         {
  647.             if(!XP_STRCMP(db->filename, db_info->filename) ) /* && !XP_STRCMP(db->path, db_info->path) ) */
  648.             {
  649.                 inIndex = TRUE;
  650.                 break;
  651.             }
  652.         }
  653.     }
  654.  
  655.     if (!inIndex && !add2Index)
  656.     {
  657.         /* We know nothing about this cache so add it */
  658.         db_info                          = (ExtCacheDBInfo *)XP_ALLOC(sizeof(ExtCacheDBInfo));
  659.         db_info->name                  = XP_STRDUP(db->name);
  660.         db_info->filename              = XP_STRDUP(db->filename);
  661.         db_info->path                  = XP_STRDUP(db->path);
  662.         db_info->queried_this_session = FALSE;
  663.         db_info->type                  = db->type;
  664.         db_info->database              = NULL;
  665.         db_info->DiskCacheSize          = 0;
  666.         db_info->NumberInDiskCache      = 0;
  667.         db_info->MaxSize              = maxSize;
  668.         db_info->logFile              = NULL;
  669.  
  670.         add2Index = TRUE;
  671.     }
  672.     else
  673.     {
  674.         /* if it is already open I am going to return the handle to it,
  675.            if it is not open I will return NULL since we have a name conflict */
  676.         if ((db_info!= NULL) && (db_info->database))
  677.         {
  678.             /* Do the meager name check to see if they can access this cache */
  679.             if ( XP_STRCMP(db->name, db_info->name) )
  680.             {
  681.                 db_info = NULL;
  682.             }
  683.  
  684.             return db_info;
  685.         }
  686.     }
  687.         
  688.     tmpName = WH_FileName(db->filename, xpSARCache);
  689. #ifndef XP_MAC
  690.     filename = WH_FilePlatformName(tmpName);
  691. #else
  692.     filename = tmpName;
  693. #endif
  694.  
  695.     if (!db_info)
  696.         return NULL ;
  697.  
  698.     /* Open or create the db file they specified */
  699.     db_info->database = dbopen(filename,
  700.                                    O_RDWR | O_CREAT,
  701.                                    0600,
  702.                                    DB_HASH,
  703.                                    0);
  704.  
  705.     /* check to see if the dbopen failed */
  706.     if ( NULL == db_info->database )
  707.     {
  708.         CACHE_CloseCache(db_info);
  709.         FREEIF(db_info);    
  710.         
  711.         db_info = NULL;
  712.  
  713.         return NULL;
  714.     }
  715.  
  716.     /* Do stuff to get the type, and name */
  717.     tmpDB_info = cache_GetSARCacheInfoFromDB(db_info);
  718.  
  719.     /* If tmpDB_info doesn't exist then this is a new cache */
  720.     if ( !tmpDB_info )
  721.     {
  722.         /* Since they can access this one, fill in the cache name value before it is saved */
  723.         db_info->name = XP_STRDUP(db->name);
  724.         cache_PutSARCacheInfoIntoDB(db_info);
  725.     }
  726.     else 
  727.     {
  728.         /* Do the meager name check to see if they can access this cache */
  729.         if ( XP_STRCMP(db->name, tmpDB_info->name) )
  730.         {
  731.             CACHE_CloseCache(db_info);
  732.             FREEIF(db_info);
  733.             
  734.             db_info = NULL;
  735.         }
  736.         else
  737.         {
  738.             /* Since they can access this one, fill in the cache name value */
  739.             db_info->name               = XP_STRDUP(db->name);
  740.             db_info->DiskCacheSize       = tmpDB_info->DiskCacheSize;
  741.             db_info->NumberInDiskCache = tmpDB_info->NumberInDiskCache;
  742.             db_info->MaxSize           = maxSize;
  743.             db_info->logFile           = NULL;    
  744.         }
  745.  
  746.         cache_freeExtCacheDBInfoObj(tmpDB_info);
  747.     }    
  748.  
  749.     if ( add2Index ) 
  750.     {
  751.         /* Since this is not in the index, add it */
  752.         XP_ListAddObject(SAR_cache_database_list, db_info);
  753.         cache_SaveSARCacheInfo();
  754.     }
  755.  
  756.     /* This might cause problems for FileName routins 
  757.     FREEIF(tmpName);
  758.     */
  759. #ifdef XP_WIN
  760.     FREEIF(filename);
  761. #endif
  762.  
  763.     if (db_info != NULL)
  764.         db_info->type  = db->type;
  765.  
  766.     /* free the struct they passed in, and have it point to the new 
  767.      * struct we will be using.
  768.      */
  769.     FREEIF(db);
  770.     db = db_info;
  771.  
  772.     return db_info;
  773. }
  774.  
  775. PUBLIC Bool
  776. CACHE_Put(char *filename, URL_Struct *url_s)
  777. {
  778.     net_CacheObject *cacheObject = XP_NEW(net_CacheObject);
  779.     XP_MEMSET(cacheObject, 0, sizeof(net_CacheObject));
  780.  
  781.     cacheObject->last_modified = url_s->last_modified;
  782.     cacheObject->content_length = url_s->content_length;
  783.     StrAllocCopy(cacheObject->filename, filename);
  784.     cacheObject->is_relative_path = TRUE;
  785.     StrAllocCopy(cacheObject->address, url_s->address);
  786.     StrAllocCopy(cacheObject->content_type, url_s->content_type);
  787.  
  788.     return NET_CacheStore(cacheObject, url_s, FALSE);
  789. }
  790.  
  791. PUBLIC char *
  792. CACHE_GetCachePath(char * name)
  793. {
  794.     char * tmpName, * filename;
  795.  
  796.     tmpName = WH_FileName(name, xpSARCache);
  797.     filename = WH_FilePlatformName(tmpName);
  798.  
  799.     return filename;
  800. }
  801.  
  802.  
  803. PUBLIC ExtCacheDBInfo * 
  804. CACHE_GetCacheStruct(char * path, char * filename, char * name)
  805. {
  806.     ExtCacheDBInfo * db_info;
  807.     XP_List            *tmpList;
  808.  
  809.     tmpList = SAR_cache_database_list;
  810.     while( NULL != (db_info = (ExtCacheDBInfo *)XP_ListNextObject(tmpList)))
  811.     {
  812.         if(!XP_STRCMP(path, db_info->path) && !XP_STRCMP(filename, db_info->filename) && !XP_STRCMP(name, db_info->name) )
  813.         {
  814.             return db_info;
  815.         }
  816.     }
  817.     
  818.     return NULL;
  819. }
  820.  
  821. /*
  822.  * New Cache version to allow for different files, and cache lists
  823.  */
  824. PRIVATE void
  825. cache_SaveCacheInfo(XP_File fp, XP_List *list_ptr, int type)
  826. { 
  827.     ExtCacheDBInfo *db_info;
  828.     int32 len = 0;
  829.  
  830.     if(!list_ptr)
  831.         return;
  832.  
  833.     if(!fp)
  834.         return;
  835.  
  836.     len = XP_FileWrite("# Netscape External Cache Index" LINEBREAK
  837.                  "# This is a generated file!  Do not edit." LINEBREAK
  838.                  LINEBREAK,
  839.                  -1, fp);
  840.     if (len < 0)
  841.     {
  842.         XP_FileClose(fp);
  843.         return;
  844.     }
  845.  
  846.     /* file format is:
  847.      *   Filename  <TAB> database_name
  848.      */
  849.      while((db_info = (ExtCacheDBInfo *)XP_ListNextObject(list_ptr)) != NULL)
  850.      {
  851.     
  852.         if( !db_info->filename && ( (type == EXTCACHE && !db_info->name) || (type == SARCACHE && !db_info->path) ) )
  853.             continue;
  854.  
  855.         len = XP_FileWrite(db_info->filename, -1, fp);
  856.         if (len < 0)
  857.         {
  858.             XP_FileClose(fp);
  859.             return;
  860.         }
  861.         XP_FileWrite("\t", -1, fp);
  862.  
  863.         if ( type == EXTCACHE )
  864.             XP_FileWrite(db_info->name, -1, fp);
  865.         else
  866.         {
  867.             if ( db_info->path == NULL || *(db_info->path) == '\0' || *(db_info->path) == ' ')
  868.             {
  869.                 XP_FileWrite("\\", -1, fp);
  870.             }
  871.             else
  872.             {
  873.                 XP_FileWrite(db_info->path, -1, fp);
  874.             }
  875.         }
  876.  
  877.         len = XP_FileWrite(LINEBREAK, -1, fp);
  878.         if (len < 0)
  879.         {
  880.             XP_FileClose(fp);
  881.             return;
  882.         }
  883.       }
  884.  
  885.     XP_FileClose(fp);
  886. }
  887.  
  888. PRIVATE void 
  889. cache_SaveSARCacheInfo(void)
  890. {    
  891.     XP_File fp;
  892.     XP_List *list_ptr;
  893.  
  894.     fp = XP_FileOpen("", xpSARCacheIndex, XP_FILE_WRITE);
  895.     list_ptr = SAR_cache_database_list;
  896.  
  897.     cache_SaveCacheInfo(fp, list_ptr, SARCACHE);
  898. }
  899.  
  900. /*
  901.  * New Cache version to allow for different files, and cache lists
  902.  */
  903. PRIVATE void
  904. cache_ReadCacheInfo(XP_File fp, XP_List **list_ptr, int type)
  905. {
  906.     ExtCacheDBInfo *new_db_info;
  907.     char buf[BUF_SIZE];
  908.     char *name;
  909.  
  910.     if(!*list_ptr)
  911.       {
  912.         *list_ptr = XP_ListNew();
  913.         if(!*list_ptr)
  914.             return;
  915.       }
  916.     
  917.     if(!fp)
  918.         return;
  919.  
  920.     /* file format is:
  921.      *   Filename  <TAB> database_name
  922.      */
  923.     while(XP_FileReadLine(buf, BUF_SIZE-1, fp))
  924.       {
  925.         if (*buf == 0 || *buf == '#' || *buf == CR || *buf == LF)
  926.           continue;
  927.  
  928.         /* remove /r and /n from the end of the line */
  929.         XP_StripLine(buf);
  930.  
  931.         name = XP_STRCHR(buf, '\t');
  932.  
  933.         if(!name)
  934.             continue;
  935.  
  936.         *name++ = '\0';
  937.  
  938.         new_db_info = XP_NEW(ExtCacheDBInfo);
  939.         if(!new_db_info)
  940.             return;
  941.  
  942.         XP_MEMSET(new_db_info, 0, sizeof(ExtCacheDBInfo));
  943.  
  944.         StrAllocCopy(new_db_info->filename, buf);
  945.  
  946.         if ( type == EXTCACHE )
  947.             StrAllocCopy(new_db_info->name, name);
  948.         else
  949.             StrAllocCopy(new_db_info->path, name);
  950.  
  951.         XP_ListAddObject(*list_ptr, new_db_info);
  952.       }
  953.     
  954.     XP_FileClose(fp);
  955. }
  956.  
  957. /*
  958.  * Delete the specified cache and all the files in it.
  959.  */
  960. PUBLIC int CACHE_EmptyCache(ExtCacheDBInfo *db)
  961. {
  962.     DBT data;
  963.     DBT key;
  964.     int ret;
  965.     char *filename;
  966.  
  967. #ifdef DEBUG_francis
  968.     printf("CACHE_EmptyCache()\n");
  969. #endif
  970.  
  971.     ret = (*db->database->seq)(db->database, &key, &data, R_FIRST);
  972.  
  973.     if( 0 != ret )
  974.       {
  975. #ifdef DEBUG_francis
  976.     printf("CACHE_EmptyCache(): 0 != ret\n");
  977. #endif
  978.  
  979.         return 0;
  980.   }
  981.  
  982.     do
  983.       {
  984.         filename = net_GetFilenameInCacheDBT(&data);     
  985.         if(filename)                                      
  986.           {                                                
  987. #ifdef DEBUG_francis
  988.     printf("CACHE_EmptyCache(): removing %s\n",filename);
  989. #endif
  990.  
  991.             TRACEMSG(("Removing file: %s due to disk"       
  992.                       " cache remove",filename));     
  993.             XP_FileRemove(filename, xpSARCache);            /* *X* What will happen if I pass this */
  994.             FREE(filename);                                 /*     a relative path */
  995.           }  
  996.       }
  997.     while(0 == (*db->database->seq)(db->database, &key, &data, R_NEXT));
  998.  
  999.     db->DiskCacheSize      = 0;
  1000.     db->NumberInDiskCache = 0;
  1001.  
  1002. #ifdef DEBUG_francis
  1003.     printf("CACHE_EmptyCache(): success\n");
  1004. #endif
  1005.  
  1006.  
  1007.     return SUCCESS;
  1008. }
  1009.  
  1010. /*
  1011.  * Delete the specified cache and all the files in it.
  1012.  */
  1013. PUBLIC int CACHE_RemoveCache(ExtCacheDBInfo *db)
  1014. {
  1015.     int ret;
  1016.     ExtCacheDBInfo *db_info;
  1017.     XP_List            *tmpList;
  1018.  
  1019.     /* See if the database is open */
  1020.     if (!db->database) return 0;
  1021.  
  1022.     CACHE_EmptyCache(db);
  1023.     CACHE_CloseCache(db);
  1024.  
  1025.     /* Find the database object in my internal list */
  1026.     tmpList = SAR_cache_database_list;
  1027.     while(NULL != (db_info = (ExtCacheDBInfo *)XP_ListNextObject(tmpList)))
  1028.     {
  1029.         if(!XP_STRCMP(db->path, db_info->path) && !XP_STRCMP(db->filename, db_info->filename)) break;
  1030.     }
  1031.  
  1032.     /* Remove the cache from SAR_cache_database_list */
  1033.     if ( XP_ListRemoveObject(SAR_cache_database_list, db_info) )
  1034.         ret = XP_FileRemove(db->filename, xpSARCache);
  1035.  
  1036.     /* This was released in the call to CACHE_CloseCache above */
  1037.     db_info->database = 0;
  1038.  
  1039.     cache_freeExtCacheDBInfoObj(db_info);
  1040.  
  1041.     cache_SaveSARCacheInfo();
  1042.  
  1043.     return ret;
  1044. }
  1045.  
  1046. MODULE_PRIVATE int
  1047. CACHE_FindURLInCache(URL_Struct *URL_s, MWContext *ctxt)
  1048. {
  1049.     DBT *key;
  1050.     DBT data;
  1051.     net_CacheObject *found_cache_obj;
  1052.     ExtCacheDBInfo *db_ptr;
  1053.     int status;
  1054.     XP_StatStruct    stat_entry;
  1055.     char *filename=0;
  1056.     XP_List *list_ptr;
  1057.  
  1058.     /* larubbio */
  1059.     XP_FileType fileType;
  1060.  
  1061.     TRACEMSG(("Checking for URL in external cache"));
  1062.  
  1063.     /* zero the last modified date so that we don't
  1064.      * screw up the If-modified-since header by
  1065.      * having it in even when the document isn't
  1066.      * cached.
  1067.      */
  1068.     URL_s->last_modified = 0;
  1069.  
  1070.     if(!AtLeastOneOpenCache && !SARCacheIndexOpen)
  1071.       {
  1072.         TRACEMSG(("No External Cache databases open"));
  1073.          return(0); 
  1074.       }
  1075.  
  1076.     key = net_GenCacheDBKey(URL_s->address, 
  1077.                             URL_s->post_data, 
  1078.                             URL_s->post_data_size);
  1079.  
  1080.     status = 1;
  1081.  
  1082.     /* Search the external caches first */
  1083.     if (AtLeastOneOpenCache)
  1084.     {
  1085.         list_ptr = ext_cache_database_list;
  1086.         while((db_ptr = (ExtCacheDBInfo *)XP_ListNextObject(list_ptr)) != NULL)
  1087.           {
  1088.             if(db_ptr->database)
  1089.               {
  1090.                 TRACEMSG(("Searching databse: %s", db_ptr->name));
  1091.                 status = (*db_ptr->database->get)(db_ptr->database, key, &data, 0);
  1092.                 if(status == 0)
  1093.                 {
  1094.                     fileType = xpExtCache;
  1095.                     break;
  1096.                 }
  1097.               }
  1098.           }
  1099.     }
  1100.  
  1101.     /* Search the SAR caches next */
  1102.     if (SARCacheIndexOpen && status != 0)
  1103.     {
  1104.         list_ptr = SAR_cache_database_list;
  1105.         while((db_ptr = (ExtCacheDBInfo *)XP_ListNextObject(list_ptr)) != NULL)
  1106.         {
  1107.             if(db_ptr->database)
  1108.             {
  1109.                 TRACEMSG(("Searching databse: %s", db_ptr->name));
  1110.                 status = (*db_ptr->database->get)(db_ptr->database, key, &data, 0);
  1111.                 if(status == 0)
  1112.                 {
  1113.                    time_t cur_time = time(NULL);
  1114.  
  1115.                    /*
  1116.                     * larubbio: If were here, then the file must have
  1117.                     * been found in an external (CD or archive) cache.
  1118.                     * In order to prevent unnecessary network refresh,
  1119.                     * override the network check if the file has
  1120.                     * not already expired out of the cache and the call
  1121.                     * isnt being made from Java (so its not the Netcaster
  1122.                     * crawler).
  1123.                     */
  1124.                     if( (NULL == URL_s->SARCache) &&
  1125.                         ( (0 == URL_s->expires) || (cur_time < URL_s->expires) ))
  1126.                            URL_s->use_local_copy = 1;
  1127.  
  1128.                     fileType = xpSARCache;
  1129.                     URL_s->SARCache = db_ptr;
  1130.                     break;
  1131.                 }
  1132.             }
  1133.         }
  1134.     }
  1135.  
  1136.     if(status != 0)
  1137.     {
  1138.         TRACEMSG(("Key not found in any database"));
  1139.         net_FreeCacheDBTdata(key);
  1140.          return(0); 
  1141.     }
  1142.  
  1143.     found_cache_obj = net_Fast_DBDataToCacheStruct(&data);
  1144.  
  1145.     TRACEMSG(("mkextcache: found URL in cache!"));
  1146.  
  1147.     if(!found_cache_obj)
  1148.         return(0);
  1149.  
  1150.     /* copy in the cache file name
  1151.      */
  1152.     if(db_ptr->path 
  1153. #if REAL_TIME  /* use this for real */
  1154.         && found_cache_obj->is_relative_path
  1155. #endif
  1156.          )
  1157.       {
  1158.         if ( XP_STRCMP(db_ptr->path, "\\" ) )
  1159.             StrAllocCopy(filename, db_ptr->path);
  1160.  
  1161.         StrAllocCat(filename, found_cache_obj->filename);
  1162.       }
  1163.     else
  1164.       {
  1165.         StrAllocCopy(filename, found_cache_obj->filename);
  1166.       }
  1167.  
  1168.     /* make sure the file still exists
  1169.      * Looks like the new cache is ok since xpExtCache tells XP_Stat to use it's default
  1170.      * settings, which is what we want so I won't touch it.
  1171.      */
  1172.     if(XP_Stat(filename, &stat_entry, fileType) == -1)
  1173.       {
  1174.         /* file does not exist!!
  1175.          * remove the entry 
  1176.          */
  1177.         TRACEMSG(("Error! Cache file missing: %s", filename));
  1178.  
  1179.         net_FreeCacheDBTdata(key);
  1180.  
  1181.         FREE(filename);
  1182.  
  1183.         return(0);
  1184.             
  1185.       }
  1186.  
  1187.     /*
  1188.      * if the last accessed date is before the startup date set the
  1189.      * expiration date really low so that the URL is forced to be rechecked
  1190.      * again.  We don't just not return the URL as being in the
  1191.      * cache because we want to use "If-modified-since"
  1192.      *
  1193.      * This works correctly because mkhttp will zero the
  1194.      * expires field.
  1195.      *
  1196.      * if it's not an http url then just delete the entry
  1197.      * since we can't do an If-modified-since
  1198.      */
  1199.  
  1200.     /* since we can't set a last accessed time
  1201.      * we can't do the once per session thing.
  1202.      * Always assume EVERY TIME
  1203.      *
  1204.      *  if(found_cache_obj->last_accessed < NET_StartupTime
  1205.      *        && NET_CacheUseMethod != CU_NEVER_CHECK)
  1206.      */
  1207.     if(URL_s->use_local_copy || URL_s->history_num)
  1208.       {
  1209.         /* we already did an IMS get or it's coming out
  1210.          * of the history.
  1211.          * Set the expires to 0 so that we can now use the
  1212.          * object
  1213.          */
  1214.          URL_s->expires = 0;
  1215.       }
  1216.  
  1217.     else if(NET_CacheUseMethod != CU_NEVER_CHECK)
  1218.       {
  1219.         if(!strncasecomp(URL_s->address, "http", 4))
  1220.           {
  1221. #ifdef MOZ_OFFLINE
  1222.             if ( NET_IsOffline() )
  1223.             {
  1224.                 time_t cur_time = time(NULL);
  1225.  
  1226.                 if ( (0 == URL_s->expires) || (cur_time < URL_s->expires) )
  1227.                     URL_s->use_local_copy = 1;
  1228.             }
  1229. #endif /* MOZ_OFFLINE */
  1230.           }
  1231.         else
  1232.           {
  1233.             /* object has expired and cant use IMS. Don't return it */
  1234.  
  1235.             net_FreeCacheDBTdata(key);
  1236.             FREE(filename);
  1237.  
  1238.             return(0);
  1239.           }
  1240.       }
  1241.     else
  1242.       {
  1243.         /* otherwise use the normal expires date for CU_NEVER_CHECK */
  1244.          URL_s->expires = found_cache_obj->expires;
  1245.       }
  1246.  
  1247.     /* won't need the key anymore */
  1248.     net_FreeCacheDBTdata(key);
  1249.  
  1250.     URL_s->cache_file = filename;
  1251.  
  1252.     /* copy the contents of the URL struct so that the content type
  1253.      * and other stuff gets recorded
  1254.      */
  1255.     StrAllocCopy(URL_s->content_type,     found_cache_obj->content_type);
  1256.     StrAllocCopy(URL_s->charset,          found_cache_obj->charset);
  1257.     StrAllocCopy(URL_s->content_encoding, found_cache_obj->content_encoding);
  1258.     URL_s->content_length = found_cache_obj->content_length;
  1259.     URL_s->real_content_length = found_cache_obj->real_content_length;
  1260.      URL_s->last_modified  = found_cache_obj->last_modified;
  1261.      URL_s->is_netsite     = found_cache_obj->is_netsite;
  1262.  
  1263.     /* copy security info */
  1264.     URL_s->security_on             = found_cache_obj->security_on;
  1265.     URL_s->key_size                = found_cache_obj->key_size;
  1266.     URL_s->key_secret_size         = found_cache_obj->key_secret_size;
  1267.     StrAllocCopy(URL_s->key_cipher,  found_cache_obj->key_cipher);
  1268.  
  1269.     /* delete any existing certificate first */
  1270.     CERT_DestroyCertificate(URL_s->certificate);
  1271.     URL_s->certificate = NULL;
  1272.  
  1273.     if (found_cache_obj->certificate)
  1274.           URL_s->certificate =
  1275.             CERT_DupCertificate(found_cache_obj->certificate);
  1276.  
  1277.     TRACEMSG(("Cached copy is valid. returning method"));
  1278.  
  1279.     TRACEMSG(("Using Disk Copy"));
  1280.  
  1281.     URL_s->ext_cache_file = TRUE;
  1282.  
  1283.     return(FILE_CACHE_TYPE_URL);
  1284. }
  1285.  
  1286.  
  1287.  /* free the cache object
  1288.  */
  1289. MODULE_PRIVATE void cache_freeExtCacheDBInfoObj (ExtCacheDBInfo * cache_obj)
  1290. {
  1291.  
  1292.     FREEIF(cache_obj->database);
  1293.     FREEIF(cache_obj->filename);
  1294.     FREEIF(cache_obj->path);
  1295.     FREEIF(cache_obj->name);
  1296.  
  1297.     FREE(cache_obj);
  1298. }
  1299.  
  1300.  
  1301. PRIVATE ExtCacheDBInfo *
  1302. cache_GetSARCacheInfoFromDB(ExtCacheDBInfo *db_info)
  1303. {
  1304.     DBT key;
  1305.     DBT data;
  1306.  
  1307.     if(!db_info->database)
  1308.         return NULL;
  1309.  
  1310.     key.data = SAR_CACHE_INFO_STRING;
  1311.     key.size = XP_STRLEN(SAR_CACHE_INFO_STRING);
  1312.  
  1313.     if(0 == (*db_info->database->get)(db_info->database, &key, &data, 0))
  1314.     {
  1315.         /* convert it to a struct */
  1316.         return cache_DBDataToExtCacheDBInfoStruct(&data);
  1317.     }
  1318.  
  1319.     return(NULL);
  1320. }
  1321.  
  1322. /* Flushes the DB's contents to disk */
  1323. PUBLIC void
  1324. CACHE_FlushCache(ExtCacheDBInfo *db_info)
  1325. {
  1326.     (*db_info->database->sync)(db_info->database, 0);
  1327. }
  1328.  
  1329. PUBLIC void
  1330. CACHE_SaveCacheInfoToDB(ExtCacheDBInfo *db_info)
  1331. {
  1332.     cache_PutSARCacheInfoIntoDB(db_info);
  1333. }
  1334.  
  1335. PRIVATE int
  1336. cache_PutSARCacheInfoIntoDB(ExtCacheDBInfo *db_info)
  1337. {
  1338.     DBT key;
  1339.     DBT * data;
  1340.  
  1341.     if(!db_info->database)
  1342.         return 0;
  1343.  
  1344.     key.data = SAR_CACHE_INFO_STRING;
  1345.     key.size = XP_STRLEN(SAR_CACHE_INFO_STRING);
  1346.  
  1347.     data = cache_ExtCacheDBInfoStructToDBData(db_info);
  1348.  
  1349.     if(0 == (*db_info->database->put)(db_info->database, &key, data, 0))
  1350.     {
  1351.         /* Flush the db to disk */
  1352.         (*db_info->database->sync)(db_info->database, 0);
  1353.         return(SUCCESS);
  1354.     }
  1355.  
  1356.     return 0;
  1357. }
  1358.  
  1359. /* takes a cache object and returns a malloc'd 
  1360.  * (void *) suitible for passing in as a database
  1361.  * data storage object
  1362.  */
  1363. MODULE_PRIVATE DBT *
  1364. cache_ExtCacheDBInfoStructToDBData(ExtCacheDBInfo * old_obj)
  1365. {
  1366.     int32 len;
  1367.     char *cur_ptr;
  1368.     void *new_obj;
  1369.     int32 total_size;
  1370.     DBT *rv;
  1371.  
  1372.     rv = XP_NEW(DBT);
  1373.  
  1374.     if(!rv)
  1375.         return(NULL);
  1376.  
  1377.     total_size = sizeof(ExtCacheDBInfo);
  1378.  
  1379. #define ADD_STRING_SIZE(string) \
  1380. total_size += old_obj->string ? XP_STRLEN(old_obj->string)+1 : 0
  1381.  
  1382.     total_size += sizeof(NULL);
  1383.     ADD_STRING_SIZE(filename);
  1384.     ADD_STRING_SIZE(path);
  1385.     ADD_STRING_SIZE(name);
  1386.     total_size += sizeof(Bool);
  1387.     total_size += sizeof(uint32);
  1388.     total_size += sizeof(uint32);
  1389.     total_size += sizeof(uint32);
  1390.     total_size += sizeof(uint32);
  1391.  
  1392. #undef ADD_STRING_SIZE
  1393.     
  1394.     new_obj = XP_ALLOC(total_size * sizeof(char));
  1395.  
  1396.     if(!new_obj)
  1397.       {
  1398.         FREE(rv);
  1399.         return NULL;
  1400.       }
  1401.  
  1402.     XP_MEMSET(new_obj, 0, total_size * sizeof(char));
  1403.     /* VERY VERY IMPORTANT.  Whenever the
  1404.      * format of the record structure changes
  1405.       * you must verify that the byte positions    
  1406.      * in extcache.h are updated
  1407.      */
  1408.  
  1409. #define STUFF_STRING(string)                                     \
  1410. {                                                                 \
  1411.   len = (old_obj->string ? XP_STRLEN(old_obj->string)+1 : 0);    \
  1412.   COPY_INT32((void *)cur_ptr, &len);                            \
  1413.   cur_ptr = cur_ptr + sizeof(int32);                            \
  1414.   if(len)                                                        \
  1415.       XP_MEMCPY((void *)cur_ptr, old_obj->string, len);            \
  1416.   cur_ptr += len;                                                \
  1417. }
  1418.  
  1419. #define STUFF_NUMBER(number)                                     \
  1420. {                                                                 \
  1421.   COPY_INT32((void *)cur_ptr, &old_obj->number);                \
  1422.   cur_ptr = cur_ptr + sizeof(int32);                            \
  1423. }
  1424.  
  1425. #define STUFF_BOOL(bool_val)                                         \
  1426. {                                                                     \
  1427.   if(old_obj->bool_val)                                                \
  1428.     ((char *)(cur_ptr))[0] = 1;                                        \
  1429.   else                                                                \
  1430.     ((char *)(cur_ptr))[0] = 0;                                        \
  1431.   cur_ptr = cur_ptr + sizeof(char);                                    \
  1432. }
  1433.  
  1434.     cur_ptr = (char *)new_obj;
  1435.  
  1436.     /* put the total size of the struct into
  1437.      * the first field so that we have
  1438.      * a cross check against corruption
  1439.      */
  1440.       COPY_INT32((void *)cur_ptr, &total_size);
  1441.       cur_ptr = cur_ptr + sizeof(int32);
  1442.  
  1443.     STUFF_STRING(filename);
  1444.     STUFF_STRING(path);
  1445.     STUFF_STRING(name);
  1446.     STUFF_BOOL(queried_this_session);
  1447.     STUFF_NUMBER(type);
  1448.     STUFF_NUMBER(DiskCacheSize);
  1449.     STUFF_NUMBER(NumberInDiskCache);
  1450.     STUFF_NUMBER(MaxSize);
  1451.  
  1452. #undef STUFF_STRING
  1453. #undef STUFF_NUMBER
  1454. #undef STUFF_BOOL
  1455.  
  1456.     rv->data = new_obj;
  1457.     rv->size = total_size;
  1458.  
  1459.     return(rv);
  1460. }
  1461.  
  1462. /* takes a database storage object and returns a malloc'd
  1463.  * cache data object.  The cache object needs all of
  1464.  * it's parts free'd.
  1465.  *
  1466.  * returns NULL on parse error 
  1467.  */
  1468. MODULE_PRIVATE ExtCacheDBInfo *
  1469. cache_DBDataToExtCacheDBInfoStruct(DBT * db_obj)
  1470. {
  1471.     ExtCacheDBInfo * rv = XP_NEW(ExtCacheDBInfo);
  1472.     char * cur_ptr;
  1473.     char * max_ptr;
  1474.     uint32 len;
  1475.  
  1476.     if(!rv)
  1477.         return NULL;
  1478.  
  1479.     XP_MEMSET(rv, 0, sizeof(ExtCacheDBInfo));
  1480.  
  1481. /* if any strings are larger than this then
  1482.  * there was a serious database error
  1483.  */
  1484. #define MAX_HUGE_STRING_SIZE 10000
  1485.  
  1486. #define RETRIEVE_STRING(string)                    \
  1487. {                                                \
  1488.     if(cur_ptr > max_ptr)                       \
  1489.       {                                             \
  1490.         cache_freeExtCacheDBInfoObj(rv);        \
  1491.         return(NULL);                           \
  1492.       }                                            \
  1493.     COPY_INT32(&len, cur_ptr);                    \
  1494.     cur_ptr += sizeof(int32);                    \
  1495.     if(len)                                        \
  1496.       {                                            \
  1497.         if(len > MAX_HUGE_STRING_SIZE)            \
  1498.           {                                         \
  1499.             cache_freeExtCacheDBInfoObj(rv);    \
  1500.             return(NULL);                        \
  1501.           }                                        \
  1502.         rv->string = (char*)XP_ALLOC(len);        \
  1503.         if(!rv->string)                            \
  1504.           {                                         \
  1505.             cache_freeExtCacheDBInfoObj(rv);    \
  1506.             return(NULL);                        \
  1507.           }                                        \
  1508.         XP_MEMCPY(rv->string, cur_ptr, len);    \
  1509.         cur_ptr += len;                            \
  1510.       }                                            \
  1511. }                                            
  1512.  
  1513. #define RETRIEVE_NUMBER(number)                    \
  1514. {                                                \
  1515.     if(cur_ptr > max_ptr)                       \
  1516.         return(rv);                             \
  1517.     COPY_INT32(&rv->number, cur_ptr);            \
  1518.     cur_ptr += sizeof(int32);                    \
  1519. }
  1520.  
  1521. #define RETRIEVE_BOOL(bool)                \
  1522. {                                        \
  1523.   if(cur_ptr > max_ptr)                 \
  1524.     return(rv);                         \
  1525.   if(((char *)(cur_ptr))[0])            \
  1526.     rv->bool = TRUE;                    \
  1527.   else                                     \
  1528.     rv->bool = FALSE;                    \
  1529.   cur_ptr += sizeof(char);                \
  1530. }
  1531.  
  1532.     cur_ptr = (char *)db_obj->data;
  1533.  
  1534.     max_ptr = cur_ptr+db_obj->size;
  1535.  
  1536.     /* get the total size of the struct out of
  1537.      * the first field to check it
  1538.      */
  1539.     COPY_INT32(&len, cur_ptr);
  1540.     cur_ptr += sizeof(int32);
  1541.  
  1542.     if(len != db_obj->size)
  1543.       {
  1544.         TRACEMSG(("Size going in is not the same as size coming out"));
  1545.         FREE(rv);
  1546.         return(NULL);
  1547.       }
  1548.  
  1549.     RETRIEVE_STRING(filename);
  1550.     RETRIEVE_STRING(path);
  1551.     RETRIEVE_STRING(name);
  1552.     RETRIEVE_BOOL(queried_this_session);
  1553.     RETRIEVE_NUMBER(type);
  1554.     RETRIEVE_NUMBER(DiskCacheSize);
  1555.     RETRIEVE_NUMBER(NumberInDiskCache);
  1556.     RETRIEVE_NUMBER(MaxSize);
  1557.  
  1558.     return(rv);
  1559. }
  1560.  
  1561. #endif /* MOZILLA_CLIENT */
  1562.