1/***************************************************************************/
2/* */
3/* ftstream.c */
4/* */
5/* I/O stream support (body). */
6/* */
7/* Copyright 2000-2018 by */
8/* David Turner, Robert Wilhelm, and Werner Lemberg. */
9/* */
10/* This file is part of the FreeType project, and may only be used, */
11/* modified, and distributed under the terms of the FreeType project */
12/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
13/* this file you indicate that you have read the license and */
14/* understand and accept it fully. */
15/* */
16/***************************************************************************/
17
18
19#include <ft2build.h>
20#include FT_INTERNAL_STREAM_H
21#include FT_INTERNAL_DEBUG_H
22
23
24 /*************************************************************************/
25 /* */
26 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
27 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
28 /* messages during execution. */
29 /* */
30#undef FT_COMPONENT
31#define FT_COMPONENT trace_stream
32
33
34 FT_BASE_DEF( void )
35 FT_Stream_OpenMemory( FT_Stream stream,
36 const FT_Byte* base,
37 FT_ULong size )
38 {
39 stream->base = (FT_Byte*) base;
40 stream->size = size;
41 stream->pos = 0;
42 stream->cursor = NULL;
43 stream->read = NULL;
44 stream->close = NULL;
45 }
46
47
48 FT_BASE_DEF( void )
49 FT_Stream_Close( FT_Stream stream )
50 {
51 if ( stream && stream->close )
52 stream->close( stream );
53 }
54
55
56 FT_BASE_DEF( FT_Error )
57 FT_Stream_Seek( FT_Stream stream,
58 FT_ULong pos )
59 {
60 FT_Error error = FT_Err_Ok;
61
62
63 if ( stream->read )
64 {
65 if ( stream->read( stream, pos, 0, 0 ) )
66 {
67 FT_ERROR(( "FT_Stream_Seek:"
68 " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
69 pos, stream->size ));
70
71 error = FT_THROW( Invalid_Stream_Operation );
72 }
73 }
74 /* note that seeking to the first position after the file is valid */
75 else if ( pos > stream->size )
76 {
77 FT_ERROR(( "FT_Stream_Seek:"
78 " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
79 pos, stream->size ));
80
81 error = FT_THROW( Invalid_Stream_Operation );
82 }
83
84 if ( !error )
85 stream->pos = pos;
86
87 return error;
88 }
89
90
91 FT_BASE_DEF( FT_Error )
92 FT_Stream_Skip( FT_Stream stream,
93 FT_Long distance )
94 {
95 if ( distance < 0 )
96 return FT_THROW( Invalid_Stream_Operation );
97
98 return FT_Stream_Seek( stream, stream->pos + (FT_ULong)distance );
99 }
100
101
102 FT_BASE_DEF( FT_ULong )
103 FT_Stream_Pos( FT_Stream stream )
104 {
105 return stream->pos;
106 }
107
108
109 FT_BASE_DEF( FT_Error )
110 FT_Stream_Read( FT_Stream stream,
111 FT_Byte* buffer,
112 FT_ULong count )
113 {
114 return FT_Stream_ReadAt( stream, stream->pos, buffer, count );
115 }
116
117
118 FT_BASE_DEF( FT_Error )
119 FT_Stream_ReadAt( FT_Stream stream,
120 FT_ULong pos,
121 FT_Byte* buffer,
122 FT_ULong count )
123 {
124 FT_Error error = FT_Err_Ok;
125 FT_ULong read_bytes;
126
127
128 if ( pos >= stream->size )
129 {
130 FT_ERROR(( "FT_Stream_ReadAt:"
131 " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
132 pos, stream->size ));
133
134 return FT_THROW( Invalid_Stream_Operation );
135 }
136
137 if ( stream->read )
138 read_bytes = stream->read( stream, pos, buffer, count );
139 else
140 {
141 read_bytes = stream->size - pos;
142 if ( read_bytes > count )
143 read_bytes = count;
144
145 FT_MEM_COPY( buffer, stream->base + pos, read_bytes );
146 }
147
148 stream->pos = pos + read_bytes;
149
150 if ( read_bytes < count )
151 {
152 FT_ERROR(( "FT_Stream_ReadAt:"
153 " invalid read; expected %lu bytes, got %lu\n",
154 count, read_bytes ));
155
156 error = FT_THROW( Invalid_Stream_Operation );
157 }
158
159 return error;
160 }
161
162
163 FT_BASE_DEF( FT_ULong )
164 FT_Stream_TryRead( FT_Stream stream,
165 FT_Byte* buffer,
166 FT_ULong count )
167 {
168 FT_ULong read_bytes = 0;
169
170
171 if ( stream->pos >= stream->size )
172 goto Exit;
173
174 if ( stream->read )
175 read_bytes = stream->read( stream, stream->pos, buffer, count );
176 else
177 {
178 read_bytes = stream->size - stream->pos;
179 if ( read_bytes > count )
180 read_bytes = count;
181
182 FT_MEM_COPY( buffer, stream->base + stream->pos, read_bytes );
183 }
184
185 stream->pos += read_bytes;
186
187 Exit:
188 return read_bytes;
189 }
190
191
192 FT_BASE_DEF( FT_Error )
193 FT_Stream_ExtractFrame( FT_Stream stream,
194 FT_ULong count,
195 FT_Byte** pbytes )
196 {
197 FT_Error error;
198
199
200 error = FT_Stream_EnterFrame( stream, count );
201 if ( !error )
202 {
203 *pbytes = (FT_Byte*)stream->cursor;
204
205 /* equivalent to FT_Stream_ExitFrame(), with no memory block release */
206 stream->cursor = NULL;
207 stream->limit = NULL;
208 }
209
210 return error;
211 }
212
213
214 FT_BASE_DEF( void )
215 FT_Stream_ReleaseFrame( FT_Stream stream,
216 FT_Byte** pbytes )
217 {
218 if ( stream && stream->read )
219 {
220 FT_Memory memory = stream->memory;
221
222#ifdef FT_DEBUG_MEMORY
223 ft_mem_free( memory, *pbytes );
224 *pbytes = NULL;
225#else
226 FT_FREE( *pbytes );
227#endif
228 }
229 *pbytes = NULL;
230 }
231
232
233 FT_BASE_DEF( FT_Error )
234 FT_Stream_EnterFrame( FT_Stream stream,
235 FT_ULong count )
236 {
237 FT_Error error = FT_Err_Ok;
238 FT_ULong read_bytes;
239
240
241 /* check for nested frame access */
242 FT_ASSERT( stream && stream->cursor == 0 );
243
244 if ( stream->read )
245 {
246 /* allocate the frame in memory */
247 FT_Memory memory = stream->memory;
248
249
250 /* simple sanity check */
251 if ( count > stream->size )
252 {
253 FT_ERROR(( "FT_Stream_EnterFrame:"
254 " frame size (%lu) larger than stream size (%lu)\n",
255 count, stream->size ));
256
257 error = FT_THROW( Invalid_Stream_Operation );
258 goto Exit;
259 }
260
261#ifdef FT_DEBUG_MEMORY
262 /* assume _ft_debug_file and _ft_debug_lineno are already set */
263 stream->base = (unsigned char*)ft_mem_qalloc( memory,
264 (FT_Long)count,
265 &error );
266 if ( error )
267 goto Exit;
268#else
269 if ( FT_QALLOC( stream->base, count ) )
270 goto Exit;
271#endif
272 /* read it */
273 read_bytes = stream->read( stream, stream->pos,
274 stream->base, count );
275 if ( read_bytes < count )
276 {
277 FT_ERROR(( "FT_Stream_EnterFrame:"
278 " invalid read; expected %lu bytes, got %lu\n",
279 count, read_bytes ));
280
281 FT_FREE( stream->base );
282 error = FT_THROW( Invalid_Stream_Operation );
283 }
284 stream->cursor = stream->base;
285 stream->limit = stream->cursor + count;
286 stream->pos += read_bytes;
287 }
288 else
289 {
290 /* check current and new position */
291 if ( stream->pos >= stream->size ||
292 stream->size - stream->pos < count )
293 {
294 FT_ERROR(( "FT_Stream_EnterFrame:"
295 " invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx\n",
296 stream->pos, count, stream->size ));
297
298 error = FT_THROW( Invalid_Stream_Operation );
299 goto Exit;
300 }
301
302 /* set cursor */
303 stream->cursor = stream->base + stream->pos;
304 stream->limit = stream->cursor + count;
305 stream->pos += count;
306 }
307
308 Exit:
309 return error;
310 }
311
312
313 FT_BASE_DEF( void )
314 FT_Stream_ExitFrame( FT_Stream stream )
315 {
316 /* IMPORTANT: The assertion stream->cursor != 0 was removed, given */
317 /* that it is possible to access a frame of length 0 in */
318 /* some weird fonts (usually, when accessing an array of */
319 /* 0 records, like in some strange kern tables). */
320 /* */
321 /* In this case, the loader code handles the 0-length table */
322 /* gracefully; however, stream.cursor is really set to 0 by the */
323 /* FT_Stream_EnterFrame() call, and this is not an error. */
324 /* */
325 FT_ASSERT( stream );
326
327 if ( stream->read )
328 {
329 FT_Memory memory = stream->memory;
330
331#ifdef FT_DEBUG_MEMORY
332 ft_mem_free( memory, stream->base );
333 stream->base = NULL;
334#else
335 FT_FREE( stream->base );
336#endif
337 }
338 stream->cursor = NULL;
339 stream->limit = NULL;
340 }
341
342
343 FT_BASE_DEF( FT_Char )
344 FT_Stream_GetChar( FT_Stream stream )
345 {
346 FT_Char result;
347
348
349 FT_ASSERT( stream && stream->cursor );
350
351 result = 0;
352 if ( stream->cursor < stream->limit )
353 result = (FT_Char)*stream->cursor++;
354
355 return result;
356 }
357
358
359 FT_BASE_DEF( FT_UShort )
360 FT_Stream_GetUShort( FT_Stream stream )
361 {
362 FT_Byte* p;
363 FT_UShort result;
364
365
366 FT_ASSERT( stream && stream->cursor );
367
368 result = 0;
369 p = stream->cursor;
370 if ( p + 1 < stream->limit )
371 result = FT_NEXT_USHORT( p );
372 stream->cursor = p;
373
374 return result;
375 }
376
377
378 FT_BASE_DEF( FT_UShort )
379 FT_Stream_GetUShortLE( FT_Stream stream )
380 {
381 FT_Byte* p;
382 FT_UShort result;
383
384
385 FT_ASSERT( stream && stream->cursor );
386
387 result = 0;
388 p = stream->cursor;
389 if ( p + 1 < stream->limit )
390 result = FT_NEXT_USHORT_LE( p );
391 stream->cursor = p;
392
393 return result;
394 }
395
396
397 FT_BASE_DEF( FT_ULong )
398 FT_Stream_GetUOffset( FT_Stream stream )
399 {
400 FT_Byte* p;
401 FT_ULong result;
402
403
404 FT_ASSERT( stream && stream->cursor );
405
406 result = 0;
407 p = stream->cursor;
408 if ( p + 2 < stream->limit )
409 result = FT_NEXT_UOFF3( p );
410 stream->cursor = p;
411 return result;
412 }
413
414
415 FT_BASE_DEF( FT_ULong )
416 FT_Stream_GetULong( FT_Stream stream )
417 {
418 FT_Byte* p;
419 FT_ULong result;
420
421
422 FT_ASSERT( stream && stream->cursor );
423
424 result = 0;
425 p = stream->cursor;
426 if ( p + 3 < stream->limit )
427 result = FT_NEXT_ULONG( p );
428 stream->cursor = p;
429 return result;
430 }
431
432
433 FT_BASE_DEF( FT_ULong )
434 FT_Stream_GetULongLE( FT_Stream stream )
435 {
436 FT_Byte* p;
437 FT_ULong result;
438
439
440 FT_ASSERT( stream && stream->cursor );
441
442 result = 0;
443 p = stream->cursor;
444 if ( p + 3 < stream->limit )
445 result = FT_NEXT_ULONG_LE( p );
446 stream->cursor = p;
447 return result;
448 }
449
450
451 FT_BASE_DEF( FT_Char )
452 FT_Stream_ReadChar( FT_Stream stream,
453 FT_Error* error )
454 {
455 FT_Byte result = 0;
456
457
458 FT_ASSERT( stream );
459
460 *error = FT_Err_Ok;
461
462 if ( stream->read )
463 {
464 if ( stream->read( stream, stream->pos, &result, 1L ) != 1L )
465 goto Fail;
466 }
467 else
468 {
469 if ( stream->pos < stream->size )
470 result = stream->base[stream->pos];
471 else
472 goto Fail;
473 }
474 stream->pos++;
475
476 return (FT_Char)result;
477
478 Fail:
479 *error = FT_THROW( Invalid_Stream_Operation );
480 FT_ERROR(( "FT_Stream_ReadChar:"
481 " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
482 stream->pos, stream->size ));
483
484 return 0;
485 }
486
487
488 FT_BASE_DEF( FT_UShort )
489 FT_Stream_ReadUShort( FT_Stream stream,
490 FT_Error* error )
491 {
492 FT_Byte reads[2];
493 FT_Byte* p = 0;
494 FT_UShort result = 0;
495
496
497 FT_ASSERT( stream );
498
499 *error = FT_Err_Ok;
500
501 if ( stream->pos + 1 < stream->size )
502 {
503 if ( stream->read )
504 {
505 if ( stream->read( stream, stream->pos, reads, 2L ) != 2L )
506 goto Fail;
507
508 p = reads;
509 }
510 else
511 p = stream->base + stream->pos;
512
513 if ( p )
514 result = FT_NEXT_USHORT( p );
515 }
516 else
517 goto Fail;
518
519 stream->pos += 2;
520
521 return result;
522
523 Fail:
524 *error = FT_THROW( Invalid_Stream_Operation );
525 FT_ERROR(( "FT_Stream_ReadUShort:"
526 " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
527 stream->pos, stream->size ));
528
529 return 0;
530 }
531
532
533 FT_BASE_DEF( FT_UShort )
534 FT_Stream_ReadUShortLE( FT_Stream stream,
535 FT_Error* error )
536 {
537 FT_Byte reads[2];
538 FT_Byte* p = 0;
539 FT_UShort result = 0;
540
541
542 FT_ASSERT( stream );
543
544 *error = FT_Err_Ok;
545
546 if ( stream->pos + 1 < stream->size )
547 {
548 if ( stream->read )
549 {
550 if ( stream->read( stream, stream->pos, reads, 2L ) != 2L )
551 goto Fail;
552
553 p = reads;
554 }
555 else
556 p = stream->base + stream->pos;
557
558 if ( p )
559 result = FT_NEXT_USHORT_LE( p );
560 }
561 else
562 goto Fail;
563
564 stream->pos += 2;
565
566 return result;
567
568 Fail:
569 *error = FT_THROW( Invalid_Stream_Operation );
570 FT_ERROR(( "FT_Stream_ReadUShortLE:"
571 " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
572 stream->pos, stream->size ));
573
574 return 0;
575 }
576
577
578 FT_BASE_DEF( FT_ULong )
579 FT_Stream_ReadUOffset( FT_Stream stream,
580 FT_Error* error )
581 {
582 FT_Byte reads[3];
583 FT_Byte* p = 0;
584 FT_ULong result = 0;
585
586
587 FT_ASSERT( stream );
588
589 *error = FT_Err_Ok;
590
591 if ( stream->pos + 2 < stream->size )
592 {
593 if ( stream->read )
594 {
595 if (stream->read( stream, stream->pos, reads, 3L ) != 3L )
596 goto Fail;
597
598 p = reads;
599 }
600 else
601 p = stream->base + stream->pos;
602
603 if ( p )
604 result = FT_NEXT_UOFF3( p );
605 }
606 else
607 goto Fail;
608
609 stream->pos += 3;
610
611 return result;
612
613 Fail:
614 *error = FT_THROW( Invalid_Stream_Operation );
615 FT_ERROR(( "FT_Stream_ReadUOffset:"
616 " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
617 stream->pos, stream->size ));
618
619 return 0;
620 }
621
622
623 FT_BASE_DEF( FT_ULong )
624 FT_Stream_ReadULong( FT_Stream stream,
625 FT_Error* error )
626 {
627 FT_Byte reads[4];
628 FT_Byte* p = 0;
629 FT_ULong result = 0;
630
631
632 FT_ASSERT( stream );
633
634 *error = FT_Err_Ok;
635
636 if ( stream->pos + 3 < stream->size )
637 {
638 if ( stream->read )
639 {
640 if ( stream->read( stream, stream->pos, reads, 4L ) != 4L )
641 goto Fail;
642
643 p = reads;
644 }
645 else
646 p = stream->base + stream->pos;
647
648 if ( p )
649 result = FT_NEXT_ULONG( p );
650 }
651 else
652 goto Fail;
653
654 stream->pos += 4;
655
656 return result;
657
658 Fail:
659 *error = FT_THROW( Invalid_Stream_Operation );
660 FT_ERROR(( "FT_Stream_ReadULong:"
661 " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
662 stream->pos, stream->size ));
663
664 return 0;
665 }
666
667
668 FT_BASE_DEF( FT_ULong )
669 FT_Stream_ReadULongLE( FT_Stream stream,
670 FT_Error* error )
671 {
672 FT_Byte reads[4];
673 FT_Byte* p = 0;
674 FT_ULong result = 0;
675
676
677 FT_ASSERT( stream );
678
679 *error = FT_Err_Ok;
680
681 if ( stream->pos + 3 < stream->size )
682 {
683 if ( stream->read )
684 {
685 if ( stream->read( stream, stream->pos, reads, 4L ) != 4L )
686 goto Fail;
687
688 p = reads;
689 }
690 else
691 p = stream->base + stream->pos;
692
693 if ( p )
694 result = FT_NEXT_ULONG_LE( p );
695 }
696 else
697 goto Fail;
698
699 stream->pos += 4;
700
701 return result;
702
703 Fail:
704 *error = FT_THROW( Invalid_Stream_Operation );
705 FT_ERROR(( "FT_Stream_ReadULongLE:"
706 " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
707 stream->pos, stream->size ));
708
709 return 0;
710 }
711
712
713 FT_BASE_DEF( FT_Error )
714 FT_Stream_ReadFields( FT_Stream stream,
715 const FT_Frame_Field* fields,
716 void* structure )
717 {
718 FT_Error error;
719 FT_Bool frame_accessed = 0;
720 FT_Byte* cursor;
721
722
723 if ( !fields )
724 return FT_THROW( Invalid_Argument );
725
726 if ( !stream )
727 return FT_THROW( Invalid_Stream_Handle );
728
729 cursor = stream->cursor;
730
731 error = FT_Err_Ok;
732 do
733 {
734 FT_ULong value;
735 FT_Int sign_shift;
736 FT_Byte* p;
737
738
739 switch ( fields->value )
740 {
741 case ft_frame_start: /* access a new frame */
742 error = FT_Stream_EnterFrame( stream, fields->offset );
743 if ( error )
744 goto Exit;
745
746 frame_accessed = 1;
747 cursor = stream->cursor;
748 fields++;
749 continue; /* loop! */
750
751 case ft_frame_bytes: /* read a byte sequence */
752 case ft_frame_skip: /* skip some bytes */
753 {
754 FT_UInt len = fields->size;
755
756
757 if ( cursor + len > stream->limit )
758 {
759 error = FT_THROW( Invalid_Stream_Operation );
760 goto Exit;
761 }
762
763 if ( fields->value == ft_frame_bytes )
764 {
765 p = (FT_Byte*)structure + fields->offset;
766 FT_MEM_COPY( p, cursor, len );
767 }
768 cursor += len;
769 fields++;
770 continue;
771 }
772
773 case ft_frame_byte:
774 case ft_frame_schar: /* read a single byte */
775 value = FT_NEXT_BYTE( cursor );
776 sign_shift = 24;
777 break;
778
779 case ft_frame_short_be:
780 case ft_frame_ushort_be: /* read a 2-byte big-endian short */
781 value = FT_NEXT_USHORT( cursor );
782 sign_shift = 16;
783 break;
784
785 case ft_frame_short_le:
786 case ft_frame_ushort_le: /* read a 2-byte little-endian short */
787 value = FT_NEXT_USHORT_LE( cursor );
788 sign_shift = 16;
789 break;
790
791 case ft_frame_long_be:
792 case ft_frame_ulong_be: /* read a 4-byte big-endian long */
793 value = FT_NEXT_ULONG( cursor );
794 sign_shift = 0;
795 break;
796
797 case ft_frame_long_le:
798 case ft_frame_ulong_le: /* read a 4-byte little-endian long */
799 value = FT_NEXT_ULONG_LE( cursor );
800 sign_shift = 0;
801 break;
802
803 case ft_frame_off3_be:
804 case ft_frame_uoff3_be: /* read a 3-byte big-endian long */
805 value = FT_NEXT_UOFF3( cursor );
806 sign_shift = 8;
807 break;
808
809 case ft_frame_off3_le:
810 case ft_frame_uoff3_le: /* read a 3-byte little-endian long */
811 value = FT_NEXT_UOFF3_LE( cursor );
812 sign_shift = 8;
813 break;
814
815 default:
816 /* otherwise, exit the loop */
817 stream->cursor = cursor;
818 goto Exit;
819 }
820
821 /* now, compute the signed value is necessary */
822 if ( fields->value & FT_FRAME_OP_SIGNED )
823 value = (FT_ULong)( (FT_Int32)( value << sign_shift ) >> sign_shift );
824
825 /* finally, store the value in the object */
826
827 p = (FT_Byte*)structure + fields->offset;
828 switch ( fields->size )
829 {
830 case ( 8 / FT_CHAR_BIT ):
831 *(FT_Byte*)p = (FT_Byte)value;
832 break;
833
834 case ( 16 / FT_CHAR_BIT ):
835 *(FT_UShort*)p = (FT_UShort)value;
836 break;
837
838 case ( 32 / FT_CHAR_BIT ):
839 *(FT_UInt32*)p = (FT_UInt32)value;
840 break;
841
842 default: /* for 64-bit systems */
843 *(FT_ULong*)p = (FT_ULong)value;
844 }
845
846 /* go to next field */
847 fields++;
848 }
849 while ( 1 );
850
851 Exit:
852 /* close the frame if it was opened by this read */
853 if ( frame_accessed )
854 FT_Stream_ExitFrame( stream );
855
856 return error;
857 }
858
859
860/* END */
861