1 /*
2 * Copyright © 2009 Red Hat, Inc.
3 * Copyright © 2018 Ebrahim Byagowi
4 *
5 * This is part of HarfBuzz, a text shaping library.
6 *
7 * Permission is hereby granted, without written agreement and without
8 * license or royalty fees, to use, copy, modify, and distribute this
9 * software and its documentation for any purpose, provided that the
10 * above copyright notice and the following two paragraphs appear in
11 * all copies of this software.
12 *
13 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
14 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
15 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
16 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
17 * DAMAGE.
18 *
19 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
20 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
21 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
22 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
23 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
24 *
25 * Red Hat Author(s): Behdad Esfahbod
26 */
27
28 #include "hb.hh"
29 #include "hb-blob.hh"
30
31 #ifdef HAVE_SYS_MMAN_H
32 #ifdef HAVE_UNISTD_H
33 #include <unistd.h>
34 #endif /* HAVE_UNISTD_H */
35 #include <sys/mman.h>
36 #endif /* HAVE_SYS_MMAN_H */
37
38 #include <stdio.h>
39 #include <errno.h>
40 #include <stdlib.h>
41
42
43 /**
44 * SECTION: hb-blob
45 * @title: hb-blob
46 * @short_description: Binary data containers
47 * @include: hb.h
48 *
49 * Blobs wrap a chunk of binary data to handle lifecycle management of data
50 * while it is passed between client and HarfBuzz. Blobs are primarily used
51 * to create font faces, but also to access font face tables, as well as
52 * pass around other binary data.
53 **/
54
55
56 /**
57 * hb_blob_create: (skip)
58 * @data: Pointer to blob data.
59 * @length: Length of @data in bytes.
60 * @mode: Memory mode for @data.
61 * @user_data: Data parameter to pass to @destroy.
62 * @destroy: Callback to call when @data is not needed anymore.
63 *
64 * Creates a new "blob" object wrapping @data. The @mode parameter is used
65 * to negotiate ownership and lifecycle of @data.
66 *
67 * Return value: New blob, or the empty blob if something failed or if @length is
68 * zero. Destroy with hb_blob_destroy().
69 *
70 * Since: 0.9.2
71 **/
72 hb_blob_t *
hb_blob_create(const char * data,unsigned int length,hb_memory_mode_t mode,void * user_data,hb_destroy_func_t destroy)73 hb_blob_create (const char *data,
74 unsigned int length,
75 hb_memory_mode_t mode,
76 void *user_data,
77 hb_destroy_func_t destroy)
78 {
79 hb_blob_t *blob;
80
81 if (!length ||
82 length >= 1u << 31 ||
83 !(blob = hb_object_create<hb_blob_t> ())) {
84 if (destroy)
85 destroy (user_data);
86 return hb_blob_get_empty ();
87 }
88
89 blob->data = data;
90 blob->length = length;
91 blob->mode = mode;
92
93 blob->user_data = user_data;
94 blob->destroy = destroy;
95
96 if (blob->mode == HB_MEMORY_MODE_DUPLICATE) {
97 blob->mode = HB_MEMORY_MODE_READONLY;
98 if (!blob->try_make_writable ()) {
99 hb_blob_destroy (blob);
100 return hb_blob_get_empty ();
101 }
102 }
103
104 return blob;
105 }
106
107 static void
_hb_blob_destroy(void * data)108 _hb_blob_destroy (void *data)
109 {
110 hb_blob_destroy ((hb_blob_t *) data);
111 }
112
113 /**
114 * hb_blob_create_sub_blob:
115 * @parent: Parent blob.
116 * @offset: Start offset of sub-blob within @parent, in bytes.
117 * @length: Length of sub-blob.
118 *
119 * Returns a blob that represents a range of bytes in @parent. The new
120 * blob is always created with %HB_MEMORY_MODE_READONLY, meaning that it
121 * will never modify data in the parent blob. The parent data is not
122 * expected to be modified, and will result in undefined behavior if it
123 * is.
124 *
125 * Makes @parent immutable.
126 *
127 * Return value: New blob, or the empty blob if something failed or if
128 * @length is zero or @offset is beyond the end of @parent's data. Destroy
129 * with hb_blob_destroy().
130 *
131 * Since: 0.9.2
132 **/
133 hb_blob_t *
hb_blob_create_sub_blob(hb_blob_t * parent,unsigned int offset,unsigned int length)134 hb_blob_create_sub_blob (hb_blob_t *parent,
135 unsigned int offset,
136 unsigned int length)
137 {
138 hb_blob_t *blob;
139
140 if (!length || !parent || offset >= parent->length)
141 return hb_blob_get_empty ();
142
143 hb_blob_make_immutable (parent);
144
145 blob = hb_blob_create (parent->data + offset,
146 MIN (length, parent->length - offset),
147 HB_MEMORY_MODE_READONLY,
148 hb_blob_reference (parent),
149 _hb_blob_destroy);
150
151 return blob;
152 }
153
154 /**
155 * hb_blob_copy_writable_or_fail:
156 * @blob: A blob.
157 *
158 * Makes a writable copy of @blob.
159 *
160 * Return value: New blob, or nullptr if allocation failed.
161 *
162 * Since: 1.8.0
163 **/
164 hb_blob_t *
hb_blob_copy_writable_or_fail(hb_blob_t * blob)165 hb_blob_copy_writable_or_fail (hb_blob_t *blob)
166 {
167 blob = hb_blob_create (blob->data,
168 blob->length,
169 HB_MEMORY_MODE_DUPLICATE,
170 nullptr,
171 nullptr);
172
173 if (unlikely (blob == hb_blob_get_empty ()))
174 blob = nullptr;
175
176 return blob;
177 }
178
179 /**
180 * hb_blob_get_empty:
181 *
182 * Returns the singleton empty blob.
183 *
184 * See TODO:link object types for more information.
185 *
186 * Return value: (transfer full): the empty blob.
187 *
188 * Since: 0.9.2
189 **/
190 hb_blob_t *
hb_blob_get_empty()191 hb_blob_get_empty ()
192 {
193 return const_cast<hb_blob_t *> (&Null(hb_blob_t));
194 }
195
196 /**
197 * hb_blob_reference: (skip)
198 * @blob: a blob.
199 *
200 * Increases the reference count on @blob.
201 *
202 * See TODO:link object types for more information.
203 *
204 * Return value: @blob.
205 *
206 * Since: 0.9.2
207 **/
208 hb_blob_t *
hb_blob_reference(hb_blob_t * blob)209 hb_blob_reference (hb_blob_t *blob)
210 {
211 return hb_object_reference (blob);
212 }
213
214 /**
215 * hb_blob_destroy: (skip)
216 * @blob: a blob.
217 *
218 * Decreases the reference count on @blob, and if it reaches zero, destroys
219 * @blob, freeing all memory, possibly calling the destroy-callback the blob
220 * was created for if it has not been called already.
221 *
222 * See TODO:link object types for more information.
223 *
224 * Since: 0.9.2
225 **/
226 void
hb_blob_destroy(hb_blob_t * blob)227 hb_blob_destroy (hb_blob_t *blob)
228 {
229 if (!hb_object_destroy (blob)) return;
230
231 blob->fini_shallow ();
232
233 free (blob);
234 }
235
236 /**
237 * hb_blob_set_user_data: (skip)
238 * @blob: a blob.
239 * @key: key for data to set.
240 * @data: data to set.
241 * @destroy: callback to call when @data is not needed anymore.
242 * @replace: whether to replace an existing data with the same key.
243 *
244 * Return value:
245 *
246 * Since: 0.9.2
247 **/
248 hb_bool_t
hb_blob_set_user_data(hb_blob_t * blob,hb_user_data_key_t * key,void * data,hb_destroy_func_t destroy,hb_bool_t replace)249 hb_blob_set_user_data (hb_blob_t *blob,
250 hb_user_data_key_t *key,
251 void * data,
252 hb_destroy_func_t destroy,
253 hb_bool_t replace)
254 {
255 return hb_object_set_user_data (blob, key, data, destroy, replace);
256 }
257
258 /**
259 * hb_blob_get_user_data: (skip)
260 * @blob: a blob.
261 * @key: key for data to get.
262 *
263 *
264 *
265 * Return value: (transfer none):
266 *
267 * Since: 0.9.2
268 **/
269 void *
hb_blob_get_user_data(hb_blob_t * blob,hb_user_data_key_t * key)270 hb_blob_get_user_data (hb_blob_t *blob,
271 hb_user_data_key_t *key)
272 {
273 return hb_object_get_user_data (blob, key);
274 }
275
276
277 /**
278 * hb_blob_make_immutable:
279 * @blob: a blob.
280 *
281 *
282 *
283 * Since: 0.9.2
284 **/
285 void
hb_blob_make_immutable(hb_blob_t * blob)286 hb_blob_make_immutable (hb_blob_t *blob)
287 {
288 if (hb_object_is_immutable (blob))
289 return;
290
291 hb_object_make_immutable (blob);
292 }
293
294 /**
295 * hb_blob_is_immutable:
296 * @blob: a blob.
297 *
298 *
299 *
300 * Return value: TODO
301 *
302 * Since: 0.9.2
303 **/
304 hb_bool_t
hb_blob_is_immutable(hb_blob_t * blob)305 hb_blob_is_immutable (hb_blob_t *blob)
306 {
307 return hb_object_is_immutable (blob);
308 }
309
310
311 /**
312 * hb_blob_get_length:
313 * @blob: a blob.
314 *
315 *
316 *
317 * Return value: the length of blob data in bytes.
318 *
319 * Since: 0.9.2
320 **/
321 unsigned int
hb_blob_get_length(hb_blob_t * blob)322 hb_blob_get_length (hb_blob_t *blob)
323 {
324 return blob->length;
325 }
326
327 /**
328 * hb_blob_get_data:
329 * @blob: a blob.
330 * @length: (out):
331 *
332 *
333 *
334 * Returns: (transfer none) (array length=length):
335 *
336 * Since: 0.9.2
337 **/
338 const char *
hb_blob_get_data(hb_blob_t * blob,unsigned int * length)339 hb_blob_get_data (hb_blob_t *blob, unsigned int *length)
340 {
341 if (length)
342 *length = blob->length;
343
344 return blob->data;
345 }
346
347 /**
348 * hb_blob_get_data_writable:
349 * @blob: a blob.
350 * @length: (out): output length of the writable data.
351 *
352 * Tries to make blob data writable (possibly copying it) and
353 * return pointer to data.
354 *
355 * Fails if blob has been made immutable, or if memory allocation
356 * fails.
357 *
358 * Returns: (transfer none) (array length=length): Writable blob data,
359 * or %NULL if failed.
360 *
361 * Since: 0.9.2
362 **/
363 char *
hb_blob_get_data_writable(hb_blob_t * blob,unsigned int * length)364 hb_blob_get_data_writable (hb_blob_t *blob, unsigned int *length)
365 {
366 if (!blob->try_make_writable ()) {
367 if (length)
368 *length = 0;
369
370 return nullptr;
371 }
372
373 if (length)
374 *length = blob->length;
375
376 return const_cast<char *> (blob->data);
377 }
378
379
380 bool
try_make_writable_inplace_unix()381 hb_blob_t::try_make_writable_inplace_unix ()
382 {
383 #if defined(HAVE_SYS_MMAN_H) && defined(HAVE_MPROTECT)
384 uintptr_t pagesize = -1, mask, length;
385 const char *addr;
386
387 #if defined(HAVE_SYSCONF) && defined(_SC_PAGE_SIZE)
388 pagesize = (uintptr_t) sysconf (_SC_PAGE_SIZE);
389 #elif defined(HAVE_SYSCONF) && defined(_SC_PAGESIZE)
390 pagesize = (uintptr_t) sysconf (_SC_PAGESIZE);
391 #elif defined(HAVE_GETPAGESIZE)
392 pagesize = (uintptr_t) getpagesize ();
393 #endif
394
395 if ((uintptr_t) -1L == pagesize) {
396 DEBUG_MSG_FUNC (BLOB, this, "failed to get pagesize: %s", strerror (errno));
397 return false;
398 }
399 DEBUG_MSG_FUNC (BLOB, this, "pagesize is %lu", (unsigned long) pagesize);
400
401 mask = ~(pagesize-1);
402 addr = (const char *) (((uintptr_t) this->data) & mask);
403 length = (const char *) (((uintptr_t) this->data + this->length + pagesize-1) & mask) - addr;
404 DEBUG_MSG_FUNC (BLOB, this,
405 "calling mprotect on [%p..%p] (%lu bytes)",
406 addr, addr+length, (unsigned long) length);
407 if (-1 == mprotect ((void *) addr, length, PROT_READ | PROT_WRITE)) {
408 DEBUG_MSG_FUNC (BLOB, this, "mprotect failed: %s", strerror (errno));
409 return false;
410 }
411
412 this->mode = HB_MEMORY_MODE_WRITABLE;
413
414 DEBUG_MSG_FUNC (BLOB, this,
415 "successfully made [%p..%p] (%lu bytes) writable\n",
416 addr, addr+length, (unsigned long) length);
417 return true;
418 #else
419 return false;
420 #endif
421 }
422
423 bool
try_make_writable_inplace()424 hb_blob_t::try_make_writable_inplace ()
425 {
426 DEBUG_MSG_FUNC (BLOB, this, "making writable inplace\n");
427
428 if (this->try_make_writable_inplace_unix ())
429 return true;
430
431 DEBUG_MSG_FUNC (BLOB, this, "making writable -> FAILED\n");
432
433 /* Failed to make writable inplace, mark that */
434 this->mode = HB_MEMORY_MODE_READONLY;
435 return false;
436 }
437
438 bool
try_make_writable()439 hb_blob_t::try_make_writable ()
440 {
441 if (hb_object_is_immutable (this))
442 return false;
443
444 if (this->mode == HB_MEMORY_MODE_WRITABLE)
445 return true;
446
447 if (this->mode == HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE && this->try_make_writable_inplace ())
448 return true;
449
450 if (this->mode == HB_MEMORY_MODE_WRITABLE)
451 return true;
452
453
454 DEBUG_MSG_FUNC (BLOB, this, "current data is -> %p\n", this->data);
455
456 char *new_data;
457
458 new_data = (char *) malloc (this->length);
459 if (unlikely (!new_data))
460 return false;
461
462 DEBUG_MSG_FUNC (BLOB, this, "dupped successfully -> %p\n", this->data);
463
464 memcpy (new_data, this->data, this->length);
465 this->destroy_user_data ();
466 this->mode = HB_MEMORY_MODE_WRITABLE;
467 this->data = new_data;
468 this->user_data = new_data;
469 this->destroy = free;
470
471 return true;
472 }
473
474 /*
475 * Mmap
476 */
477
478 #ifdef HAVE_MMAP
479 # include <sys/types.h>
480 # include <sys/stat.h>
481 # include <fcntl.h>
482 #endif
483
484 #ifdef _WIN32
485 # include <windows.h>
486 #else
487 # ifndef O_BINARY
488 # define O_BINARY 0
489 # endif
490 #endif
491
492 #ifndef MAP_NORESERVE
493 # define MAP_NORESERVE 0
494 #endif
495
496 struct hb_mapped_file_t
497 {
498 char *contents;
499 unsigned long length;
500 #ifdef _WIN32
501 HANDLE mapping;
502 #endif
503 };
504
505 #if (defined(HAVE_MMAP) || defined(_WIN32)) && !defined(HB_NO_MMAP)
506 static void
_hb_mapped_file_destroy(void * file_)507 _hb_mapped_file_destroy (void *file_)
508 {
509 hb_mapped_file_t *file = (hb_mapped_file_t *) file_;
510 #ifdef HAVE_MMAP
511 munmap (file->contents, file->length);
512 #elif defined(_WIN32)
513 UnmapViewOfFile (file->contents);
514 CloseHandle (file->mapping);
515 #else
516 assert (0); // If we don't have mmap we shouldn't reach here
517 #endif
518
519 free (file);
520 }
521 #endif
522
523 /**
524 * hb_blob_create_from_file:
525 * @file_name: font filename.
526 *
527 * Returns: A hb_blob_t pointer with the content of the file
528 *
529 * Since: 1.7.7
530 **/
531 hb_blob_t *
hb_blob_create_from_file(const char * file_name)532 hb_blob_create_from_file (const char *file_name)
533 {
534 /* Adopted from glib's gmappedfile.c with Matthias Clasen and
535 Allison Lortie permission but changed a lot to suit our need. */
536 #if defined(HAVE_MMAP) && !defined(HB_NO_MMAP)
537 hb_mapped_file_t *file = (hb_mapped_file_t *) calloc (1, sizeof (hb_mapped_file_t));
538 if (unlikely (!file)) return hb_blob_get_empty ();
539
540 int fd = open (file_name, O_RDONLY | O_BINARY, 0);
541 if (unlikely (fd == -1)) goto fail_without_close;
542
543 struct stat st;
544 if (unlikely (fstat (fd, &st) == -1)) goto fail;
545
546 file->length = (unsigned long) st.st_size;
547 file->contents = (char *) mmap (nullptr, file->length, PROT_READ,
548 MAP_PRIVATE | MAP_NORESERVE, fd, 0);
549
550 if (unlikely (file->contents == MAP_FAILED)) goto fail;
551
552 close (fd);
553
554 return hb_blob_create (file->contents, file->length,
555 HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE, (void *) file,
556 (hb_destroy_func_t) _hb_mapped_file_destroy);
557
558 fail:
559 close (fd);
560 fail_without_close:
561 free (file);
562
563 #elif defined(_WIN32) && !defined(HB_NO_MMAP)
564 hb_mapped_file_t *file = (hb_mapped_file_t *) calloc (1, sizeof (hb_mapped_file_t));
565 if (unlikely (!file)) return hb_blob_get_empty ();
566
567 HANDLE fd;
568 unsigned int size = strlen (file_name) + 1;
569 wchar_t * wchar_file_name = (wchar_t *) malloc (sizeof (wchar_t) * size);
570 if (unlikely (wchar_file_name == nullptr)) goto fail_without_close;
571 mbstowcs (wchar_file_name, file_name, size);
572 #if defined(WINAPI_FAMILY) && (WINAPI_FAMILY==WINAPI_FAMILY_PC_APP || WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP)
573 {
574 CREATEFILE2_EXTENDED_PARAMETERS ceparams = { 0 };
575 ceparams.dwSize = sizeof(CREATEFILE2_EXTENDED_PARAMETERS);
576 ceparams.dwFileAttributes = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED & 0xFFFF;
577 ceparams.dwFileFlags = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED & 0xFFF00000;
578 ceparams.dwSecurityQosFlags = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED & 0x000F0000;
579 ceparams.lpSecurityAttributes = nullptr;
580 ceparams.hTemplateFile = nullptr;
581 fd = CreateFile2 (wchar_file_name, GENERIC_READ, FILE_SHARE_READ,
582 OPEN_EXISTING, &ceparams);
583 }
584 #else
585 fd = CreateFileW (wchar_file_name, GENERIC_READ, FILE_SHARE_READ, nullptr,
586 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,
587 nullptr);
588 #endif
589 free (wchar_file_name);
590
591 if (unlikely (fd == INVALID_HANDLE_VALUE)) goto fail_without_close;
592
593 #if defined(WINAPI_FAMILY) && (WINAPI_FAMILY==WINAPI_FAMILY_PC_APP || WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP)
594 {
595 LARGE_INTEGER length;
596 GetFileSizeEx (fd, &length);
597 file->length = length.LowPart;
598 file->mapping = CreateFileMappingFromApp (fd, nullptr, PAGE_READONLY, length.QuadPart, nullptr);
599 }
600 #else
601 file->length = (unsigned long) GetFileSize (fd, nullptr);
602 file->mapping = CreateFileMapping (fd, nullptr, PAGE_READONLY, 0, 0, nullptr);
603 #endif
604 if (unlikely (file->mapping == nullptr)) goto fail;
605
606 #if defined(WINAPI_FAMILY) && (WINAPI_FAMILY==WINAPI_FAMILY_PC_APP || WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP)
607 file->contents = (char *) MapViewOfFileFromApp (file->mapping, FILE_MAP_READ, 0, 0);
608 #else
609 file->contents = (char *) MapViewOfFile (file->mapping, FILE_MAP_READ, 0, 0, 0);
610 #endif
611 if (unlikely (file->contents == nullptr)) goto fail;
612
613 CloseHandle (fd);
614 return hb_blob_create (file->contents, file->length,
615 HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE, (void *) file,
616 (hb_destroy_func_t) _hb_mapped_file_destroy);
617
618 fail:
619 CloseHandle (fd);
620 fail_without_close:
621 free (file);
622
623 #endif
624
625 /* The following tries to read a file without knowing its size beforehand
626 It's used as a fallback for systems without mmap or to read from pipes */
627 unsigned long len = 0, allocated = BUFSIZ * 16;
628 char *data = (char *) malloc (allocated);
629 if (unlikely (data == nullptr)) return hb_blob_get_empty ();
630
631 FILE *fp = fopen (file_name, "rb");
632 if (unlikely (fp == nullptr)) goto fread_fail_without_close;
633
634 while (!feof (fp))
635 {
636 if (allocated - len < BUFSIZ)
637 {
638 allocated *= 2;
639 /* Don't allocate and go more than ~536MB, our mmap reader still
640 can cover files like that but lets limit our fallback reader */
641 if (unlikely (allocated > (2 << 28))) goto fread_fail;
642 char *new_data = (char *) realloc (data, allocated);
643 if (unlikely (new_data == nullptr)) goto fread_fail;
644 data = new_data;
645 }
646
647 unsigned long addition = fread (data + len, 1, allocated - len, fp);
648
649 int err = ferror (fp);
650 #ifdef EINTR // armcc doesn't have it
651 if (unlikely (err == EINTR)) continue;
652 #endif
653 if (unlikely (err)) goto fread_fail;
654
655 len += addition;
656 }
657
658 return hb_blob_create (data, len, HB_MEMORY_MODE_WRITABLE, data,
659 (hb_destroy_func_t) free);
660
661 fread_fail:
662 fclose (fp);
663 fread_fail_without_close:
664 free (data);
665 return hb_blob_get_empty ();
666 }
667