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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
ftrfork.c
资源名称：wow-313-source.rar　[点击查看]
上传用户：yisoukefu
上传日期：2020-08-09
资源大小：39506k
文件大小：23k
源码类别：

其他游戏

开发平台：

Visual C++

ftrfork.c：源码内容
  2. /***************************************************************************/
  3. /*                                                                         */
  4. /*  ftrfork.c                                                              */
  5. /*                                                                         */
  6. /*    Embedded resource forks accessor (body).                             */
  7. /*                                                                         */
  8. /*  Copyright 2004, 2005, 2006 by                                          */
  9. /*  Masatake YAMATO and Redhat K.K.                                        */
  10. /*                                                                         */
  11. /*  FT_Raccess_Get_HeaderInfo() and raccess_guess_darwin_hfsplus() are     */
  12. /*  derived from ftobjs.c.                                                 */
  13. /*                                                                         */
  14. /*  This file is part of the FreeType project, and may only be used,       */
  15. /*  modified, and distributed under the terms of the FreeType project      */
  16. /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  17. /*  this file you indicate that you have read the license and              */
  18. /*  understand and accept it fully.                                        */
  19. /*                                                                         */
  20. /***************************************************************************/
  22. /***************************************************************************/
  23. /* Development of the code in this file is support of                      */
  24. /* Information-technology Promotion Agency, Japan.                         */
  25. /***************************************************************************/
  28. #include <ft2build.h>
  29. #include FT_INTERNAL_DEBUG_H
  30. #include FT_INTERNAL_STREAM_H
  31. #include FT_INTERNAL_RFORK_H
  34. #undef  FT_COMPONENT
  35. #define FT_COMPONENT  trace_raccess
  38.   /*************************************************************************/
  39.   /*************************************************************************/
  40.   /*************************************************************************/
  41.   /****                                                                 ****/
  42.   /****                                                                 ****/
  43.   /****               Resource fork directory access                    ****/
  44.   /****                                                                 ****/
  45.   /****                                                                 ****/
  46.   /*************************************************************************/
  47.   /*************************************************************************/
  48.   /*************************************************************************/
  50.   FT_BASE_DEF( FT_Error )
  51.   FT_Raccess_Get_HeaderInfo( FT_Library  library,
  52.                              FT_Stream   stream,
  53.                              FT_Long     rfork_offset,
  54.                              FT_Long    *map_offset,
  55.                              FT_Long    *rdata_pos )
  56.   {
  57.     FT_Error       error;
  58.     unsigned char  head[16], head2[16];
  59.     FT_Long        map_pos, rdata_len;
  60.     int            allzeros, allmatch, i;
  61.     FT_Long        type_list;
  63.     FT_UNUSED( library );
  66.     error = FT_Stream_Seek( stream, rfork_offset );
  67.     if ( error )
  68.       return error;
  70.     error = FT_Stream_Read( stream, (FT_Byte *)head, 16 );
  71.     if ( error )
  72.       return error;
  74.     *rdata_pos = rfork_offset + ( ( head[0] << 24 ) |
  75.                                   ( head[1] << 16 ) |
  76.                                   ( head[2] <<  8 ) |
  77.                                     head[3]         );
  78.     map_pos    = rfork_offset + ( ( head[4] << 24 ) |
  79.                                   ( head[5] << 16 ) |
  80.                                   ( head[6] <<  8 ) |
  81.                                     head[7]         );
  82.     rdata_len = ( head[ 8] << 24 ) |
  83.                 ( head[ 9] << 16 ) |
  84.                 ( head[10] <<  8 ) |
  85.                   head[11];
  87.     /* map_len = head[12] .. head[15] */
  89.     if ( *rdata_pos + rdata_len != map_pos || map_pos == rfork_offset )
  90.       return FT_Err_Unknown_File_Format;
  92.     error = FT_Stream_Seek( stream, map_pos );
  93.     if ( error )
  94.       return error;
  96.     head2[15] = (FT_Byte)( head[15] + 1 );       /* make it be different */
  98.     error = FT_Stream_Read( stream, (FT_Byte*)head2, 16 );
  99.     if ( error )
  100.       return error;
  102.     allzeros = 1;
  103.     allmatch = 1;
  104.     for ( i = 0; i < 16; ++i )
  105.     {
  106.       if ( head2[i] != 0 )
  107.         allzeros = 0;
  108.       if ( head2[i] != head[i] )
  109.         allmatch = 0;
  110.     }
  111.     if ( !allzeros && !allmatch )
  112.       return FT_Err_Unknown_File_Format;
  114.     /* If we have reached this point then it is probably a mac resource */
  115.     /* file.  Now, does it contain any interesting resources?           */
  116.     /* Skip handle to next resource map, the file resource number, and  */
  117.     /* attributes.                                                      */
  118.     (void)FT_STREAM_SKIP( 4        /* skip handle to next resource map */
  119.                           + 2      /* skip file resource number */
  120.                           + 2 );   /* skip attributes */
  122.     if ( FT_READ_USHORT( type_list ) )
  123.       return error;
  124.     if ( type_list == -1 )
  125.       return FT_Err_Unknown_File_Format;
  127.     error = FT_Stream_Seek( stream, map_pos + type_list );
  128.     if ( error )
  129.       return error;
  131.     *map_offset = map_pos + type_list;
  132.     return FT_Err_Ok;
  133.   }
  136.   FT_BASE_DEF( FT_Error )
  137.   FT_Raccess_Get_DataOffsets( FT_Library  library,
  138.                               FT_Stream   stream,
  139.                               FT_Long     map_offset,
  140.                               FT_Long     rdata_pos,
  141.                               FT_Long     tag,
  142.                               FT_Long   **offsets,
  143.                               FT_Long    *count )
  144.   {
  145.     FT_Error   error;
  146.     int        i, j, cnt, subcnt;
  147.     FT_Long    tag_internal, rpos;
  148.     FT_Memory  memory = library->memory;
  149.     FT_Long    temp;
  150.     FT_Long    *offsets_internal;
  153.     error = FT_Stream_Seek( stream, map_offset );
  154.     if ( error )
  155.       return error;
  157.     if ( FT_READ_USHORT( cnt ) )
  158.       return error;
  159.     cnt++;
  161.     for ( i = 0; i < cnt; ++i )
  162.     {
  163.       if ( FT_READ_LONG( tag_internal ) ||
  164.            FT_READ_USHORT( subcnt )     ||
  165.            FT_READ_USHORT( rpos )       )
  166.         return error;
  168.       FT_TRACE2(( "Resource tags: %c%c%c%cn",
  169.                   (char)( 0xff & ( tag_internal >> 24 ) ),
  170.                   (char)( 0xff & ( tag_internal >> 16 ) ),
  171.                   (char)( 0xff & ( tag_internal >>  8 ) ),
  172.                   (char)( 0xff & ( tag_internal >>  0 ) ) ));
  174.       if ( tag_internal == tag )
  175.       {
  176.         *count = subcnt + 1;
  177.         rpos  += map_offset;
  179.         error = FT_Stream_Seek( stream, rpos );
  180.         if ( error )
  181.           return error;
  183.         if ( FT_NEW_ARRAY( offsets_internal, *count ) )
  184.           return error;
  186.         for ( j = 0; j < *count; ++j )
  187.         {
  188.           (void)FT_STREAM_SKIP( 2 ); /* resource id */
  189.           (void)FT_STREAM_SKIP( 2 ); /* rsource name */
  191.           if ( FT_READ_LONG( temp ) )
  192.           {
  193.             FT_FREE( offsets_internal );
  194.             return error;
  195.           }
  197.           offsets_internal[j] = rdata_pos + ( temp & 0xFFFFFFL );
  199.           (void)FT_STREAM_SKIP( 4 ); /* mbz */
  200.         }
  202.         *offsets = offsets_internal;
  204.         return FT_Err_Ok;
  205.       }
  206.     }
  208.     return FT_Err_Cannot_Open_Resource;
  209.   }
  212. #ifdef FT_CONFIG_OPTION_GUESSING_EMBEDDED_RFORK
  214.   /*************************************************************************/
  215.   /*************************************************************************/
  216.   /*************************************************************************/
  217.   /****                                                                 ****/
  218.   /****                                                                 ****/
  219.   /****                     Guessing functions                          ****/
  220.   /****                                                                 ****/
  221.   /****            When you add a new guessing function,                ****/
  222.   /****           update FT_RACCESS_N_RULES in ftrfork.h.               ****/
  223.   /****                                                                 ****/
  224.   /*************************************************************************/
  225.   /*************************************************************************/
  226.   /*************************************************************************/
  228.   typedef FT_Error
  229.   (*raccess_guess_func)( FT_Library  library,
  230.                          FT_Stream   stream,
  231.                          char *      base_file_name,
  232.                          char      **result_file_name,
  233.                          FT_Long    *result_offset );
  236.   static FT_Error
  237.   raccess_guess_apple_double( FT_Library  library,
  238.                               FT_Stream   stream,
  239.                               char *      base_file_name,
  240.                               char      **result_file_name,
  241.                               FT_Long    *result_offset );
  243.   static FT_Error
  244.   raccess_guess_apple_single( FT_Library  library,
  245.                               FT_Stream   stream,
  246.                               char *      base_file_name,
  247.                               char      **result_file_name,
  248.                               FT_Long    *result_offset );
  250.   static FT_Error
  251.   raccess_guess_darwin_ufs_export( FT_Library  library,
  252.                                    FT_Stream   stream,
  253.                                    char *      base_file_name,
  254.                                    char      **result_file_name,
  255.                                    FT_Long    *result_offset );
  257.   static FT_Error
  258.   raccess_guess_darwin_hfsplus( FT_Library  library,
  259.                                 FT_Stream   stream,
  260.                                 char *      base_file_name,
  261.                                 char      **result_file_name,
  262.                                 FT_Long    *result_offset );
  264.   static FT_Error
  265.   raccess_guess_vfat( FT_Library  library,
  266.                       FT_Stream   stream,
  267.                       char *      base_file_name,
  268.                       char      **result_file_name,
  269.                       FT_Long    *result_offset );
  271.   static FT_Error
  272.   raccess_guess_linux_cap( FT_Library  library,
  273.                            FT_Stream   stream,
  274.                            char *      base_file_name,
  275.                            char      **result_file_name,
  276.                            FT_Long    *result_offset );
  278.   static FT_Error
  279.   raccess_guess_linux_double( FT_Library  library,
  280.                               FT_Stream   stream,
  281.                               char *      base_file_name,
  282.                               char      **result_file_name,
  283.                               FT_Long    *result_offset );
  285.   static FT_Error
  286.   raccess_guess_linux_netatalk( FT_Library  library,
  287.                                 FT_Stream   stream,
  288.                                 char *      base_file_name,
  289.                                 char      **result_file_name,
  290.                                 FT_Long    *result_offset );
  293.   /*************************************************************************/
  294.   /****                                                                 ****/
  295.   /****                       Helper functions                          ****/
  296.   /****                                                                 ****/
  297.   /*************************************************************************/
  299.   static FT_Error
  300.   raccess_guess_apple_generic( FT_Library  library,
  301.                                FT_Stream   stream,
  302.                                char *      base_file_name,
  303.                                FT_Int32    magic,
  304.                                FT_Long    *result_offset );
  306.   static FT_Error
  307.   raccess_guess_linux_double_from_file_name( FT_Library  library,
  308.                                              char *      file_name,
  309.                                              FT_Long    *result_offset );
  311.   static char *
  312.   raccess_make_file_name( FT_Memory    memory,
  313.                           const char  *original_name,
  314.                           const char  *insertion );
  317.   FT_BASE_DEF( void )
  318.   FT_Raccess_Guess( FT_Library  library,
  319.                     FT_Stream   stream,
  320.                     char*       base_name,
  321.                     char      **new_names,
  322.                     FT_Long    *offsets,
  323.                     FT_Error   *errors )
  324.   {
  325.     FT_Long  i;
  328.     raccess_guess_func  funcs[FT_RACCESS_N_RULES] =
  329.     {
  330.       raccess_guess_apple_double,
  331.       raccess_guess_apple_single,
  332.       raccess_guess_darwin_ufs_export,
  333.       raccess_guess_darwin_hfsplus,
  334.       raccess_guess_vfat,
  335.       raccess_guess_linux_cap,
  336.       raccess_guess_linux_double,
  337.       raccess_guess_linux_netatalk,
  338.     };
  340.     for ( i = 0; i < FT_RACCESS_N_RULES; i++ )
  341.     {
  342.       new_names[i] = NULL;
  343.       errors[i] = FT_Stream_Seek( stream, 0 );
  344.       if ( errors[i] )
  345.         continue ;
  347.       errors[i] = (funcs[i])( library, stream, base_name,
  348.                               &(new_names[i]), &(offsets[i]) );
  349.     }
  351.     return;
  352.   }
  355.   static FT_Error
  356.   raccess_guess_apple_double( FT_Library  library,
  357.                               FT_Stream   stream,
  358.                               char *      base_file_name,
  359.                               char      **result_file_name,
  360.                               FT_Long    *result_offset )
  361.   {
  362.     FT_Int32  magic = ( 0x00 << 24 | 0x05 << 16 | 0x16 << 8 | 0x07 );
  365.     *result_file_name = NULL;
  366.     return raccess_guess_apple_generic( library, stream, base_file_name,
  367.                                         magic, result_offset );
  368.   }
  371.   static FT_Error
  372.   raccess_guess_apple_single( FT_Library  library,
  373.                               FT_Stream   stream,
  374.                               char *      base_file_name,
  375.                               char      **result_file_name,
  376.                               FT_Long    *result_offset )
  377.   {
  378.     FT_Int32  magic = (0x00 << 24 | 0x05 << 16 | 0x16 << 8 | 0x00);
  381.     *result_file_name = NULL;
  382.     return raccess_guess_apple_generic( library, stream, base_file_name,
  383.                                         magic, result_offset );
  384.   }
  387.   static FT_Error
  388.   raccess_guess_darwin_ufs_export( FT_Library  library,
  389.                                    FT_Stream   stream,
  390.                                    char *      base_file_name,
  391.                                    char      **result_file_name,
  392.                                    FT_Long    *result_offset )
  393.   {
  394.     char*      newpath;
  395.     FT_Error   error;
  396.     FT_Memory  memory;
  398.     FT_UNUSED( stream );
  401.     memory  = library->memory;
  402.     newpath = raccess_make_file_name( memory, base_file_name, "._" );
  403.     if ( !newpath )
  404.       return FT_Err_Out_Of_Memory;
  406.     error = raccess_guess_linux_double_from_file_name( library, newpath,
  407.                                                        result_offset );
  408.     if ( !error )
  409.       *result_file_name = newpath;
  410.     else
  411.       FT_FREE( newpath );
  413.     return error;
  414.   }
  417.   static FT_Error
  418.   raccess_guess_darwin_hfsplus( FT_Library  library,
  419.                                 FT_Stream   stream,
  420.                                 char *      base_file_name,
  421.                                 char      **result_file_name,
  422.                                 FT_Long    *result_offset )
  423.   {
  424.     /*
  425.       Only meaningful on systems with hfs+ drivers (or Macs).
  426.      */
  427.     FT_Error   error;
  428.     char*      newpath;
  429.     FT_Memory  memory;
  430.     FT_Long    base_file_len = ft_strlen( base_file_name );
  432.     FT_UNUSED( stream );
  435.     memory = library->memory;
  437.     if ( base_file_len > FT_INT_MAX )
  438.       return FT_Err_Array_Too_Large;
  440.     if ( FT_ALLOC( newpath, base_file_len + 6 ) )
  441.       return error;
  443.     FT_MEM_COPY( newpath, base_file_name, base_file_len );
  444.     FT_MEM_COPY( newpath + base_file_len, "/rsrc", 6 );
  446.     *result_file_name = newpath;
  447.     *result_offset    = 0;
  449.     return FT_Err_Ok;
  450.   }
  453.   static FT_Error
  454.   raccess_guess_vfat( FT_Library  library,
  455.                       FT_Stream   stream,
  456.                       char *      base_file_name,
  457.                       char      **result_file_name,
  458.                       FT_Long    *result_offset )
  459.   {
  460.     char*      newpath;
  461.     FT_Memory  memory;
  463.     FT_UNUSED( stream );
  466.     memory = library->memory;
  468.     newpath = raccess_make_file_name( memory, base_file_name,
  469.                                       "resource.frk/" );
  470.     if ( !newpath )
  471.       return FT_Err_Out_Of_Memory;
  473.     *result_file_name = newpath;
  474.     *result_offset    = 0;
  476.     return FT_Err_Ok;
  477.   }
  480.   static FT_Error
  481.   raccess_guess_linux_cap( FT_Library  library,
  482.                            FT_Stream   stream,
  483.                            char *      base_file_name,
  484.                            char      **result_file_name,
  485.                            FT_Long    *result_offset )
  486.   {
  487.     char*      newpath;
  488.     FT_Memory  memory;
  490.     FT_UNUSED( stream );
  493.     memory = library->memory;
  495.     newpath = raccess_make_file_name( memory, base_file_name, ".resource/" );
  496.     if ( !newpath )
  497.       return FT_Err_Out_Of_Memory;
  499.     *result_file_name = newpath;
  500.     *result_offset    = 0;
  502.     return FT_Err_Ok;
  503.   }
  506.   static FT_Error
  507.   raccess_guess_linux_double( FT_Library  library,
  508.                               FT_Stream   stream,
  509.                               char *      base_file_name,
  510.                               char      **result_file_name,
  511.                               FT_Long    *result_offset )
  512.   {
  513.     char*      newpath;
  514.     FT_Error   error;
  515.     FT_Memory  memory;
  517.     FT_UNUSED( stream );
  520.     memory = library->memory;
  522.     newpath = raccess_make_file_name( memory, base_file_name, "%" );
  523.     if ( !newpath )
  524.       return FT_Err_Out_Of_Memory;
  526.     error = raccess_guess_linux_double_from_file_name( library, newpath,
  527.                                                        result_offset );
  528.     if ( !error )
  529.       *result_file_name = newpath;
  530.     else
  531.       FT_FREE( newpath );
  533.     return error;
  534.   }
  537.   static FT_Error
  538.   raccess_guess_linux_netatalk( FT_Library  library,
  539.                                 FT_Stream   stream,
  540.                                 char *      base_file_name,
  541.                                 char      **result_file_name,
  542.                                 FT_Long    *result_offset )
  543.   {
  544.     char*      newpath;
  545.     FT_Error   error;
  546.     FT_Memory  memory;
  548.     FT_UNUSED( stream );
  551.     memory = library->memory;
  553.     newpath = raccess_make_file_name( memory, base_file_name,
  554.                                       ".AppleDouble/" );
  555.     if ( !newpath )
  556.       return FT_Err_Out_Of_Memory;
  558.     error = raccess_guess_linux_double_from_file_name( library, newpath,
  559.                                                        result_offset );
  560.     if ( !error )
  561.       *result_file_name = newpath;
  562.     else
  563.       FT_FREE( newpath );
  565.     return error;
  566.   }
  569.   static FT_Error
  570.   raccess_guess_apple_generic( FT_Library  library,
  571.                                FT_Stream   stream,
  572.                                char *      base_file_name,
  573.                                FT_Int32    magic,
  574.                                FT_Long    *result_offset )
  575.   {
  576.     FT_Int32   magic_from_stream;
  577.     FT_Error   error;
  578.     FT_Int32   version_number = 0;
  579.     FT_UShort  n_of_entries;
  581.     int        i;
  582.     FT_UInt32  entry_id, entry_offset, entry_length = 0;
  584.     const FT_UInt32  resource_fork_entry_id = 0x2;
  586.     FT_UNUSED( library );
  587.     FT_UNUSED( base_file_name );
  588.     FT_UNUSED( version_number );
  589.     FT_UNUSED( entry_length   );
  592.     if ( FT_READ_LONG( magic_from_stream ) )
  593.       return error;
  594.     if ( magic_from_stream != magic )
  595.       return FT_Err_Unknown_File_Format;
  597.     if ( FT_READ_LONG( version_number ) )
  598.       return error;
  600.     /* filler */
  601.     error = FT_Stream_Skip( stream, 16 );
  602.     if ( error )
  603.       return error;
  605.     if ( FT_READ_USHORT( n_of_entries ) )
  606.       return error;
  607.     if ( n_of_entries == 0 )
  608.       return FT_Err_Unknown_File_Format;
  610.     for ( i = 0; i < n_of_entries; i++ )
  611.     {
  612.       if ( FT_READ_LONG( entry_id ) )
  613.         return error;
  614.       if ( entry_id == resource_fork_entry_id )
  615.       {
  616.         if ( FT_READ_LONG( entry_offset ) ||
  617.              FT_READ_LONG( entry_length ) )
  618.           continue;
  619.         *result_offset = entry_offset;
  621.         return FT_Err_Ok;
  622.       }
  623.       else
  624.         FT_Stream_Skip( stream, 4 + 4 );    /* offset + length */
  625.       }
  627.     return FT_Err_Unknown_File_Format;
  628.   }
  631.   static FT_Error
  632.   raccess_guess_linux_double_from_file_name( FT_Library  library,
  633.                                              char *      file_name,
  634.                                              FT_Long    *result_offset )
  635.   {
  636.     FT_Open_Args  args2;
  637.     FT_Stream     stream2;
  638.     char *        nouse = NULL;
  639.     FT_Error      error;
  642.     args2.flags    = FT_OPEN_PATHNAME;
  643.     args2.pathname = file_name;
  644.     error = FT_Stream_New( library, &args2, &stream2 );
  645.     if ( error )
  646.       return error;
  648.     error = raccess_guess_apple_double( library, stream2, file_name,
  649.                                         &nouse, result_offset );
  651.     FT_Stream_Free( stream2, 0 );
  653.     return error;
  654.   }
  657.   static char*
  658.   raccess_make_file_name( FT_Memory    memory,
  659.                           const char  *original_name,
  660.                           const char  *insertion )
  661.   {
  662.     char*        new_name;
  663.     char*        tmp;
  664.     const char*  slash;
  665.     unsigned     new_length;
  666.     FT_Error     error = FT_Err_Ok;
  668.     FT_UNUSED( error );
  671.     new_length = ft_strlen( original_name ) + ft_strlen( insertion );
  672.     if ( FT_ALLOC( new_name, new_length + 1 ) )
  673.       return NULL;
  675.     tmp = ft_strrchr( original_name, '/' );
  676.     if ( tmp )
  677.     {
  678.       ft_strncpy( new_name, original_name, tmp - original_name + 1 );
  679.       new_name[tmp - original_name + 1] = '';
  680.       slash = tmp + 1;
  681.     }
  682.     else
  683.     {
  684.       slash       = original_name;
  685.       new_name[0] = '';
  686.     }
  688.     ft_strcat( new_name, insertion );
  689.     ft_strcat( new_name, slash );
  691.     return new_name;
  692.   }
  695. #else   /* !FT_CONFIG_OPTION_GUESSING_EMBEDDED_RFORK */
  698.   /*************************************************************************/
  699.   /*                  Dummy function; just sets errors                     */
  700.   /*************************************************************************/
  702.   FT_BASE_DEF( void )
  703.   FT_Raccess_Guess( FT_Library  library,
  704.                     FT_Stream   stream,
  705.                     char*       base_name,
  706.                     char      **new_names,
  707.                     FT_Long    *offsets,
  708.                     FT_Error   *errors )
  709.   {
  710.     int  i;
  712.     FT_UNUSED( library );
  713.     FT_UNUSED( stream );
  714.     FT_UNUSED( base_name );
  717.     for ( i = 0; i < FT_RACCESS_N_RULES; i++ )
  718.     {
  719.       new_names[i] = NULL;
  720.       offsets[i]   = 0;
  721.       errors[i]    = FT_Err_Unimplemented_Feature;
  722.     }
  723.   }
  726. #endif  /* !FT_CONFIG_OPTION_GUESSING_EMBEDDED_RFORK */
  729. /* END */