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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
cache.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：25k
源码类别：

midi

开发平台：

Unix_Linux

cache.c：源码内容
  1. /*****************************************************************************
  2.  * cache.c: Plugins cache
  3.  *****************************************************************************
  4.  * Copyright (C) 2001-2007 the VideoLAN team
  5.  * $Id: 89d1a99a6d51f0a798c25fc33b2133097c058f5e $
  6.  *
  7.  * Authors: Sam Hocevar <sam@zoy.org>
  8.  *          Ethan C. Baldridge <BaldridgeE@cadmus.com>
  9.  *          Hans-Peter Jansen <hpj@urpla.net>
  10.  *          Gildas Bazin <gbazin@videolan.org>
  11.  *
  12.  * This program is free software; you can redistribute it and/or modify
  13.  * it under the terms of the GNU General Public License as published by
  14.  * the Free Software Foundation; either version 2 of the License, or
  15.  * (at your option) any later version.
  16.  *
  17.  * This program is distributed in the hope that it will be useful,
  18.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20.  * GNU General Public License for more details.
  21.  *
  22.  * You should have received a copy of the GNU General Public License
  23.  * along with this program; if not, write to the Free Software
  24.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  25.  *****************************************************************************/
  27. #ifdef HAVE_CONFIG_H
  28. # include "config.h"
  29. #endif
  31. #include <vlc_common.h>
  32. #include "libvlc.h"
  34. #include <stdlib.h>                                      /* free(), strtol() */
  35. #include <stdio.h>                                              /* sprintf() */
  36. #include <string.h>                                              /* strdup() */
  37. #include <vlc_plugin.h>
  39. #ifdef HAVE_SYS_TYPES_H
  40. #   include <sys/types.h>
  41. #endif
  42. #ifdef HAVE_UNISTD_H
  43. #   include <unistd.h>
  44. #endif
  46. #if !defined(HAVE_DYNAMIC_PLUGINS)
  47.     /* no support for plugins */
  48. #elif defined(HAVE_DL_DYLD)
  49. #   if defined(HAVE_MACH_O_DYLD_H)
  50. #       include <mach-o/dyld.h>
  51. #   endif
  52. #elif defined(HAVE_DL_BEOS)
  53. #   if defined(HAVE_IMAGE_H)
  54. #       include <image.h>
  55. #   endif
  56. #elif defined(HAVE_DL_WINDOWS)
  57. #   include <windows.h>
  58. #elif defined(HAVE_DL_DLOPEN)
  59. #   if defined(HAVE_DLFCN_H) /* Linux, BSD, Hurd */
  60. #       include <dlfcn.h>
  61. #   endif
  62. #   if defined(HAVE_SYS_DL_H)
  63. #       include <sys/dl.h>
  64. #   endif
  65. #elif defined(HAVE_DL_SHL_LOAD)
  66. #   if defined(HAVE_DL_H)
  67. #       include <dl.h>
  68. #   endif
  69. #endif
  71. #include "config/configuration.h"
  73. #include "vlc_charset.h"
  75. #include "modules/modules.h"
  78. /*****************************************************************************
  79.  * Local prototypes
  80.  *****************************************************************************/
  81. #ifdef HAVE_DYNAMIC_PLUGINS
  82. static int    CacheLoadConfig  ( module_t *, FILE * );
  83. static int    CacheSaveConfig  ( module_t *, FILE * );
  85. /* Sub-version number
  86.  * (only used to avoid breakage in dev version when cache structure changes) */
  87. #define CACHE_SUBVERSION_NUM 4
  89. /* Format string for the cache filename */
  90. #define CACHENAME_FORMAT 
  91.     "plugins-%.2zx%.2zx%.2"PRIx8".dat"
  92. /* Magic for the cache filename */
  93. #define CACHENAME_VALUES 
  94.     sizeof(int), sizeof(void *), *(uint8_t *)&(uint16_t){ 0xbe1e }
  97. /*****************************************************************************
  98.  * LoadPluginsCache: loads the plugins cache file
  99.  *****************************************************************************
  100.  * This function will load the plugin cache if present and valid. This cache
  101.  * will in turn be queried by AllocateAllPlugins() to see if it needs to
  102.  * actually load the dynamically loadable module.
  103.  * This allows us to only fully load plugins when they are actually used.
  104.  *****************************************************************************/
  105. void CacheLoad( vlc_object_t *p_this, module_bank_t *p_bank, bool b_delete )
  106. {
  107.     char *psz_filename, *psz_cachedir = config_GetCacheDir();
  108.     FILE *file;
  109.     int i, j, i_size, i_read;
  110.     char p_cachestring[sizeof("cache " COPYRIGHT_MESSAGE)];
  111.     char p_cachelang[6], p_lang[6];
  112.     int i_cache;
  113.     module_cache_t **pp_cache = 0;
  114.     int32_t i_file_size, i_marker;
  116.     if( !psz_cachedir ) /* XXX: this should never happen */
  117.     {
  118.         msg_Err( p_this, "Unable to get cache directory" );
  119.         return;
  120.     }
  122.     if( asprintf( &psz_filename, "%s"DIR_SEP CACHENAME_FORMAT,
  123.                   psz_cachedir, CACHENAME_VALUES ) == -1 )
  124.     {
  125.         free( psz_cachedir );
  126.         return;
  127.     }
  128.     free( psz_cachedir );
  130.     if( b_delete )
  131.     {
  132. #if !defined( UNDER_CE )
  133.         unlink( psz_filename );
  134. #else
  135.         wchar_t psz_wf[MAX_PATH];
  136.         MultiByteToWideChar( CP_ACP, 0, psz_filename, -1, psz_wf, MAX_PATH );
  137.         DeleteFile( psz_wf );
  138. #endif
  139.         msg_Dbg( p_this, "removing plugins cache file %s", psz_filename );
  140.         free( psz_filename );
  141.         return;
  142.     }
  144.     msg_Dbg( p_this, "loading plugins cache file %s", psz_filename );
  146.     file = utf8_fopen( psz_filename, "rb" );
  147.     if( !file )
  148.     {
  149.         msg_Warn( p_this, "could not open plugins cache file %s for reading",
  150.                   psz_filename );
  151.         free( psz_filename );
  152.         return;
  153.     }
  154.     free( psz_filename );
  156.     /* Check the file size */
  157.     i_read = fread( &i_file_size, 1, sizeof(i_file_size), file );
  158.     if( i_read != sizeof(i_file_size) )
  159.     {
  160.         msg_Warn( p_this, "This doesn't look like a valid plugins cache "
  161.                   "(too short)" );
  162.         fclose( file );
  163.         return;
  164.     }
  166.     fseek( file, 0, SEEK_END );
  167.     if( ftell( file ) != i_file_size )
  168.     {
  169.         msg_Warn( p_this, "This doesn't look like a valid plugins cache "
  170.                   "(corrupted size)" );
  171.         fclose( file );
  172.         return;
  173.     }
  174.     fseek( file, sizeof(i_file_size), SEEK_SET );
  176.     /* Check the file is a plugins cache */
  177.     i_size = sizeof("cache " COPYRIGHT_MESSAGE) - 1;
  178.     i_read = fread( p_cachestring, 1, i_size, file );
  179.     if( i_read != i_size ||
  180.         memcmp( p_cachestring, "cache " COPYRIGHT_MESSAGE, i_size ) )
  181.     {
  182.         msg_Warn( p_this, "This doesn't look like a valid plugins cache" );
  183.         fclose( file );
  184.         return;
  185.     }
  187. #ifdef DISTRO_VERSION
  188.     /* Check for distribution specific version */
  189.     char p_distrostring[sizeof( DISTRO_VERSION )];
  190.     i_size = sizeof( DISTRO_VERSION ) - 1;
  191.     i_read = fread( p_distrostring, 1, i_size, file );
  192.     if( i_read != i_size ||
  193.         memcmp( p_distrostring, DISTRO_VERSION, i_size ) )
  194.     {
  195.         msg_Warn( p_this, "This doesn't look like a valid plugins cache" );
  196.         fclose( file );
  197.         return;
  198.     }
  199. #endif
  201.     /* Check Sub-version number */
  202.     i_read = fread( &i_marker, 1, sizeof(i_marker), file );
  203.     if( i_read != sizeof(i_marker) || i_marker != CACHE_SUBVERSION_NUM )
  204.     {
  205.         msg_Warn( p_this, "This doesn't look like a valid plugins cache "
  206.                   "(corrupted header)" );
  207.         fclose( file );
  208.         return;
  209.     }
  211.     /* Check the language hasn't changed */
  212.     sprintf( p_lang, "%5.5s", _("C") ); i_size = 5;
  213.     i_read = fread( p_cachelang, 1, i_size, file );
  214.     if( i_read != i_size || memcmp( p_cachelang, p_lang, i_size ) )
  215.     {
  216.         msg_Warn( p_this, "This doesn't look like a valid plugins cache "
  217.                   "(language changed)" );
  218.         fclose( file );
  219.         return;
  220.     }
  222.     /* Check header marker */
  223.     i_read = fread( &i_marker, 1, sizeof(i_marker), file );
  224.     if( i_read != sizeof(i_marker) ||
  225.         i_marker != ftell( file ) - (int)sizeof(i_marker) )
  226.     {
  227.         msg_Warn( p_this, "This doesn't look like a valid plugins cache "
  228.                   "(corrupted header)" );
  229.         fclose( file );
  230.         return;
  231.     }
  233.     p_bank->i_loaded_cache = 0;
  234.     if (fread( &i_cache, 1, sizeof(i_cache), file ) != sizeof(i_cache) )
  235.     {
  236.         msg_Warn( p_this, "This doesn't look like a valid plugins cache "
  237.                   "(file too short)" );
  238.         fclose( file );
  239.         return;
  240.     }
  242.     if( i_cache )
  243.         pp_cache = p_bank->pp_loaded_cache =
  244.                    malloc( i_cache * sizeof(void *) );
  246. #define LOAD_IMMEDIATE(a) 
  247.     if( fread( (void *)&a, sizeof(char), sizeof(a), file ) != sizeof(a) ) goto error
  248. #define LOAD_STRING(a) 
  249. { 
  250.     a = NULL; 
  251.     if( ( fread( &i_size, sizeof(i_size), 1, file ) != 1 ) 
  252.      || ( i_size > 16384 ) ) 
  253.         goto error; 
  254.     if( i_size ) { 
  255.         char *psz = malloc( i_size ); 
  256.         if( fread( psz, i_size, 1, file ) != 1 ) { 
  257.             free( psz ); 
  258.             goto error; 
  259.         } 
  260.         if( psz[i_size-1] ) { 
  261.             free( psz ); 
  262.             goto error; 
  263.         } 
  264.         a = psz; 
  265.     } 
  266. }
  268.     for( i = 0; i < i_cache; i++ )
  269.     {
  270.         uint16_t i_size;
  271.         int i_submodules;
  273.         pp_cache[i] = malloc( sizeof(module_cache_t) );
  274.         p_bank->i_loaded_cache++;
  276.         /* Load common info */
  277.         LOAD_STRING( pp_cache[i]->psz_file );
  278.         LOAD_IMMEDIATE( pp_cache[i]->i_time );
  279.         LOAD_IMMEDIATE( pp_cache[i]->i_size );
  280.         LOAD_IMMEDIATE( pp_cache[i]->b_junk );
  281.         pp_cache[i]->b_used = false;
  283.         if( pp_cache[i]->b_junk ) continue;
  285.         pp_cache[i]->p_module = vlc_module_create( p_this );
  287.         /* Load additional infos */
  288.         free( pp_cache[i]->p_module->psz_object_name );
  289.         LOAD_STRING( pp_cache[i]->p_module->psz_object_name );
  290.         LOAD_STRING( pp_cache[i]->p_module->psz_shortname );
  291.         LOAD_STRING( pp_cache[i]->p_module->psz_longname );
  292.         LOAD_STRING( pp_cache[i]->p_module->psz_help );
  293.         for( j = 0; j < MODULE_SHORTCUT_MAX; j++ )
  294.         {
  295.             LOAD_STRING( pp_cache[i]->p_module->pp_shortcuts[j] ); // FIX
  296.         }
  297.         LOAD_STRING( pp_cache[i]->p_module->psz_capability );
  298.         LOAD_IMMEDIATE( pp_cache[i]->p_module->i_score );
  299.         LOAD_IMMEDIATE( pp_cache[i]->p_module->i_cpu );
  300.         LOAD_IMMEDIATE( pp_cache[i]->p_module->b_unloadable );
  301.         LOAD_IMMEDIATE( pp_cache[i]->p_module->b_reentrant );
  302.         LOAD_IMMEDIATE( pp_cache[i]->p_module->b_submodule );
  304.         /* Config stuff */
  305.         if( CacheLoadConfig( pp_cache[i]->p_module, file ) != VLC_SUCCESS )
  306.             goto error;
  308.         LOAD_STRING( pp_cache[i]->p_module->psz_filename );
  310.         LOAD_IMMEDIATE( i_submodules );
  312.         while( i_submodules-- )
  313.         {
  314.             module_t *p_module = vlc_submodule_create( pp_cache[i]->p_module );
  315.             free( p_module->psz_object_name );
  316.             LOAD_STRING( p_module->psz_object_name );
  317.             LOAD_STRING( p_module->psz_shortname );
  318.             LOAD_STRING( p_module->psz_longname );
  319.             LOAD_STRING( p_module->psz_help );
  320.             for( j = 0; j < MODULE_SHORTCUT_MAX; j++ )
  321.             {
  322.                 LOAD_STRING( p_module->pp_shortcuts[j] ); // FIX
  323.             }
  324.             LOAD_STRING( p_module->psz_capability );
  325.             LOAD_IMMEDIATE( p_module->i_score );
  326.             LOAD_IMMEDIATE( p_module->i_cpu );
  327.             LOAD_IMMEDIATE( p_module->b_unloadable );
  328.             LOAD_IMMEDIATE( p_module->b_reentrant );
  329.         }
  330.     }
  332.     fclose( file );
  333.     return;
  335.  error:
  337.     msg_Warn( p_this, "plugins cache not loaded (corrupted)" );
  339.     /* TODO: cleanup */
  340.     p_bank->i_loaded_cache = 0;
  342.     fclose( file );
  343.     return;
  344. }
  347. static int CacheLoadConfig( module_t *p_module, FILE *file )
  348. {
  349.     uint32_t i_lines;
  350.     uint16_t i_size;
  352.     /* Calculate the structure length */
  353.     LOAD_IMMEDIATE( p_module->i_config_items );
  354.     LOAD_IMMEDIATE( p_module->i_bool_items );
  356.     LOAD_IMMEDIATE( i_lines );
  358.     /* Allocate memory */
  359.     if (i_lines)
  360.     {
  361.         p_module->p_config =
  362.             (module_config_t *)calloc( i_lines, sizeof(module_config_t) );
  363.         if( p_module->p_config == NULL )
  364.         {
  365.             p_module->confsize = 0;
  366.             return VLC_ENOMEM;
  367.         }
  368.     }
  369.     p_module->confsize = i_lines;
  371.     /* Do the duplication job */
  372.     for (size_t i = 0; i < i_lines; i++ )
  373.     {
  374.         LOAD_IMMEDIATE( p_module->p_config[i] );
  376.         LOAD_STRING( p_module->p_config[i].psz_type );
  377.         LOAD_STRING( p_module->p_config[i].psz_name );
  378.         LOAD_STRING( p_module->p_config[i].psz_text );
  379.         LOAD_STRING( p_module->p_config[i].psz_longtext );
  380.         LOAD_STRING( p_module->p_config[i].psz_oldname );
  381.         LOAD_IMMEDIATE( p_module->p_config[i].b_removed );
  383.         if (IsConfigStringType (p_module->p_config[i].i_type))
  384.         {
  385.             LOAD_STRING (p_module->p_config[i].orig.psz);
  386.             p_module->p_config[i].value.psz =
  387.                     (p_module->p_config[i].orig.psz != NULL)
  388.                         ? strdup (p_module->p_config[i].orig.psz) : NULL;
  389.             p_module->p_config[i].saved.psz = NULL;
  390.         }
  391.         else
  392.         {
  393.             memcpy (&p_module->p_config[i].value, &p_module->p_config[i].orig,
  394.                     sizeof (p_module->p_config[i].value));
  395.             memcpy (&p_module->p_config[i].saved, &p_module->p_config[i].orig,
  396.                     sizeof (p_module->p_config[i].saved));
  397.         }
  399.         p_module->p_config[i].b_dirty = false;
  401.         p_module->p_config[i].p_lock = &p_module->lock;
  403.         if( p_module->p_config[i].i_list )
  404.         {
  405.             if( p_module->p_config[i].ppsz_list )
  406.             {
  407.                 int j;
  408.                 p_module->p_config[i].ppsz_list =
  409.                     malloc( (p_module->p_config[i].i_list+1) * sizeof(char *));
  410.                 if( p_module->p_config[i].ppsz_list )
  411.                 {
  412.                     for( j = 0; j < p_module->p_config[i].i_list; j++ )
  413.                         LOAD_STRING( p_module->p_config[i].ppsz_list[j] );
  414.                     p_module->p_config[i].ppsz_list[j] = NULL;
  415.                 }
  416.             }
  417.             if( p_module->p_config[i].ppsz_list_text )
  418.             {
  419.                 int j;
  420.                 p_module->p_config[i].ppsz_list_text =
  421.                     malloc( (p_module->p_config[i].i_list+1) * sizeof(char *));
  422.                 if( p_module->p_config[i].ppsz_list_text )
  423.                 {
  424.                   for( j = 0; j < p_module->p_config[i].i_list; j++ )
  425.                       LOAD_STRING( p_module->p_config[i].ppsz_list_text[j] );
  426.                   p_module->p_config[i].ppsz_list_text[j] = NULL;
  427.                 }
  428.             }
  429.             if( p_module->p_config[i].pi_list )
  430.             {
  431.                 p_module->p_config[i].pi_list =
  432.                     malloc( (p_module->p_config[i].i_list + 1) * sizeof(int) );
  433.                 if( p_module->p_config[i].pi_list )
  434.                 {
  435.                     for (int j = 0; j < p_module->p_config[i].i_list; j++)
  436.                         LOAD_IMMEDIATE( p_module->p_config[i].pi_list[j] );
  437.                 }
  438.             }
  439.         }
  441.         if( p_module->p_config[i].i_action )
  442.         {
  443.             p_module->p_config[i].ppf_action =
  444.                 malloc( p_module->p_config[i].i_action * sizeof(void *) );
  445.             p_module->p_config[i].ppsz_action_text =
  446.                 malloc( p_module->p_config[i].i_action * sizeof(char *) );
  448.             for (int j = 0; j < p_module->p_config[i].i_action; j++)
  449.             {
  450.                 p_module->p_config[i].ppf_action[j] = 0;
  451.                 LOAD_STRING( p_module->p_config[i].ppsz_action_text[j] );
  452.             }
  453.         }
  455.         LOAD_IMMEDIATE( p_module->p_config[i].pf_callback );
  456.     }
  458.     return VLC_SUCCESS;
  460.  error:
  462.     return VLC_EGENERIC;
  463. }
  465. static int CacheSaveSubmodule( FILE *file, module_t *p_module );
  467. /*****************************************************************************
  468.  * SavePluginsCache: saves the plugins cache to a file
  469.  *****************************************************************************/
  470. void CacheSave( vlc_object_t *p_this, module_bank_t *p_bank )
  471. {
  472.     static char const psz_tag[] =
  473.         "Signature: 8a477f597d28d172789f06886806bc55rn"
  474.         "# This file is a cache directory tag created by VLC.rn"
  475.         "# For information about cache directory tags, see:rn"
  476.         "#   http://www.brynosaurus.com/cachedir/rn";
  478.     char *psz_cachedir = config_GetCacheDir();
  479.     FILE *file;
  480.     int i, j, i_cache;
  481.     module_cache_t **pp_cache;
  482.     uint32_t i_file_size = 0;
  484.     if( !psz_cachedir ) /* XXX: this should never happen */
  485.     {
  486.         msg_Err( p_this, "unable to get cache directory" );
  487.         return;
  488.     }
  490.     char psz_filename[sizeof(DIR_SEP) + 32 + strlen(psz_cachedir)];
  491.     config_CreateDir( p_this, psz_cachedir );
  493.     snprintf( psz_filename, sizeof( psz_filename ),
  494.               "%s"DIR_SEP"CACHEDIR.TAG", psz_cachedir );
  495.     file = utf8_fopen( psz_filename, "wb" );
  496.     if (file != NULL)
  497.     {
  498.         if (fwrite (psz_tag, 1, sizeof (psz_tag) - 1, file) != 1)
  499.             clearerr (file); /* what else can we do? */
  500.         fclose( file );
  501.     }
  503.     snprintf( psz_filename, sizeof( psz_filename ),
  504.               "%s"DIR_SEP CACHENAME_FORMAT, psz_cachedir,
  505.               CACHENAME_VALUES );
  506.     free( psz_cachedir );
  507.     msg_Dbg( p_this, "writing plugins cache %s", psz_filename );
  509.     char psz_tmpname[sizeof (psz_filename) + 12];
  510.     snprintf (psz_tmpname, sizeof (psz_tmpname), "%s.%"PRIu32, psz_filename,
  511. #ifdef UNDER_CE
  512.               (uint32_t)GetCurrentProcessId ()
  513. #else
  514.               (uint32_t)getpid ()
  515. #endif
  516.              );
  517.     file = utf8_fopen( psz_tmpname, "wb" );
  518.     if (file == NULL)
  519.         goto error;
  521.     /* Empty space for file size */
  522.     if (fwrite (&i_file_size, sizeof (i_file_size), 1, file) != 1)
  523.         goto error;
  525.     /* Contains version number */
  526.     if (fputs ("cache "COPYRIGHT_MESSAGE, file) == EOF)
  527.         goto error;
  528. #ifdef DISTRO_VERSION
  529.     /* Allow binary maintaner to pass a string to detect new binary version*/
  530.     if (fputs( DISTRO_VERSION, file ) == EOF)
  531.         goto error;
  532. #endif
  533.     /* Sub-version number (to avoid breakage in the dev version when cache
  534.      * structure changes) */
  535.     i_file_size = CACHE_SUBVERSION_NUM;
  536.     if (fwrite (&i_file_size, sizeof (i_file_size), 1, file) != 1 )
  537.         goto error;
  539.     /* Language */
  540.     if (fprintf (file, "%5.5s", _("C")) == EOF)
  541.         goto error;
  543.     /* Header marker */
  544.     i_file_size = ftell( file );
  545.     if (fwrite (&i_file_size, sizeof (i_file_size), 1, file) != 1)
  546.         goto error;
  548.     i_cache = p_bank->i_cache;
  549.     pp_cache = p_bank->pp_cache;
  551.     if (fwrite( &i_cache, sizeof (i_cache), 1, file) != 1)
  552.         goto error;
  554. #define SAVE_IMMEDIATE( a ) 
  555.     if (fwrite (&a, sizeof(a), 1, file) != 1) 
  556.         goto error
  557. #define SAVE_STRING( a ) 
  558.     { 
  559.         uint16_t i_size = (a != NULL) ? (strlen (a) + 1) : 0; 
  560.         if ((fwrite (&i_size, sizeof (i_size), 1, file) != 1) 
  561.          || (a && (fwrite (a, 1, i_size, file) != i_size))) 
  562.             goto error; 
  563.     } while(0)
  565.     for( i = 0; i < i_cache; i++ )
  566.     {
  567.         uint32_t i_submodule;
  569.         /* Save common info */
  570.         SAVE_STRING( pp_cache[i]->psz_file );
  571.         SAVE_IMMEDIATE( pp_cache[i]->i_time );
  572.         SAVE_IMMEDIATE( pp_cache[i]->i_size );
  573.         SAVE_IMMEDIATE( pp_cache[i]->b_junk );
  575.         if( pp_cache[i]->b_junk ) continue;
  577.         /* Save additional infos */
  578.         SAVE_STRING( pp_cache[i]->p_module->psz_object_name );
  579.         SAVE_STRING( pp_cache[i]->p_module->psz_shortname );
  580.         SAVE_STRING( pp_cache[i]->p_module->psz_longname );
  581.         SAVE_STRING( pp_cache[i]->p_module->psz_help );
  582.         for( j = 0; j < MODULE_SHORTCUT_MAX; j++ )
  583.         {
  584.             SAVE_STRING( pp_cache[i]->p_module->pp_shortcuts[j] ); // FIX
  585.         }
  586.         SAVE_STRING( pp_cache[i]->p_module->psz_capability );
  587.         SAVE_IMMEDIATE( pp_cache[i]->p_module->i_score );
  588.         SAVE_IMMEDIATE( pp_cache[i]->p_module->i_cpu );
  589.         SAVE_IMMEDIATE( pp_cache[i]->p_module->b_unloadable );
  590.         SAVE_IMMEDIATE( pp_cache[i]->p_module->b_reentrant );
  591.         SAVE_IMMEDIATE( pp_cache[i]->p_module->b_submodule );
  593.         /* Config stuff */
  594.         if (CacheSaveConfig (pp_cache[i]->p_module, file))
  595.             goto error;
  597.         SAVE_STRING( pp_cache[i]->p_module->psz_filename );
  599.         i_submodule = pp_cache[i]->p_module->submodule_count;
  600.         SAVE_IMMEDIATE( i_submodule );
  601.         if( CacheSaveSubmodule( file, pp_cache[i]->p_module->submodule ) )
  602.             goto error;
  603.     }
  605.     /* Fill-up file size */
  606.     i_file_size = ftell( file );
  607.     fseek( file, 0, SEEK_SET );
  608.     if (fwrite (&i_file_size, sizeof (i_file_size), 1, file) != 1
  609.      || fflush (file)) /* flush libc buffers */
  610.         goto error;
  612. #ifndef WIN32
  613.     utf8_rename (psz_tmpname, psz_filename); /* atomically replace old cache */
  614.     fclose (file);
  615. #else
  616.     utf8_unlink (psz_filename);
  617.     fclose (file);
  618.     utf8_rename (psz_tmpname, psz_filename);
  619. #endif
  620.     return; /* success! */
  622. error:
  623.     msg_Warn (p_this, "could not write plugins cache %s (%m)",
  624.               psz_filename);
  625.     if (file != NULL)
  626.     {
  627.         clearerr (file);
  628.         fclose (file);
  629.     }
  630. }
  632. static int CacheSaveSubmodule( FILE *file, module_t *p_module )
  633. {
  634.     if( !p_module )
  635.         return 0;
  636.     if( CacheSaveSubmodule( file, p_module->next ) )
  637.         goto error;
  639.     SAVE_STRING( p_module->psz_object_name );
  640.     SAVE_STRING( p_module->psz_shortname );
  641.     SAVE_STRING( p_module->psz_longname );
  642.     SAVE_STRING( p_module->psz_help );
  643.     for( unsigned j = 0; j < MODULE_SHORTCUT_MAX; j++ )
  644.          SAVE_STRING( p_module->pp_shortcuts[j] ); // FIXME
  646.     SAVE_STRING( p_module->psz_capability );
  647.     SAVE_IMMEDIATE( p_module->i_score );
  648.     SAVE_IMMEDIATE( p_module->i_cpu );
  649.     SAVE_IMMEDIATE( p_module->b_unloadable );
  650.     SAVE_IMMEDIATE( p_module->b_reentrant );
  651.     return 0;
  653. error:
  654.     return -1;
  655. }
  658. static int CacheSaveConfig( module_t *p_module, FILE *file )
  659. {
  660.     uint32_t i_lines = p_module->confsize;
  662.     SAVE_IMMEDIATE( p_module->i_config_items );
  663.     SAVE_IMMEDIATE( p_module->i_bool_items );
  664.     SAVE_IMMEDIATE( i_lines );
  666.     for (size_t i = 0; i < i_lines ; i++)
  667.     {
  668.         SAVE_IMMEDIATE( p_module->p_config[i] );
  670.         SAVE_STRING( p_module->p_config[i].psz_type );
  671.         SAVE_STRING( p_module->p_config[i].psz_name );
  672.         SAVE_STRING( p_module->p_config[i].psz_text );
  673.         SAVE_STRING( p_module->p_config[i].psz_longtext );
  674.         SAVE_STRING( p_module->p_config[i].psz_oldname );
  675.         SAVE_IMMEDIATE( p_module->p_config[i].b_removed );
  677.         if (IsConfigStringType (p_module->p_config[i].i_type))
  678.             SAVE_STRING( p_module->p_config[i].orig.psz );
  680.         if( p_module->p_config[i].i_list )
  681.         {
  682.             if( p_module->p_config[i].ppsz_list )
  683.             {
  684.                 for (int j = 0; j < p_module->p_config[i].i_list; j++)
  685.                     SAVE_STRING( p_module->p_config[i].ppsz_list[j] );
  686.             }
  688.             if( p_module->p_config[i].ppsz_list_text )
  689.             {
  690.                 for (int j = 0; j < p_module->p_config[i].i_list; j++)
  691.                     SAVE_STRING( p_module->p_config[i].ppsz_list_text[j] );
  692.             }
  693.             if( p_module->p_config[i].pi_list )
  694.             {
  695.                 for (int j = 0; j < p_module->p_config[i].i_list; j++)
  696.                     SAVE_IMMEDIATE( p_module->p_config[i].pi_list[j] );
  697.             }
  698.         }
  700.         for (int j = 0; j < p_module->p_config[i].i_action; j++)
  701.             SAVE_STRING( p_module->p_config[i].ppsz_action_text[j] );
  703.         SAVE_IMMEDIATE( p_module->p_config[i].pf_callback );
  704.     }
  705.     return 0;
  707. error:
  708.     return -1;
  709. }
  711. /*****************************************************************************
  712.  * CacheMerge: Merge a cache module descriptor with a full module descriptor.
  713.  *****************************************************************************/
  714. void CacheMerge( vlc_object_t *p_this, module_t *p_cache, module_t *p_module )
  715. {
  716.     (void)p_this;
  718.     p_cache->pf_activate = p_module->pf_activate;
  719.     p_cache->pf_deactivate = p_module->pf_deactivate;
  720.     p_cache->handle = p_module->handle;
  722.     /* FIXME: This looks too simplistic an algorithm to me. What if the module
  723.      * file was altered such that the number of order of submodules was
  724.      * altered... after VLC started -- Courmisch, 09/2008 */
  725.     module_t *p_child = p_module->submodule,
  726.              *p_cchild = p_cache->submodule;
  727.     while( p_child && p_cchild )
  728.     {
  729.         p_cchild->pf_activate = p_child->pf_activate;
  730.         p_cchild->pf_deactivate = p_child->pf_deactivate;
  731.         p_child = p_child->next;
  732.         p_cchild = p_cchild->next;
  733.     }
  735.     p_cache->b_loaded = true;
  736.     p_module->b_loaded = false;
  737. }
  739. /*****************************************************************************
  740.  * CacheFind: finds the cache entry corresponding to a file
  741.  *****************************************************************************/
  742. module_cache_t *CacheFind( module_bank_t *p_bank, const char *psz_file,
  743.                            int64_t i_time, int64_t i_size )
  744. {
  745.     module_cache_t **pp_cache;
  746.     int i_cache, i;
  748.     pp_cache = p_bank->pp_loaded_cache;
  749.     i_cache = p_bank->i_loaded_cache;
  751.     for( i = 0; i < i_cache; i++ )
  752.     {
  753.         if( !strcmp( pp_cache[i]->psz_file, psz_file ) &&
  754.             pp_cache[i]->i_time == i_time &&
  755.             pp_cache[i]->i_size == i_size ) return pp_cache[i];
  756.     }
  758.     return NULL;
  759. }
  761. #endif /* HAVE_DYNAMIC_PLUGINS */