XFA: merge patch from CL 815103002
[pdfium.git] / third_party / freetype / src / base / ftrfork.c
1 /***************************************************************************/
2 /*                                                                         */
3 /*  ftrfork.c                                                              */
4 /*                                                                         */
5 /*    Embedded resource forks accessor (body).                             */
6 /*                                                                         */
7 /*  Copyright 2004-2010, 2013, 2014 by                                     */
8 /*  Masatake YAMATO and Redhat K.K.                                        */
9 /*                                                                         */
10 /*  FT_Raccess_Get_HeaderInfo() and raccess_guess_darwin_hfsplus() are     */
11 /*  derived from ftobjs.c.                                                 */
12 /*                                                                         */
13 /*  This file is part of the FreeType project, and may only be used,       */
14 /*  modified, and distributed under the terms of the FreeType project      */
15 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
16 /*  this file you indicate that you have read the license and              */
17 /*  understand and accept it fully.                                        */
18 /*                                                                         */
19 /***************************************************************************/
20
21 /***************************************************************************/
22 /* Development of the code in this file is support of                      */
23 /* Information-technology Promotion Agency, Japan.                         */
24 /***************************************************************************/
25
26
27 #include <ft2build.h>
28 #include FT_INTERNAL_DEBUG_H
29 #include FT_INTERNAL_STREAM_H
30 #include FT_INTERNAL_RFORK_H
31 #include "basepic.h"
32 #include "ftbase.h"
33
34 #undef  FT_COMPONENT
35 #define FT_COMPONENT  trace_raccess
36
37
38   /*************************************************************************/
39   /*************************************************************************/
40   /*************************************************************************/
41   /****                                                                 ****/
42   /****                                                                 ****/
43   /****               Resource fork directory access                    ****/
44   /****                                                                 ****/
45   /****                                                                 ****/
46   /*************************************************************************/
47   /*************************************************************************/
48   /*************************************************************************/
49
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;
62
63     FT_UNUSED( library );
64
65
66     error = FT_Stream_Seek( stream, rfork_offset );
67     if ( error )
68       return error;
69
70     error = FT_Stream_Read( stream, (FT_Byte *)head, 16 );
71     if ( error )
72       return error;
73
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];
86
87     /* map_len = head[12] .. head[15] */
88
89     if ( *rdata_pos + rdata_len != map_pos || map_pos == rfork_offset )
90       return FT_THROW( Unknown_File_Format );
91
92     error = FT_Stream_Seek( stream, map_pos );
93     if ( error )
94       return error;
95
96     head2[15] = (FT_Byte)( head[15] + 1 );       /* make it be different */
97
98     error = FT_Stream_Read( stream, (FT_Byte*)head2, 16 );
99     if ( error )
100       return error;
101
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_THROW( Unknown_File_Format );
113
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 */
121
122     if ( FT_READ_USHORT( type_list ) )
123       return error;
124     if ( type_list == -1 )
125       return FT_THROW( Unknown_File_Format );
126
127     error = FT_Stream_Seek( stream, map_pos + type_list );
128     if ( error )
129       return error;
130
131     *map_offset = map_pos + type_list;
132     return FT_Err_Ok;
133   }
134
135
136   static int
137   ft_raccess_sort_ref_by_id( FT_RFork_Ref*  a,
138                              FT_RFork_Ref*  b )
139   {
140     if ( a->res_id < b->res_id )
141       return -1;
142     else if ( a->res_id > b->res_id )
143       return 1;
144     else
145       return 0;
146   }
147
148
149   FT_BASE_DEF( FT_Error )
150   FT_Raccess_Get_DataOffsets( FT_Library  library,
151                               FT_Stream   stream,
152                               FT_Long     map_offset,
153                               FT_Long     rdata_pos,
154                               FT_Long     tag,
155                               FT_Bool     sort_by_res_id,
156                               FT_Long   **offsets,
157                               FT_Long    *count )
158   {
159     FT_Error      error;
160     int           i, j, cnt, subcnt;
161     FT_Long       tag_internal, rpos;
162     FT_Memory     memory = library->memory;
163     FT_Long       temp;
164     FT_Long       *offsets_internal = NULL;
165     FT_RFork_Ref  *ref = NULL;
166
167
168     FT_TRACE3(( "\n" ));
169     error = FT_Stream_Seek( stream, map_offset );
170     if ( error )
171       return error;
172
173     if ( FT_READ_USHORT( cnt ) )
174       return error;
175     cnt++;
176
177     for ( i = 0; i < cnt; ++i )
178     {
179       if ( FT_READ_LONG( tag_internal ) ||
180            FT_READ_USHORT( subcnt )     ||
181            FT_READ_USHORT( rpos )       )
182         return error;
183
184       FT_TRACE2(( "Resource tags: %c%c%c%c\n",
185                   (char)( 0xff & ( tag_internal >> 24 ) ),
186                   (char)( 0xff & ( tag_internal >> 16 ) ),
187                   (char)( 0xff & ( tag_internal >>  8 ) ),
188                   (char)( 0xff & ( tag_internal >>  0 ) ) ));
189       FT_TRACE3(( "             : subcount=%d, suboffset=0x%04x\n",
190                   subcnt, rpos ));
191
192       if ( tag_internal == tag )
193       {
194         *count = subcnt + 1;
195         rpos  += map_offset;
196
197         error = FT_Stream_Seek( stream, rpos );
198         if ( error )
199           return error;
200
201         if ( FT_NEW_ARRAY( ref, *count ) )
202           return error;
203
204         for ( j = 0; j < *count; ++j )
205         {
206           if ( FT_READ_USHORT( ref[j].res_id ) )
207             goto Exit;
208           if ( FT_STREAM_SKIP( 2 ) ) /* resource name */
209             goto Exit;
210           if ( FT_READ_LONG( temp ) )
211             goto Exit;
212           if ( FT_STREAM_SKIP( 4 ) ) /* mbz */
213             goto Exit;
214
215           ref[j].offset = temp & 0xFFFFFFL;
216           FT_TRACE3(( "             [%d]:"
217                       " resource_id=0x%04x, offset=0x%08x\n",
218                       j, ref[j].res_id, ref[j].offset ));
219         }
220
221         if (sort_by_res_id)
222         {
223           ft_qsort( ref, *count, sizeof ( FT_RFork_Ref ),
224                     ( int(*)(const void*, const void*) )
225                     ft_raccess_sort_ref_by_id );
226
227           FT_TRACE3(( "             -- sort resources by their ids --\n" ));
228           for ( j = 0; j < *count; ++ j ) {
229             FT_TRACE3(( "             [%d]:"
230                         " resource_id=0x%04x, offset=0x%08x\n",
231                         j, ref[j].res_id, ref[j].offset ));
232           }
233         }
234
235         if ( FT_NEW_ARRAY( offsets_internal, *count ) )
236           goto Exit;
237
238         /* XXX: duplicated reference ID,
239          *      gap between reference IDs are acceptable?
240          *      further investigation on Apple implementation is needed.
241          */
242         for ( j = 0; j < *count; ++j )
243           offsets_internal[j] = rdata_pos + ref[j].offset;
244
245         *offsets = offsets_internal;
246         error    = FT_Err_Ok;
247
248       Exit:
249         FT_FREE( ref );
250         return error;
251       }
252     }
253
254     return FT_THROW( Cannot_Open_Resource );
255   }
256
257
258 #ifdef FT_CONFIG_OPTION_GUESSING_EMBEDDED_RFORK
259
260   /*************************************************************************/
261   /*************************************************************************/
262   /*************************************************************************/
263   /****                                                                 ****/
264   /****                                                                 ****/
265   /****                     Guessing functions                          ****/
266   /****                                                                 ****/
267   /****            When you add a new guessing function,                ****/
268   /****           update FT_RACCESS_N_RULES in ftrfork.h.               ****/
269   /****                                                                 ****/
270   /*************************************************************************/
271   /*************************************************************************/
272   /*************************************************************************/
273
274   static FT_Error
275   raccess_guess_apple_double( FT_Library  library,
276                               FT_Stream   stream,
277                               char       *base_file_name,
278                               char      **result_file_name,
279                               FT_Long    *result_offset );
280
281   static FT_Error
282   raccess_guess_apple_single( FT_Library  library,
283                               FT_Stream   stream,
284                               char       *base_file_name,
285                               char      **result_file_name,
286                               FT_Long    *result_offset );
287
288   static FT_Error
289   raccess_guess_darwin_ufs_export( FT_Library  library,
290                                    FT_Stream   stream,
291                                    char       *base_file_name,
292                                    char      **result_file_name,
293                                    FT_Long    *result_offset );
294
295   static FT_Error
296   raccess_guess_darwin_newvfs( FT_Library  library,
297                                FT_Stream   stream,
298                                char       *base_file_name,
299                                char      **result_file_name,
300                                FT_Long    *result_offset );
301
302   static FT_Error
303   raccess_guess_darwin_hfsplus( FT_Library  library,
304                                 FT_Stream   stream,
305                                 char       *base_file_name,
306                                 char      **result_file_name,
307                                 FT_Long    *result_offset );
308
309   static FT_Error
310   raccess_guess_vfat( FT_Library  library,
311                       FT_Stream   stream,
312                       char       *base_file_name,
313                       char      **result_file_name,
314                       FT_Long    *result_offset );
315
316   static FT_Error
317   raccess_guess_linux_cap( FT_Library  library,
318                            FT_Stream   stream,
319                            char       *base_file_name,
320                            char      **result_file_name,
321                            FT_Long    *result_offset );
322
323   static FT_Error
324   raccess_guess_linux_double( FT_Library  library,
325                               FT_Stream   stream,
326                               char       *base_file_name,
327                               char      **result_file_name,
328                               FT_Long    *result_offset );
329
330   static FT_Error
331   raccess_guess_linux_netatalk( FT_Library  library,
332                                 FT_Stream   stream,
333                                 char       *base_file_name,
334                                 char      **result_file_name,
335                                 FT_Long    *result_offset );
336
337
338   CONST_FT_RFORK_RULE_ARRAY_BEGIN(ft_raccess_guess_table,
339                                   ft_raccess_guess_rec)
340   CONST_FT_RFORK_RULE_ARRAY_ENTRY(apple_double,      apple_double)
341   CONST_FT_RFORK_RULE_ARRAY_ENTRY(apple_single,      apple_single)
342   CONST_FT_RFORK_RULE_ARRAY_ENTRY(darwin_ufs_export, darwin_ufs_export)
343   CONST_FT_RFORK_RULE_ARRAY_ENTRY(darwin_newvfs,     darwin_newvfs)
344   CONST_FT_RFORK_RULE_ARRAY_ENTRY(darwin_hfsplus,    darwin_hfsplus)
345   CONST_FT_RFORK_RULE_ARRAY_ENTRY(vfat,              vfat)
346   CONST_FT_RFORK_RULE_ARRAY_ENTRY(linux_cap,         linux_cap)
347   CONST_FT_RFORK_RULE_ARRAY_ENTRY(linux_double,      linux_double)
348   CONST_FT_RFORK_RULE_ARRAY_ENTRY(linux_netatalk,    linux_netatalk)
349   CONST_FT_RFORK_RULE_ARRAY_END
350
351
352   /*************************************************************************/
353   /****                                                                 ****/
354   /****                       Helper functions                          ****/
355   /****                                                                 ****/
356   /*************************************************************************/
357
358   static FT_Error
359   raccess_guess_apple_generic( FT_Library  library,
360                                FT_Stream   stream,
361                                char       *base_file_name,
362                                FT_Int32    magic,
363                                FT_Long    *result_offset );
364
365   static FT_Error
366   raccess_guess_linux_double_from_file_name( FT_Library  library,
367                                              char *      file_name,
368                                              FT_Long    *result_offset );
369
370   static char *
371   raccess_make_file_name( FT_Memory    memory,
372                           const char  *original_name,
373                           const char  *insertion );
374
375   FT_BASE_DEF( void )
376   FT_Raccess_Guess( FT_Library  library,
377                     FT_Stream   stream,
378                     char*       base_name,
379                     char      **new_names,
380                     FT_Long    *offsets,
381                     FT_Error   *errors )
382   {
383     FT_Int  i;
384
385
386     for ( i = 0; i < FT_RACCESS_N_RULES; i++ )
387     {
388       new_names[i] = NULL;
389       if ( NULL != stream )
390         errors[i] = FT_Stream_Seek( stream, 0 );
391       else
392         errors[i] = FT_Err_Ok;
393
394       if ( errors[i] )
395         continue ;
396
397       errors[i] = (FT_RACCESS_GUESS_TABLE_GET[i].func)( library,
398                                                  stream, base_name,
399                                                  &(new_names[i]),
400                                                  &(offsets[i]) );
401     }
402
403     return;
404   }
405
406
407 #ifndef FT_MACINTOSH
408   static FT_RFork_Rule
409   raccess_get_rule_type_from_rule_index( FT_Library  library,
410                                          FT_UInt     rule_index )
411   {
412     FT_UNUSED( library );
413
414     if ( rule_index >= FT_RACCESS_N_RULES )
415       return FT_RFork_Rule_invalid;
416
417     return FT_RACCESS_GUESS_TABLE_GET[rule_index].type;
418   }
419
420
421   /*
422    * For this function, refer ftbase.h.
423    */
424   FT_LOCAL_DEF( FT_Bool )
425   ft_raccess_rule_by_darwin_vfs( FT_Library  library,
426                                  FT_UInt     rule_index )
427   {
428     switch( raccess_get_rule_type_from_rule_index( library, rule_index ) )
429     {
430       case FT_RFork_Rule_darwin_newvfs:
431       case FT_RFork_Rule_darwin_hfsplus:
432         return TRUE;
433
434       default:
435         return FALSE;
436     }
437   }
438 #endif
439
440
441   static FT_Error
442   raccess_guess_apple_double( FT_Library  library,
443                               FT_Stream   stream,
444                               char       *base_file_name,
445                               char      **result_file_name,
446                               FT_Long    *result_offset )
447   {
448     FT_Int32  magic = ( 0x00 << 24 ) |
449                       ( 0x05 << 16 ) |
450                       ( 0x16 <<  8 ) |
451                         0x07;
452
453
454     *result_file_name = NULL;
455     if ( NULL == stream )
456       return FT_THROW( Cannot_Open_Stream );
457
458     return raccess_guess_apple_generic( library, stream, base_file_name,
459                                         magic, result_offset );
460   }
461
462
463   static FT_Error
464   raccess_guess_apple_single( FT_Library  library,
465                               FT_Stream   stream,
466                               char       *base_file_name,
467                               char      **result_file_name,
468                               FT_Long    *result_offset )
469   {
470     FT_Int32  magic = ( 0x00 << 24 ) |
471                       ( 0x05 << 16 ) |
472                       ( 0x16 <<  8 ) |
473                         0x00;
474
475
476     *result_file_name = NULL;
477     if ( NULL == stream )
478       return FT_THROW( Cannot_Open_Stream );
479
480     return raccess_guess_apple_generic( library, stream, base_file_name,
481                                         magic, result_offset );
482   }
483
484
485   static FT_Error
486   raccess_guess_darwin_ufs_export( FT_Library  library,
487                                    FT_Stream   stream,
488                                    char       *base_file_name,
489                                    char      **result_file_name,
490                                    FT_Long    *result_offset )
491   {
492     char*      newpath;
493     FT_Error   error;
494     FT_Memory  memory;
495
496     FT_UNUSED( stream );
497
498
499     memory  = library->memory;
500     newpath = raccess_make_file_name( memory, base_file_name, "._" );
501     if ( !newpath )
502       return FT_THROW( Out_Of_Memory );
503
504     error = raccess_guess_linux_double_from_file_name( library, newpath,
505                                                        result_offset );
506     if ( !error )
507       *result_file_name = newpath;
508     else
509       FT_FREE( newpath );
510
511     return error;
512   }
513
514
515   static FT_Error
516   raccess_guess_darwin_hfsplus( FT_Library  library,
517                                 FT_Stream   stream,
518                                 char       *base_file_name,
519                                 char      **result_file_name,
520                                 FT_Long    *result_offset )
521   {
522     /*
523       Only meaningful on systems with hfs+ drivers (or Macs).
524      */
525     FT_Error   error;
526     char*      newpath = NULL;
527     FT_Memory  memory;
528     FT_Long    base_file_len = (FT_Long)ft_strlen( base_file_name );
529
530     FT_UNUSED( stream );
531
532
533     memory = library->memory;
534
535     if ( base_file_len + 6 > FT_INT_MAX )
536       return FT_THROW( Array_Too_Large );
537
538     if ( FT_ALLOC( newpath, base_file_len + 6 ) )
539       return error;
540
541     FT_MEM_COPY( newpath, base_file_name, base_file_len );
542     FT_MEM_COPY( newpath + base_file_len, "/rsrc", 6 );
543
544     *result_file_name = newpath;
545     *result_offset    = 0;
546
547     return FT_Err_Ok;
548   }
549
550
551   static FT_Error
552   raccess_guess_darwin_newvfs( FT_Library  library,
553                                FT_Stream   stream,
554                                char       *base_file_name,
555                                char      **result_file_name,
556                                FT_Long    *result_offset )
557   {
558     /*
559       Only meaningful on systems with Mac OS X (> 10.1).
560      */
561     FT_Error   error;
562     char*      newpath = NULL;
563     FT_Memory  memory;
564     FT_Long    base_file_len = (FT_Long)ft_strlen( base_file_name );
565
566     FT_UNUSED( stream );
567
568
569     memory = library->memory;
570
571     if ( base_file_len + 18 > FT_INT_MAX )
572       return FT_THROW( Array_Too_Large );
573
574     if ( FT_ALLOC( newpath, base_file_len + 18 ) )
575       return error;
576
577     FT_MEM_COPY( newpath, base_file_name, base_file_len );
578     FT_MEM_COPY( newpath + base_file_len, "/..namedfork/rsrc", 18 );
579
580     *result_file_name = newpath;
581     *result_offset    = 0;
582
583     return FT_Err_Ok;
584   }
585
586
587   static FT_Error
588   raccess_guess_vfat( FT_Library  library,
589                       FT_Stream   stream,
590                       char       *base_file_name,
591                       char      **result_file_name,
592                       FT_Long    *result_offset )
593   {
594     char*      newpath;
595     FT_Memory  memory;
596
597     FT_UNUSED( stream );
598
599
600     memory = library->memory;
601
602     newpath = raccess_make_file_name( memory, base_file_name,
603                                       "resource.frk/" );
604     if ( !newpath )
605       return FT_THROW( Out_Of_Memory );
606
607     *result_file_name = newpath;
608     *result_offset    = 0;
609
610     return FT_Err_Ok;
611   }
612
613
614   static FT_Error
615   raccess_guess_linux_cap( FT_Library  library,
616                            FT_Stream   stream,
617                            char       *base_file_name,
618                            char      **result_file_name,
619                            FT_Long    *result_offset )
620   {
621     char*      newpath;
622     FT_Memory  memory;
623
624     FT_UNUSED( stream );
625
626
627     memory = library->memory;
628
629     newpath = raccess_make_file_name( memory, base_file_name, ".resource/" );
630     if ( !newpath )
631       return FT_THROW( Out_Of_Memory );
632
633     *result_file_name = newpath;
634     *result_offset    = 0;
635
636     return FT_Err_Ok;
637   }
638
639
640   static FT_Error
641   raccess_guess_linux_double( FT_Library  library,
642                               FT_Stream   stream,
643                               char       *base_file_name,
644                               char      **result_file_name,
645                               FT_Long    *result_offset )
646   {
647     char*      newpath;
648     FT_Error   error;
649     FT_Memory  memory;
650
651     FT_UNUSED( stream );
652
653
654     memory = library->memory;
655
656     newpath = raccess_make_file_name( memory, base_file_name, "%" );
657     if ( !newpath )
658       return FT_THROW( Out_Of_Memory );
659
660     error = raccess_guess_linux_double_from_file_name( library, newpath,
661                                                        result_offset );
662     if ( !error )
663       *result_file_name = newpath;
664     else
665       FT_FREE( newpath );
666
667     return error;
668   }
669
670
671   static FT_Error
672   raccess_guess_linux_netatalk( FT_Library  library,
673                                 FT_Stream   stream,
674                                 char       *base_file_name,
675                                 char      **result_file_name,
676                                 FT_Long    *result_offset )
677   {
678     char*      newpath;
679     FT_Error   error;
680     FT_Memory  memory;
681
682     FT_UNUSED( stream );
683
684
685     memory = library->memory;
686
687     newpath = raccess_make_file_name( memory, base_file_name,
688                                       ".AppleDouble/" );
689     if ( !newpath )
690       return FT_THROW( Out_Of_Memory );
691
692     error = raccess_guess_linux_double_from_file_name( library, newpath,
693                                                        result_offset );
694     if ( !error )
695       *result_file_name = newpath;
696     else
697       FT_FREE( newpath );
698
699     return error;
700   }
701
702
703   static FT_Error
704   raccess_guess_apple_generic( FT_Library  library,
705                                FT_Stream   stream,
706                                char       *base_file_name,
707                                FT_Int32    magic,
708                                FT_Long    *result_offset )
709   {
710     FT_Int32   magic_from_stream;
711     FT_Error   error;
712     FT_Int32   version_number = 0;
713     FT_UShort  n_of_entries;
714
715     int        i;
716     FT_UInt32  entry_id, entry_offset, entry_length = 0;
717
718     const FT_UInt32  resource_fork_entry_id = 0x2;
719
720     FT_UNUSED( library );
721     FT_UNUSED( base_file_name );
722     FT_UNUSED( version_number );
723     FT_UNUSED( entry_length   );
724
725
726     if ( FT_READ_LONG( magic_from_stream ) )
727       return error;
728     if ( magic_from_stream != magic )
729       return FT_THROW( Unknown_File_Format );
730
731     if ( FT_READ_LONG( version_number ) )
732       return error;
733
734     /* filler */
735     error = FT_Stream_Skip( stream, 16 );
736     if ( error )
737       return error;
738
739     if ( FT_READ_USHORT( n_of_entries ) )
740       return error;
741     if ( n_of_entries == 0 )
742       return FT_THROW( Unknown_File_Format );
743
744     for ( i = 0; i < n_of_entries; i++ )
745     {
746       if ( FT_READ_LONG( entry_id ) )
747         return error;
748       if ( entry_id == resource_fork_entry_id )
749       {
750         if ( FT_READ_LONG( entry_offset ) ||
751              FT_READ_LONG( entry_length ) )
752           continue;
753         *result_offset = entry_offset;
754
755         return FT_Err_Ok;
756       }
757       else
758       {
759         error = FT_Stream_Skip( stream, 4 + 4 );    /* offset + length */
760         if ( error )
761           return error;
762       }
763     }
764
765     return FT_THROW( Unknown_File_Format );
766   }
767
768
769   static FT_Error
770   raccess_guess_linux_double_from_file_name( FT_Library  library,
771                                              char       *file_name,
772                                              FT_Long    *result_offset )
773   {
774     FT_Open_Args  args2;
775     FT_Stream     stream2;
776     char *        nouse = NULL;
777     FT_Error      error;
778
779
780     args2.flags    = FT_OPEN_PATHNAME;
781     args2.pathname = file_name;
782     error = FT_Stream_New( library, &args2, &stream2 );
783     if ( error )
784       return error;
785
786     error = raccess_guess_apple_double( library, stream2, file_name,
787                                         &nouse, result_offset );
788
789     FT_Stream_Free( stream2, 0 );
790
791     return error;
792   }
793
794
795   static char*
796   raccess_make_file_name( FT_Memory    memory,
797                           const char  *original_name,
798                           const char  *insertion )
799   {
800     char*        new_name = NULL;
801     const char*  tmp;
802     const char*  slash;
803     size_t       new_length;
804     FT_Error     error = FT_Err_Ok;
805
806     FT_UNUSED( error );
807
808
809     new_length = ft_strlen( original_name ) + ft_strlen( insertion );
810     if ( FT_ALLOC( new_name, new_length + 1 ) )
811       return NULL;
812
813     tmp = ft_strrchr( original_name, '/' );
814     if ( tmp )
815     {
816       ft_strncpy( new_name, original_name, tmp - original_name + 1 );
817       new_name[tmp - original_name + 1] = '\0';
818       slash = tmp + 1;
819     }
820     else
821     {
822       slash       = original_name;
823       new_name[0] = '\0';
824     }
825
826     ft_strcat( new_name, insertion );
827     ft_strcat( new_name, slash );
828
829     return new_name;
830   }
831
832
833 #else   /* !FT_CONFIG_OPTION_GUESSING_EMBEDDED_RFORK */
834
835
836   /*************************************************************************/
837   /*                  Dummy function; just sets errors                     */
838   /*************************************************************************/
839
840   FT_BASE_DEF( void )
841   FT_Raccess_Guess( FT_Library  library,
842                     FT_Stream   stream,
843                     char       *base_name,
844                     char      **new_names,
845                     FT_Long    *offsets,
846                     FT_Error   *errors )
847   {
848     FT_Int  i;
849
850     FT_UNUSED( library );
851     FT_UNUSED( stream );
852     FT_UNUSED( base_name );
853
854
855     for ( i = 0; i < FT_RACCESS_N_RULES; i++ )
856     {
857       new_names[i] = NULL;
858       offsets[i]   = 0;
859       errors[i]    = FT_ERR( Unimplemented_Feature );
860     }
861   }
862
863
864 #endif  /* !FT_CONFIG_OPTION_GUESSING_EMBEDDED_RFORK */
865
866
867 /* END */