From 0a1bea3739aa642aa307ed32ed5aed4c78d19d42 Mon Sep 17 00:00:00 2001 From: alihanozturk Date: Sun, 5 Feb 2017 17:50:42 +0300 Subject: [PATCH] ghostscript:v.bump --- .../ghostscript-9.20-cve-2016-7976.patch | 179 +++ .../ghostscript-9.20-cve-2016-7977.patch | 28 + .../ghostscript-9.20-cve-2016-7978.patch | 24 + .../ghostscript-9.20-cve-2016-7979.patch | 42 + .../ghostscript-9.20-cve-2016-8602.patch | 41 + .../ghostscript-9.20-cve-2016-9601.patch | 896 ++++++++++++ ...cript-9.20-fix-openjpeg-system-build.patch | 55 + ...9.20-handle-glyphdirectory-correctly.patch | 51 + ...20-remove-and-reimplement-ConvertUTF.patch | 1227 +++++++++++++++++ ...hostscript-9.20-run-dvipdf-securely.patch} | 21 +- .../ghostscript-9.20-runlibfileifexists.patch | 92 ++ .../ghostscript-9.20-urw-fonts-naming.patch | 100 ++ .../fedora/ghostscript-Fontmap.local.patch | 9 - .../ghostscript-gdevcups-debug-uninit.patch | 11 - .../files/fedora/ghostscript-gs694154.patch | 12 - .../ghostscript-icc-missing-check.patch | 12 - .../ghostscript-iccprofiles-initdir.patch | 35 - .../files/fedora/ghostscript-multilib.patch | 14 - .../files/fedora/ghostscript-noopt.patch | 12 - .../ghostscript-runlibfileifexists.patch | 52 - .../fedora/ghostscript-wrf-snprintf.patch | 22 - office/postscript/ghostscript/pspec.xml | 38 +- 22 files changed, 2773 insertions(+), 200 deletions(-) create mode 100644 office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-7976.patch create mode 100644 office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-7977.patch create mode 100644 office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-7978.patch create mode 100644 office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-7979.patch create mode 100644 office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-8602.patch create mode 100644 office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-9601.patch create mode 100644 office/postscript/ghostscript/files/fedora/ghostscript-9.20-fix-openjpeg-system-build.patch create mode 100644 office/postscript/ghostscript/files/fedora/ghostscript-9.20-handle-glyphdirectory-correctly.patch create mode 100644 office/postscript/ghostscript/files/fedora/ghostscript-9.20-remove-and-reimplement-ConvertUTF.patch rename office/postscript/ghostscript/files/fedora/{ghostscript-scripts.patch => ghostscript-9.20-run-dvipdf-securely.patch} (54%) create mode 100644 office/postscript/ghostscript/files/fedora/ghostscript-9.20-runlibfileifexists.patch create mode 100644 office/postscript/ghostscript/files/fedora/ghostscript-9.20-urw-fonts-naming.patch delete mode 100644 office/postscript/ghostscript/files/fedora/ghostscript-Fontmap.local.patch delete mode 100644 office/postscript/ghostscript/files/fedora/ghostscript-gdevcups-debug-uninit.patch delete mode 100644 office/postscript/ghostscript/files/fedora/ghostscript-gs694154.patch delete mode 100644 office/postscript/ghostscript/files/fedora/ghostscript-icc-missing-check.patch delete mode 100644 office/postscript/ghostscript/files/fedora/ghostscript-iccprofiles-initdir.patch delete mode 100644 office/postscript/ghostscript/files/fedora/ghostscript-multilib.patch delete mode 100644 office/postscript/ghostscript/files/fedora/ghostscript-noopt.patch delete mode 100644 office/postscript/ghostscript/files/fedora/ghostscript-runlibfileifexists.patch delete mode 100644 office/postscript/ghostscript/files/fedora/ghostscript-wrf-snprintf.patch diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-7976.patch b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-7976.patch new file mode 100644 index 0000000000..618278c06f --- /dev/null +++ b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-7976.patch @@ -0,0 +1,179 @@ +From fee19fa8d4f6f351e5a76f5801884880249d6a45 Mon Sep 17 00:00:00 2001 +From: Chris Liddell +Date: Wed, 5 Oct 2016 09:55:55 +0100 +Subject: [PATCH] Bug 697178: Add a file permissions callback + +For the rare occasions when the graphics library directly opens a file +(currently for reading), this allows us to apply any restrictions on +file access normally applied in the interpteter. +--- + base/gsicc_manage.c | 10 ++++++---- + base/gslibctx.c | 12 +++++++++++- + base/gslibctx.h | 7 +++++++ + psi/imain.c | 2 ++ + psi/int.mak | 2 +- + psi/zfile.c | 19 +++++++++++++++++++ + psi/zfile.h | 7 +++++++ + 7 files changed, 53 insertions(+), 6 deletions(-) + +diff --git a/base/gsicc_manage.c b/base/gsicc_manage.c +index 931c2a6..e9c09c3 100644 +--- a/base/gsicc_manage.c ++++ b/base/gsicc_manage.c +@@ -1124,10 +1124,12 @@ gsicc_open_search(const char* pname, int namelen, gs_memory_t *mem_gc, + } + + /* First just try it like it is */ +- str = sfopen(pname, "r", mem_gc); +- if (str != NULL) { +- *strp = str; +- return 0; ++ if (gs_check_file_permission(mem_gc, pname, namelen, "r") >= 0) { ++ str = sfopen(pname, "r", mem_gc); ++ if (str != NULL) { ++ *strp = str; ++ return 0; ++ } + } + + /* If that fails, try %rom% */ /* FIXME: Not sure this is needed or correct */ +diff --git a/base/gslibctx.c b/base/gslibctx.c +index fa4432a..f2c13e3 100644 +--- a/base/gslibctx.c ++++ b/base/gslibctx.c +@@ -183,7 +183,7 @@ int gs_lib_ctx_init( gs_memory_t *mem ) + mem->gs_lib_ctx = NULL; + return -1; + } +- ++ pio->client_check_file_permission = NULL; + gp_get_realtime(pio->real_time_0); + + /* Set scanconverter to 1 (default) */ +@@ -336,3 +336,13 @@ void errflush(const gs_memory_t *mem) + fflush(mem->gs_lib_ctx->fstderr); + /* else nothing to flush */ + } ++ ++int ++gs_check_file_permission (gs_memory_t *mem, const char *fname, const int len, const char *permission) ++{ ++ int code = 0; ++ if (mem->gs_lib_ctx->client_check_file_permission != NULL) { ++ code = mem->gs_lib_ctx->client_check_file_permission(mem, fname, len, permission); ++ } ++ return code; ++} +diff --git a/base/gslibctx.h b/base/gslibctx.h +index 84ec205..55eb4a6 100644 +--- a/base/gslibctx.h ++++ b/base/gslibctx.h +@@ -32,6 +32,9 @@ typedef struct gs_fapi_server_s gs_fapi_server; + # define gs_font_dir_DEFINED + typedef struct gs_font_dir_s gs_font_dir; + #endif ++ ++typedef int (*client_check_file_permission_t) (gs_memory_t *mem, const char *fname, const int len, const char *permission); ++ + typedef struct gs_lib_ctx_s + { + gs_memory_t *memory; /* mem->gs_lib_ctx->memory == mem */ +@@ -61,6 +64,7 @@ typedef struct gs_lib_ctx_s + struct gx_io_device_s **io_device_table; + int io_device_table_count; + int io_device_table_size; ++ client_check_file_permission_t client_check_file_permission; + /* Define the default value of AccurateScreens that affects setscreen + and setcolorscreen. */ + bool screen_accurate_screens; +@@ -132,6 +136,9 @@ int + gs_lib_ctx_get_default_device_list(const gs_memory_t *mem, char** dev_list_str, + int *list_str_len); + ++int ++gs_check_file_permission (gs_memory_t *mem, const char *fname, const int len, const char *permission); ++ + #define IS_LIBCTX_STDOUT(mem, f) (f == mem->gs_lib_ctx->fstdout) + #define IS_LIBCTX_STDERR(mem, f) (f == mem->gs_lib_ctx->fstderr) + +diff --git a/psi/imain.c b/psi/imain.c +index 9a9bb5d..6874128 100644 +--- a/psi/imain.c ++++ b/psi/imain.c +@@ -57,6 +57,7 @@ + #include "ivmspace.h" + #include "idisp.h" /* for setting display device callback */ + #include "iplugin.h" ++#include "zfile.h" + + #ifdef PACIFY_VALGRIND + #include "valgrind.h" +@@ -212,6 +213,7 @@ gs_main_init1(gs_main_instance * minst) + "the_gs_name_table"); + if (code < 0) + return code; ++ mem->gs_lib_ctx->client_check_file_permission = z_check_file_permissions; + } + code = obj_init(&minst->i_ctx_p, &idmem); /* requires name_init */ + if (code < 0) +diff --git a/psi/int.mak b/psi/int.mak +index 4654afc..bb30d51 100644 +--- a/psi/int.mak ++++ b/psi/int.mak +@@ -2024,7 +2024,7 @@ $(PSOBJ)imain.$(OBJ) : $(PSSRC)imain.c $(GH) $(memory__h) $(string__h)\ + $(ialloc_h) $(iconf_h) $(idebug_h) $(idict_h) $(idisp_h) $(iinit_h)\ + $(iname_h) $(interp_h) $(iplugin_h) $(isave_h) $(iscan_h) $(ivmspace_h)\ + $(iinit_h) $(main_h) $(oper_h) $(ostack_h)\ +- $(sfilter_h) $(store_h) $(stream_h) $(strimpl_h)\ ++ $(sfilter_h) $(store_h) $(stream_h) $(strimpl_h) $(zfile_h)\ + $(INT_MAK) $(MAKEDIRS) + $(PSCC) $(PSO_)imain.$(OBJ) $(C_) $(PSSRC)imain.c + +diff --git a/psi/zfile.c b/psi/zfile.c +index b6caea2..fd94f67 100644 +--- a/psi/zfile.c ++++ b/psi/zfile.c +@@ -197,6 +197,25 @@ check_file_permissions(i_ctx_t *i_ctx_p, const char *fname, int len, + return check_file_permissions_reduced(i_ctx_p, fname_reduced, rlen, permitgroup); + } + ++/* z_check_file_permissions: see zfile.h for explanation ++ */ ++int ++z_check_file_permissions(gs_memory_t *mem, const char *fname, const int len, const char *permission) ++{ ++ i_ctx_t *i_ctx_p = get_minst_from_memory(mem)->i_ctx_p; ++ gs_parsed_file_name_t pname; ++ const char *permitgroup = permission[0] == 'r' ? "PermitFileReading" : "PermitFileWriting"; ++ int code = gs_parse_file_name(&pname, fname, len, imemory); ++ if (code < 0) ++ return code; ++ ++ if (pname.iodev && i_ctx_p->LockFilePermissions && strcmp(pname.iodev->dname, "%pipe%") == 0) ++ return gs_error_invalidfileaccess; ++ ++ code = check_file_permissions(i_ctx_p, fname, len, permitgroup); ++ return code; ++} ++ + /* file */ + int /* exported for zsysvm.c */ + zfile(i_ctx_t *i_ctx_p) +diff --git a/psi/zfile.h b/psi/zfile.h +index fdf1373..a9399c7 100644 +--- a/psi/zfile.h ++++ b/psi/zfile.h +@@ -22,4 +22,11 @@ + int zopen_file(i_ctx_t *i_ctx_p, const gs_parsed_file_name_t *pfn, + const char *file_access, stream **ps, gs_memory_t *mem); + ++/* z_check_file_permissions: a callback (via mem->gs_lib_ctx->client_check_file_permission) ++ * to allow applying the above permissions checks when opening file(s) from ++ * the graphics library ++ */ ++int ++z_check_file_permissions(gs_memory_t *mem, const char *fname, ++ const int len, const char *permission); + #endif +-- +2.7.4 \ No newline at end of file diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-7977.patch b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-7977.patch new file mode 100644 index 0000000000..176ba9e72d --- /dev/null +++ b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-7977.patch @@ -0,0 +1,28 @@ +From 8abd22010eb4db0fb1b10e430d5f5d83e015ef70 Mon Sep 17 00:00:00 2001 +From: Chris Liddell +Date: Mon, 3 Oct 2016 01:46:28 +0100 +Subject: [PATCH] Bug 697169: Be rigorous with SAFER permissions + +Once we've opened our input file from the command line, enforce the SAFER +rules. +--- + psi/zfile.c | 3 +++ + 1 file changed, 3 insertions(+) + +diff --git a/psi/zfile.c b/psi/zfile.c +index b6caea2..2c6c958 100644 +--- a/psi/zfile.c ++++ b/psi/zfile.c +@@ -1081,6 +1081,9 @@ lib_file_open(gs_file_path_ptr lib_path, const gs_memory_t *mem, i_ctx_t *i_ctx + gs_main_instance *minst = get_minst_from_memory(mem); + int code; + ++ if (i_ctx_p && starting_arg_file) ++ i_ctx_p->starting_arg_file = false; ++ + /* when starting arg files (@ files) iodev_default is not yet set */ + if (iodev == 0) + iodev = (gx_io_device *)gx_io_device_table[0]; +-- +2.7.4 + diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-7978.patch b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-7978.patch new file mode 100644 index 0000000000..477f85052e --- /dev/null +++ b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-7978.patch @@ -0,0 +1,24 @@ +From 6f749c0c44e7b9e09737b9f29edf29925a34f0cf Mon Sep 17 00:00:00 2001 +From: Chris Liddell +Date: Wed, 5 Oct 2016 09:59:25 +0100 +Subject: [PATCH] Bug 697179: Reference count device icc profile + +when copying a device +--- + base/gsdevice.c | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/base/gsdevice.c b/base/gsdevice.c +index 778106f..aea986a 100644 +--- a/base/gsdevice.c ++++ b/base/gsdevice.c +@@ -614,6 +614,7 @@ gx_device_init(gx_device * dev, const gx_device * proto, gs_memory_t * mem, + dev->memory = mem; + dev->retained = !internal; + rc_init(dev, mem, (internal ? 0 : 1)); ++ rc_increment(dev->icc_struct); + } + + void +-- +2.7.4 \ No newline at end of file diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-7979.patch b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-7979.patch new file mode 100644 index 0000000000..95c6b11e17 --- /dev/null +++ b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-7979.patch @@ -0,0 +1,42 @@ +From 875a0095f37626a721c7ff57d606a0f95af03913 Mon Sep 17 00:00:00 2001 +From: Ken Sharp +Date: Wed, 5 Oct 2016 10:10:58 +0100 +Subject: [PATCH] DSC parser - validate parameters + +Bug #697190 ".initialize_dsc_parser doesn't validate the parameter is a dict type before using it." + +Regardless of any security implications, its simply wrong for a PostScript +operator not to validate its parameter(s). + +No differences expected. +--- + psi/zdscpars.c | 13 +++++++++---- + 1 file changed, 9 insertions(+), 4 deletions(-) + +diff --git a/psi/zdscpars.c b/psi/zdscpars.c +index c05e154..9b4b605 100644 +--- a/psi/zdscpars.c ++++ b/psi/zdscpars.c +@@ -150,11 +150,16 @@ zinitialize_dsc_parser(i_ctx_t *i_ctx_p) + ref local_ref; + int code; + os_ptr const op = osp; +- dict * const pdict = op->value.pdict; +- gs_memory_t * const mem = (gs_memory_t *)dict_memory(pdict); +- dsc_data_t * const data = +- gs_alloc_struct(mem, dsc_data_t, &st_dsc_data_t, "DSC parser init"); ++ dict *pdict; ++ gs_memory_t *mem; ++ dsc_data_t *data; + ++ check_read_type(*op, t_dictionary); ++ ++ pdict = op->value.pdict; ++ mem = (gs_memory_t *)dict_memory(pdict); ++ ++ data = gs_alloc_struct(mem, dsc_data_t, &st_dsc_data_t, "DSC parser init"); + if (!data) + return_error(gs_error_VMerror); + data->document_level = 0; +-- +2.7.4 \ No newline at end of file diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-8602.patch b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-8602.patch new file mode 100644 index 0000000000..280a5ab261 --- /dev/null +++ b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-8602.patch @@ -0,0 +1,41 @@ +From f5c7555c30393e64ec1f5ab0dfae5b55b3b3fc78 Mon Sep 17 00:00:00 2001 +From: Chris Liddell +Date: Sat, 8 Oct 2016 16:10:27 +0100 +Subject: [PATCH] Bug 697203: check for sufficient params in .sethalftone5 + +and param types +--- + psi/zht2.c | 12 ++++++++++-- + 1 file changed, 10 insertions(+), 2 deletions(-) + +diff --git a/psi/zht2.c b/psi/zht2.c +index fb4a264..dfa27a4 100644 +--- a/psi/zht2.c ++++ b/psi/zht2.c +@@ -82,14 +82,22 @@ zsethalftone5(i_ctx_t *i_ctx_p) + gs_memory_t *mem; + uint edepth = ref_stack_count(&e_stack); + int npop = 2; +- int dict_enum = dict_first(op); ++ int dict_enum; + ref rvalue[2]; + int cname, colorant_number; + byte * pname; + uint name_size; + int halftonetype, type = 0; + gs_gstate *pgs = igs; +- int space_index = r_space_index(op - 1); ++ int space_index; ++ ++ if (ref_stack_count(&o_stack) < 2) ++ return_error(gs_error_stackunderflow); ++ check_type(*op, t_dictionary); ++ check_type(*(op - 1), t_dictionary); ++ ++ dict_enum = dict_first(op); ++ space_index = r_space_index(op - 1); + + mem = (gs_memory_t *) idmemory->spaces_indexed[space_index]; + +-- +2.7.4 diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-9601.patch b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-9601.patch new file mode 100644 index 0000000000..0f756ded54 --- /dev/null +++ b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-cve-2016-9601.patch @@ -0,0 +1,896 @@ +From cecf6b592945d247bf932f6a4f50065db4acfba8 Mon Sep 17 00:00:00 2001 +From: Robin Watts +Date: Mon, 12 Dec 2016 17:47:17 +0000 +Subject: [PATCH] Squash signed/unsigned warnings in MSVC jbig2 build. + +Also rename "new" to "new_dict", because "new" is a bad +variable name. +--- + jbig2dec/jbig2.c | 4 +-- + jbig2dec/jbig2.h | 8 +++-- + jbig2dec/jbig2_generic.c | 2 +- + jbig2dec/jbig2_halftone.c | 24 +++++++-------- + jbig2dec/jbig2_huffman.c | 10 +++--- + jbig2dec/jbig2_huffman.h | 2 +- + jbig2dec/jbig2_image.c | 32 +++++++++---------- + jbig2dec/jbig2_mmr.c | 66 ++++++++++++++++++++------------------- + jbig2dec/jbig2_page.c | 6 ++-- + jbig2dec/jbig2_priv.h | 4 +-- + jbig2dec/jbig2_segment.c | 10 +++--- + jbig2dec/jbig2_symbol_dict.c | 73 ++++++++++++++++++++++---------------------- + jbig2dec/jbig2_symbol_dict.h | 6 ++-- + jbig2dec/jbig2_text.c | 16 +++++----- + jbig2dec/jbig2_text.h | 2 +- + 15 files changed, 134 insertions(+), 131 deletions(-) + +diff --git a/jbig2dec/jbig2.c b/jbig2dec/jbig2.c +index f729e29..e51380f 100644 +--- a/jbig2dec/jbig2.c ++++ b/jbig2dec/jbig2.c +@@ -379,7 +379,7 @@ typedef struct { + } Jbig2WordStreamBuf; + + static int +-jbig2_word_stream_buf_get_next_word(Jbig2WordStream *self, int offset, uint32_t *word) ++jbig2_word_stream_buf_get_next_word(Jbig2WordStream *self, size_t offset, uint32_t *word) + { + Jbig2WordStreamBuf *z = (Jbig2WordStreamBuf *) self; + const byte *data = z->data; +@@ -390,7 +390,7 @@ jbig2_word_stream_buf_get_next_word(Jbig2WordStream *self, int offset, uint32_t + else if (offset > z->size) + return -1; + else { +- int i; ++ size_t i; + + result = 0; + for (i = 0; i < z->size - offset; i++) +diff --git a/jbig2dec/jbig2.h b/jbig2dec/jbig2.h +index d5aa52f..624e0ed 100644 +--- a/jbig2dec/jbig2.h ++++ b/jbig2dec/jbig2.h +@@ -56,17 +56,19 @@ typedef struct _Jbig2SymbolDictionary Jbig2SymbolDictionary; + */ + + struct _Jbig2Image { +- int width, height, stride; ++ uint32_t width; ++ uint32_t height; ++ uint32_t stride; + uint8_t *data; + int refcount; + }; + +-Jbig2Image *jbig2_image_new(Jbig2Ctx *ctx, int width, int height); ++Jbig2Image *jbig2_image_new(Jbig2Ctx *ctx, uint32_t width, uint32_t height); + Jbig2Image *jbig2_image_clone(Jbig2Ctx *ctx, Jbig2Image *image); + void jbig2_image_release(Jbig2Ctx *ctx, Jbig2Image *image); + void jbig2_image_free(Jbig2Ctx *ctx, Jbig2Image *image); + void jbig2_image_clear(Jbig2Ctx *ctx, Jbig2Image *image, int value); +-Jbig2Image *jbig2_image_resize(Jbig2Ctx *ctx, Jbig2Image *image, int width, int height); ++Jbig2Image *jbig2_image_resize(Jbig2Ctx *ctx, Jbig2Image *image, uint32_t width, uint32_t height); + + /* errors are returned from the library via a callback. If no callback + is provided (a NULL argument is passed ot jbig2_ctx_new) a default +diff --git a/jbig2dec/jbig2_generic.c b/jbig2dec/jbig2_generic.c +index 02fdbfb..9656198 100644 +--- a/jbig2dec/jbig2_generic.c ++++ b/jbig2dec/jbig2_generic.c +@@ -718,7 +718,7 @@ jbig2_immediate_generic_region(Jbig2Ctx *ctx, Jbig2Segment *segment, const byte + byte seg_flags; + int8_t gbat[8]; + int offset; +- int gbat_bytes = 0; ++ uint32_t gbat_bytes = 0; + Jbig2GenericRegionParams params; + int code = 0; + Jbig2Image *image = NULL; +diff --git a/jbig2dec/jbig2_halftone.c b/jbig2dec/jbig2_halftone.c +index aeab576..acfbc56 100644 +--- a/jbig2dec/jbig2_halftone.c ++++ b/jbig2dec/jbig2_halftone.c +@@ -257,8 +257,8 @@ jbig2_decode_gray_scale_image(Jbig2Ctx *ctx, Jbig2Segment *segment, + { + uint8_t **GSVALS = NULL; + size_t consumed_bytes = 0; +- int i, j, code, stride; +- int x, y; ++ uint32_t i, j, stride, x, y; ++ int code; + Jbig2Image **GSPLANES; + Jbig2GenericRegionParams rparams; + Jbig2WordStream *ws = NULL; +@@ -276,9 +276,8 @@ jbig2_decode_gray_scale_image(Jbig2Ctx *ctx, Jbig2Segment *segment, + if (GSPLANES[i] == NULL) { + jbig2_error(ctx, JBIG2_SEVERITY_FATAL, segment->number, "failed to allocate %dx%d image for GSPLANES", GSW, GSH); + /* free already allocated */ +- for (j = i - 1; j >= 0; --j) { +- jbig2_image_release(ctx, GSPLANES[j]); +- } ++ for (j = i; j > 0;) ++ jbig2_image_release(ctx, GSPLANES[--j]); + jbig2_free(ctx->allocator, GSPLANES); + return NULL; + } +@@ -323,9 +322,10 @@ jbig2_decode_gray_scale_image(Jbig2Ctx *ctx, Jbig2Segment *segment, + } + + /* C.5 step 2. Set j = GSBPP-2 */ +- j = GSBPP - 2; ++ j = GSBPP - 1; + /* C.5 step 3. decode loop */ +- while (j >= 0) { ++ while (j > 0) { ++ j--; + /* C.5 step 3. (a) */ + if (GSMMR) { + code = jbig2_decode_halftone_mmr(ctx, &rparams, data + consumed_bytes, size - consumed_bytes, GSPLANES[j], &consumed_bytes); +@@ -345,7 +345,6 @@ jbig2_decode_gray_scale_image(Jbig2Ctx *ctx, Jbig2Segment *segment, + GSPLANES[j]->data[i] ^= GSPLANES[j + 1]->data[i]; + + /* C.5 step 3. (c) */ +- --j; + } + + /* allocate GSVALS */ +@@ -359,9 +358,8 @@ jbig2_decode_gray_scale_image(Jbig2Ctx *ctx, Jbig2Segment *segment, + if (GSVALS[i] == NULL) { + jbig2_error(ctx, JBIG2_SEVERITY_FATAL, segment->number, "failed to allocate GSVALS: %d bytes", GSH * GSW); + /* free already allocated */ +- for (j = i - 1; j >= 0; --j) { +- jbig2_free(ctx->allocator, GSVALS[j]); +- } ++ for (j = i; j > 0;) ++ jbig2_free(ctx->allocator, GSVALS[--j]); + jbig2_free(ctx->allocator, GSVALS); + GSVALS = NULL; + goto cleanup; +@@ -450,7 +448,7 @@ jbig2_decode_halftone_region(Jbig2Ctx *ctx, Jbig2Segment *segment, + uint8_t **GI; + Jbig2Image *HSKIP = NULL; + Jbig2PatternDict *HPATS; +- int i; ++ uint32_t i; + uint32_t mg, ng; + int32_t x, y; + uint8_t gray_val; +@@ -476,7 +474,7 @@ jbig2_decode_halftone_region(Jbig2Ctx *ctx, Jbig2Segment *segment, + + /* calculate ceil(log2(HNUMPATS)) */ + HBPP = 0; +- while (HNUMPATS > (1 << ++HBPP)); ++ while (HNUMPATS > (1U << ++HBPP)); + + /* 6.6.5 point 4. decode gray-scale image as mentioned in annex C */ + GI = jbig2_decode_gray_scale_image(ctx, segment, data, size, +diff --git a/jbig2dec/jbig2_huffman.c b/jbig2dec/jbig2_huffman.c +index 4521b48..f77981b 100644 +--- a/jbig2dec/jbig2_huffman.c ++++ b/jbig2dec/jbig2_huffman.c +@@ -47,16 +47,16 @@ struct _Jbig2HuffmanState { + is (offset + 4) * 8. */ + uint32_t this_word; + uint32_t next_word; +- int offset_bits; +- int offset; +- int offset_limit; ++ uint32_t offset_bits; ++ uint32_t offset; ++ uint32_t offset_limit; + + Jbig2WordStream *ws; + Jbig2Ctx *ctx; + }; + + static uint32_t +-huff_get_next_word(Jbig2HuffmanState *hs, int offset) ++huff_get_next_word(Jbig2HuffmanState *hs, uint32_t offset) + { + uint32_t word = 0; + Jbig2WordStream *ws = hs->ws; +@@ -213,7 +213,7 @@ jbig2_huffman_advance(Jbig2HuffmanState *hs, int offset) + /* return the offset of the huffman decode pointer (in bytes) + * from the beginning of the WordStream + */ +-int ++uint32_t + jbig2_huffman_offset(Jbig2HuffmanState *hs) + { + return hs->offset + (hs->offset_bits >> 3); +diff --git a/jbig2dec/jbig2_huffman.h b/jbig2dec/jbig2_huffman.h +index 5d1e6e0..cfda9e0 100644 +--- a/jbig2dec/jbig2_huffman.h ++++ b/jbig2dec/jbig2_huffman.h +@@ -64,7 +64,7 @@ void jbig2_huffman_skip(Jbig2HuffmanState *hs); + + void jbig2_huffman_advance(Jbig2HuffmanState *hs, int offset); + +-int jbig2_huffman_offset(Jbig2HuffmanState *hs); ++uint32_t jbig2_huffman_offset(Jbig2HuffmanState *hs); + + int32_t jbig2_huffman_get(Jbig2HuffmanState *hs, const Jbig2HuffmanTable *table, bool *oob); + +diff --git a/jbig2dec/jbig2_image.c b/jbig2dec/jbig2_image.c +index 1ae614e..94e5a4c 100644 +--- a/jbig2dec/jbig2_image.c ++++ b/jbig2dec/jbig2_image.c +@@ -32,10 +32,10 @@ + + /* allocate a Jbig2Image structure and its associated bitmap */ + Jbig2Image * +-jbig2_image_new(Jbig2Ctx *ctx, int width, int height) ++jbig2_image_new(Jbig2Ctx *ctx, uint32_t width, uint32_t height) + { + Jbig2Image *image; +- int stride; ++ uint32_t stride; + int64_t check; + + image = jbig2_new(ctx, Jbig2Image, 1); +@@ -99,7 +99,7 @@ jbig2_image_free(Jbig2Ctx *ctx, Jbig2Image *image) + + /* resize a Jbig2Image */ + Jbig2Image * +-jbig2_image_resize(Jbig2Ctx *ctx, Jbig2Image *image, int width, int height) ++jbig2_image_resize(Jbig2Ctx *ctx, Jbig2Image *image, uint32_t width, uint32_t height) + { + if (width == image->width) { + /* check for integer multiplication overflow */ +@@ -133,11 +133,11 @@ jbig2_image_resize(Jbig2Ctx *ctx, Jbig2Image *image, int width, int height) + static int + jbig2_image_compose_unopt(Jbig2Ctx *ctx, Jbig2Image *dst, Jbig2Image *src, int x, int y, Jbig2ComposeOp op) + { +- int i, j; +- int sw = src->width; +- int sh = src->height; +- int sx = 0; +- int sy = 0; ++ uint32_t i, j; ++ uint32_t sw = src->width; ++ uint32_t sh = src->height; ++ uint32_t sx = 0; ++ uint32_t sy = 0; + + /* clip to the dst image boundaries */ + if (x < 0) { +@@ -200,10 +200,10 @@ jbig2_image_compose_unopt(Jbig2Ctx *ctx, Jbig2Image *dst, Jbig2Image *src, int x + int + jbig2_image_compose(Jbig2Ctx *ctx, Jbig2Image *dst, Jbig2Image *src, int x, int y, Jbig2ComposeOp op) + { +- int i, j; +- int w, h; +- int leftbyte, rightbyte; +- int shift; ++ uint32_t i, j; ++ uint32_t w, h; ++ uint32_t leftbyte, rightbyte; ++ uint32_t shift; + uint8_t *s, *ss; + uint8_t *d, *dd; + uint8_t mask, rightmask; +@@ -226,8 +226,8 @@ jbig2_image_compose(Jbig2Ctx *ctx, Jbig2Image *dst, Jbig2Image *src, int x, int + h += y; + y = 0; + } +- w = (x + w < dst->width) ? w : dst->width - x; +- h = (y + h < dst->height) ? h : dst->height - y; ++ w = ((uint32_t)x + w < dst->width) ? w : ((dst->width >= (uint32_t)x) ? dst->width - (uint32_t)x : 0); ++ h = ((uint32_t)y + h < dst->height) ? h : ((dst->height >= (uint32_t)y) ? dst->height - (uint32_t)y : 0); + #ifdef JBIG2_DEBUG + jbig2_error(ctx, JBIG2_SEVERITY_DEBUG, -1, "compositing %dx%d at (%d, %d) after clipping\n", w, h, x, y); + #endif +@@ -249,8 +249,8 @@ jbig2_image_compose(Jbig2Ctx *ctx, Jbig2Image *dst, Jbig2Image *src, int x, int + } + #endif + +- leftbyte = x >> 3; +- rightbyte = (x + w - 1) >> 3; ++ leftbyte = (uint32_t)x >> 3; ++ rightbyte = ((uint32_t)x + w - 1) >> 3; + shift = x & 7; + + /* general OR case */ +diff --git a/jbig2dec/jbig2_mmr.c b/jbig2dec/jbig2_mmr.c +index d4cd3a2..390e27c 100644 +--- a/jbig2dec/jbig2_mmr.c ++++ b/jbig2dec/jbig2_mmr.c +@@ -38,19 +38,21 @@ + #include "jbig2_mmr.h" + + typedef struct { +- int width; +- int height; ++ uint32_t width; ++ uint32_t height; + const byte *data; + size_t size; +- int data_index; +- int bit_index; ++ uint32_t data_index; ++ uint32_t bit_index; + uint32_t word; + } Jbig2MmrCtx; + ++#define MINUS1 ((uint32_t)-1) ++ + static void + jbig2_decode_mmr_init(Jbig2MmrCtx *mmr, int width, int height, const byte *data, size_t size) + { +- int i; ++ size_t i; + uint32_t word = 0; + + mmr->width = width; +@@ -732,14 +734,14 @@ const mmr_table_node jbig2_mmr_black_decode[] = { + #define getbit(buf, x) ( ( buf[x >> 3] >> ( 7 - (x & 7) ) ) & 1 ) + + static int +-jbig2_find_changing_element(const byte *line, int x, int w) ++jbig2_find_changing_element(const byte *line, uint32_t x, uint32_t w) + { + int a, b; + + if (line == 0) +- return w; ++ return (int)w; + +- if (x == -1) { ++ if (x == MINUS1) { + a = 0; + x = 0; + } else { +@@ -758,7 +760,7 @@ jbig2_find_changing_element(const byte *line, int x, int w) + } + + static int +-jbig2_find_changing_element_of_color(const byte *line, int x, int w, int color) ++jbig2_find_changing_element_of_color(const byte *line, uint32_t x, uint32_t w, int color) + { + if (line == 0) + return w; +@@ -772,9 +774,9 @@ static const byte lm[8] = { 0xFF, 0x7F, 0x3F, 0x1F, 0x0F, 0x07, 0x03, 0x01 }; + static const byte rm[8] = { 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE }; + + static void +-jbig2_set_bits(byte *line, int x0, int x1) ++jbig2_set_bits(byte *line, uint32_t x0, uint32_t x1) + { +- int a0, a1, b0, b1, a; ++ uint32_t a0, a1, b0, b1, a; + + a0 = x0 >> 3; + a1 = x1 >> 3; +@@ -831,8 +833,8 @@ jbig2_decode_get_run(Jbig2MmrCtx *mmr, const mmr_table_node *table, int initial_ + static int + jbig2_decode_mmr_line(Jbig2MmrCtx *mmr, const byte *ref, byte *dst) + { +- int a0 = -1; +- int a1, a2, b1, b2; ++ uint32_t a0 = MINUS1; ++ uint32_t a1, a2, b1, b2; + int c = 0; /* 0 is white, black is 1 */ + + while (1) { +@@ -840,7 +842,7 @@ jbig2_decode_mmr_line(Jbig2MmrCtx *mmr, const byte *ref, byte *dst) + + /* printf ("%08x\n", word); */ + +- if (a0 >= mmr->width) ++ if (a0 != MINUS1 && a0 >= mmr->width) + break; + + if ((word >> (32 - 3)) == 1) { +@@ -848,7 +850,7 @@ jbig2_decode_mmr_line(Jbig2MmrCtx *mmr, const byte *ref, byte *dst) + + jbig2_decode_mmr_consume(mmr, 3); + +- if (a0 == -1) ++ if (a0 == MINUS1) + a0 = 0; + + if (c == 0) { +@@ -860,7 +862,7 @@ jbig2_decode_mmr_line(Jbig2MmrCtx *mmr, const byte *ref, byte *dst) + a1 = mmr->width; + if (a2 > mmr->width) + a2 = mmr->width; +- if (a2 < a1 || a1 < 0) ++ if (a1 == MINUS1 || a2 < a1) + return -1; + jbig2_set_bits(dst, a1, a2); + a0 = a2; +@@ -874,7 +876,7 @@ jbig2_decode_mmr_line(Jbig2MmrCtx *mmr, const byte *ref, byte *dst) + a1 = mmr->width; + if (a2 > mmr->width) + a2 = mmr->width; +- if (a1 < a0 || a0 < 0) ++ if (a0 == MINUS1 || a1 < a0) + return -1; + jbig2_set_bits(dst, a0, a1); + a0 = a2; +@@ -888,7 +890,7 @@ jbig2_decode_mmr_line(Jbig2MmrCtx *mmr, const byte *ref, byte *dst) + b1 = jbig2_find_changing_element_of_color(ref, a0, mmr->width, !c); + b2 = jbig2_find_changing_element(ref, b1, mmr->width); + if (c) { +- if (b2 < a0 || a0 < 0) ++ if (a0 == MINUS1 || b2 < a0) + return -1; + jbig2_set_bits(dst, a0, b2); + } +@@ -900,7 +902,7 @@ jbig2_decode_mmr_line(Jbig2MmrCtx *mmr, const byte *ref, byte *dst) + jbig2_decode_mmr_consume(mmr, 1); + b1 = jbig2_find_changing_element_of_color(ref, a0, mmr->width, !c); + if (c) { +- if (b1 < a0 || a0 < 0) ++ if (a0 == MINUS1 || b1 < a0) + return -1; + jbig2_set_bits(dst, a0, b1); + } +@@ -915,7 +917,7 @@ jbig2_decode_mmr_line(Jbig2MmrCtx *mmr, const byte *ref, byte *dst) + if (b1 + 1 > mmr->width) + break; + if (c) { +- if (b1 + 1 < a0 || a0 < 0) ++ if (a0 == MINUS1 || b1 + 1 < a0) + return -1; + jbig2_set_bits(dst, a0, b1 + 1); + } +@@ -930,7 +932,7 @@ jbig2_decode_mmr_line(Jbig2MmrCtx *mmr, const byte *ref, byte *dst) + if (b1 + 2 > mmr->width) + break; + if (c) { +- if (b1 + 2 < a0 || a0 < 0) ++ if (a0 == MINUS1 || b1 + 2 < a0) + return -1; + jbig2_set_bits(dst, a0, b1 + 2); + } +@@ -942,10 +944,10 @@ jbig2_decode_mmr_line(Jbig2MmrCtx *mmr, const byte *ref, byte *dst) + /* printf ("VR(3)\n"); */ + jbig2_decode_mmr_consume(mmr, 7); + b1 = jbig2_find_changing_element_of_color(ref, a0, mmr->width, !c); +- if (b1 + 3 > mmr->width) ++ if (b1 + 3 > (int)mmr->width) + break; + if (c) { +- if (b1 + 3 < a0 || a0 < 0) ++ if (a0 == MINUS1 || b1 + 3 < a0) + return -1; + jbig2_set_bits(dst, a0, b1 + 3); + } +@@ -957,10 +959,10 @@ jbig2_decode_mmr_line(Jbig2MmrCtx *mmr, const byte *ref, byte *dst) + /* printf ("VL(1)\n"); */ + jbig2_decode_mmr_consume(mmr, 3); + b1 = jbig2_find_changing_element_of_color(ref, a0, mmr->width, !c); +- if (b1 - 1 < 0) ++ if (b1 < 1) + break; + if (c) { +- if (b1 - 1 < a0 || a0 < 0) ++ if (a0 == MINUS1 || b1 - 1 < a0) + return -1; + jbig2_set_bits(dst, a0, b1 - 1); + } +@@ -972,7 +974,7 @@ jbig2_decode_mmr_line(Jbig2MmrCtx *mmr, const byte *ref, byte *dst) + /* printf ("VL(2)\n"); */ + jbig2_decode_mmr_consume(mmr, 6); + b1 = jbig2_find_changing_element_of_color(ref, a0, mmr->width, !c); +- if (b1 - 2 < 0) ++ if (b1 < 2) + break; + if (c) { + if (b1 - 2 < a0 || a0 < 0) +@@ -987,10 +989,10 @@ jbig2_decode_mmr_line(Jbig2MmrCtx *mmr, const byte *ref, byte *dst) + /* printf ("VL(3)\n"); */ + jbig2_decode_mmr_consume(mmr, 7); + b1 = jbig2_find_changing_element_of_color(ref, a0, mmr->width, !c); +- if (b1 - 3 < 0) ++ if (b1 < 3) + break; + if (c) { +- if (b1 - 3 < a0 || a0 < 0) ++ if (a0 == MINUS1 || b1 - 3 < a0) + return -1; + jbig2_set_bits(dst, a0, b1 - 3); + } +@@ -1009,10 +1011,10 @@ int + jbig2_decode_generic_mmr(Jbig2Ctx *ctx, Jbig2Segment *segment, const Jbig2GenericRegionParams *params, const byte *data, size_t size, Jbig2Image *image) + { + Jbig2MmrCtx mmr; +- const int rowstride = image->stride; ++ const uint32_t rowstride = image->stride; + byte *dst = image->data; + byte *ref = NULL; +- int y; ++ uint32_t y; + int code = 0; + + jbig2_decode_mmr_init(&mmr, image->width, image->height, data, size); +@@ -1047,10 +1049,10 @@ int + jbig2_decode_halftone_mmr(Jbig2Ctx *ctx, const Jbig2GenericRegionParams *params, const byte *data, size_t size, Jbig2Image *image, size_t *consumed_bytes) + { + Jbig2MmrCtx mmr; +- const int rowstride = image->stride; ++ const uint32_t rowstride = image->stride; + byte *dst = image->data; + byte *ref = NULL; +- int y; ++ uint32_t y; + int code = 0; + const uint32_t EOFB = 0x001001; + +diff --git a/jbig2dec/jbig2_page.c b/jbig2dec/jbig2_page.c +index 110ff7c..1ed1c8a 100644 +--- a/jbig2dec/jbig2_page.c ++++ b/jbig2dec/jbig2_page.c +@@ -155,9 +155,9 @@ int + jbig2_end_of_stripe(Jbig2Ctx *ctx, Jbig2Segment *segment, const uint8_t *segment_data) + { + Jbig2Page page = ctx->pages[ctx->current_page]; +- int end_row; ++ uint32_t end_row; + +- end_row = jbig2_get_int32(segment_data); ++ end_row = jbig2_get_uint32(segment_data); + if (end_row < page.end_row) { + jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, + "end of stripe segment with non-positive end row advance" " (new end row %d vs current end row %d)", end_row, page.end_row); +@@ -248,7 +248,7 @@ jbig2_page_add_result(Jbig2Ctx *ctx, Jbig2Page *page, Jbig2Image *image, int x, + + /* grow the page to accomodate a new stripe if necessary */ + if (page->striped) { +- int new_height = y + image->height + page->end_row; ++ uint32_t new_height = y + image->height + page->end_row; + + if (page->image->height < new_height) { + jbig2_error(ctx, JBIG2_SEVERITY_DEBUG, -1, "growing page buffer to %d rows " "to accomodate new stripe", new_height); +diff --git a/jbig2dec/jbig2_priv.h b/jbig2dec/jbig2_priv.h +index 42ba496..3d44b42 100644 +--- a/jbig2dec/jbig2_priv.h ++++ b/jbig2dec/jbig2_priv.h +@@ -132,7 +132,7 @@ struct _Jbig2Page { + uint32_t x_resolution, y_resolution; /* in pixels per meter */ + uint16_t stripe_size; + bool striped; +- int end_row; ++ uint32_t end_row; + uint8_t flags; + Jbig2Image *image; + }; +@@ -182,7 +182,7 @@ int jbig2_halftone_region(Jbig2Ctx *ctx, Jbig2Segment *segment, const byte *segm + typedef struct _Jbig2WordStream Jbig2WordStream; + + struct _Jbig2WordStream { +- int (*get_next_word)(Jbig2WordStream *self, int offset, uint32_t *word); ++ int (*get_next_word)(Jbig2WordStream *self, size_t offset, uint32_t *word); + }; + + Jbig2WordStream *jbig2_word_stream_buf_new(Jbig2Ctx *ctx, const byte *data, size_t size); +diff --git a/jbig2dec/jbig2_segment.c b/jbig2dec/jbig2_segment.c +index 2e0db67..5b63706 100644 +--- a/jbig2dec/jbig2_segment.c ++++ b/jbig2dec/jbig2_segment.c +@@ -39,10 +39,10 @@ jbig2_parse_segment_header(Jbig2Ctx *ctx, uint8_t *buf, size_t buf_size, size_t + uint8_t rtscarf; + uint32_t rtscarf_long; + uint32_t *referred_to_segments; +- int referred_to_segment_count; +- int referred_to_segment_size; +- int pa_size; +- int offset; ++ uint32_t referred_to_segment_count; ++ uint32_t referred_to_segment_size; ++ uint32_t pa_size; ++ uint32_t offset; + + /* minimum possible size of a jbig2 segment header */ + if (buf_size < 11) +@@ -83,7 +83,7 @@ jbig2_parse_segment_header(Jbig2Ctx *ctx, uint8_t *buf, size_t buf_size, size_t + + /* 7.2.5 */ + if (referred_to_segment_count) { +- int i; ++ uint32_t i; + + referred_to_segments = jbig2_new(ctx, uint32_t, referred_to_segment_count * referred_to_segment_size); + if (referred_to_segments == NULL) { +diff --git a/jbig2dec/jbig2_symbol_dict.c b/jbig2dec/jbig2_symbol_dict.c +index 2c71a4c..11a2252 100644 +--- a/jbig2dec/jbig2_symbol_dict.c ++++ b/jbig2dec/jbig2_symbol_dict.c +@@ -88,40 +88,40 @@ jbig2_dump_symbol_dict(Jbig2Ctx *ctx, Jbig2Segment *segment) + + /* return a new empty symbol dict */ + Jbig2SymbolDict * +-jbig2_sd_new(Jbig2Ctx *ctx, int n_symbols) ++jbig2_sd_new(Jbig2Ctx *ctx, uint32_t n_symbols) + { +- Jbig2SymbolDict *new = NULL; ++ Jbig2SymbolDict *new_dict = NULL; + + if (n_symbols < 0) { + jbig2_error(ctx, JBIG2_SEVERITY_FATAL, -1, "Negative number of symbols in symbol dict: %d", n_symbols); + return NULL; + } + +- new = jbig2_new(ctx, Jbig2SymbolDict, 1); +- if (new != NULL) { +- new->glyphs = jbig2_new(ctx, Jbig2Image *, n_symbols); +- new->n_symbols = n_symbols; ++ new_dict = jbig2_new(ctx, Jbig2SymbolDict, 1); ++ if (new_dict != NULL) { ++ new_dict->glyphs = jbig2_new(ctx, Jbig2Image *, n_symbols); ++ new_dict->n_symbols = n_symbols; + } else { + jbig2_error(ctx, JBIG2_SEVERITY_FATAL, -1, "unable to allocate new empty symbol dict"); + return NULL; + } + +- if (new->glyphs != NULL) { +- memset(new->glyphs, 0, n_symbols * sizeof(Jbig2Image *)); ++ if (new_dict->glyphs != NULL) { ++ memset(new_dict->glyphs, 0, n_symbols * sizeof(Jbig2Image *)); + } else { + jbig2_error(ctx, JBIG2_SEVERITY_FATAL, -1, "unable to allocate glyphs for new empty symbol dict"); +- jbig2_free(ctx->allocator, new); ++ jbig2_free(ctx->allocator, new_dict); + return NULL; + } + +- return new; ++ return new_dict; + } + + /* release the memory associated with a symbol dict */ + void + jbig2_sd_release(Jbig2Ctx *ctx, Jbig2SymbolDict *dict) + { +- int i; ++ uint32_t i; + + if (dict == NULL) + return; +@@ -142,12 +142,12 @@ jbig2_sd_glyph(Jbig2SymbolDict *dict, unsigned int id) + } + + /* count the number of dictionary segments referred to by the given segment */ +-int ++uint32_t + jbig2_sd_count_referred(Jbig2Ctx *ctx, Jbig2Segment *segment) + { + int index; + Jbig2Segment *rsegment; +- int n_dicts = 0; ++ uint32_t n_dicts = 0; + + for (index = 0; index < segment->referred_to_segment_count; index++) { + rsegment = jbig2_find_segment(ctx, segment->referred_to_segments[index]); +@@ -166,8 +166,8 @@ jbig2_sd_list_referred(Jbig2Ctx *ctx, Jbig2Segment *segment) + int index; + Jbig2Segment *rsegment; + Jbig2SymbolDict **dicts; +- int n_dicts = jbig2_sd_count_referred(ctx, segment); +- int dindex = 0; ++ uint32_t n_dicts = jbig2_sd_count_referred(ctx, segment); ++ uint32_t dindex = 0; + + dicts = jbig2_new(ctx, Jbig2SymbolDict *, n_dicts); + if (dicts == NULL) { +@@ -195,10 +195,10 @@ jbig2_sd_list_referred(Jbig2Ctx *ctx, Jbig2Segment *segment) + /* generate a new symbol dictionary by concatenating a list of + existing dictionaries */ + Jbig2SymbolDict * +-jbig2_sd_cat(Jbig2Ctx *ctx, int n_dicts, Jbig2SymbolDict **dicts) ++jbig2_sd_cat(Jbig2Ctx *ctx, uint32_t n_dicts, Jbig2SymbolDict **dicts) + { +- int i, j, k, symbols; +- Jbig2SymbolDict *new = NULL; ++ uint32_t i, j, k, symbols; ++ Jbig2SymbolDict *new_dict = NULL; + + /* count the imported symbols and allocate a new array */ + symbols = 0; +@@ -206,17 +206,17 @@ jbig2_sd_cat(Jbig2Ctx *ctx, int n_dicts, Jbig2SymbolDict **dicts) + symbols += dicts[i]->n_symbols; + + /* fill a new array with cloned glyph pointers */ +- new = jbig2_sd_new(ctx, symbols); +- if (new != NULL) { ++ new_dict = jbig2_sd_new(ctx, symbols); ++ if (new_dict != NULL) { + k = 0; + for (i = 0; i < n_dicts; i++) + for (j = 0; j < dicts[i]->n_symbols; j++) +- new->glyphs[k++] = jbig2_image_clone(ctx, dicts[i]->glyphs[j]); ++ new_dict->glyphs[k++] = jbig2_image_clone(ctx, dicts[i]->glyphs[j]); + } else { + jbig2_error(ctx, JBIG2_SEVERITY_WARNING, -1, "failed to allocate new symbol dictionary"); + } + +- return new; ++ return new_dict; + } + + /* Decoding routines */ +@@ -431,7 +431,7 @@ jbig2_decode_symbol_dict(Jbig2Ctx *ctx, + + if (REFAGGNINST > 1) { + Jbig2Image *image; +- int i; ++ uint32_t i; + + if (tparams == NULL) { + /* First time through, we need to initialise the */ +@@ -512,7 +512,7 @@ jbig2_decode_symbol_dict(Jbig2Ctx *ctx, + uint32_t ID; + int32_t RDX, RDY; + int BMSIZE = 0; +- int ninsyms = params->SDNUMINSYMS; ++ uint32_t ninsyms = params->SDNUMINSYMS; + int code1 = 0; + int code2 = 0; + int code3 = 0; +@@ -609,8 +609,9 @@ jbig2_decode_symbol_dict(Jbig2Ctx *ctx, + if (params->SDHUFF && !params->SDREFAGG) { + /* 6.5.9 */ + Jbig2Image *image; +- int BMSIZE = jbig2_huffman_get(hs, params->SDHUFFBMSIZE, &code); +- int j, x; ++ uint32_t BMSIZE = jbig2_huffman_get(hs, params->SDHUFFBMSIZE, &code); ++ uint32_t j; ++ int x; + + if (code || (BMSIZE < 0)) { + jbig2_error(ctx, JBIG2_SEVERITY_FATAL, segment->number, "error decoding size of collective bitmap!"); +@@ -700,22 +701,22 @@ jbig2_decode_symbol_dict(Jbig2Ctx *ctx, + jbig2_error(ctx, JBIG2_SEVERITY_FATAL, segment->number, "failed to allocate symbols exported from symbols dictionary"); + goto cleanup4; + } else { +- int i = 0; +- int j = 0; +- int k; ++ uint32_t i = 0; ++ uint32_t j = 0; ++ uint32_t k; + int exflag = 0; +- int64_t limit = params->SDNUMINSYMS + params->SDNUMNEWSYMS; +- int32_t exrunlength; ++ uint32_t limit = params->SDNUMINSYMS + params->SDNUMNEWSYMS; ++ uint32_t exrunlength; + int zerolength = 0; + + while (i < limit) { + if (params->SDHUFF) + exrunlength = jbig2_huffman_get(hs, SBHUFFRSIZE, &code); + else +- code = jbig2_arith_int_decode(IAEX, as, &exrunlength); ++ code = jbig2_arith_int_decode(IAEX, as, (int32_t *)&exrunlength); + /* prevent infinite loop */ + zerolength = exrunlength > 0 ? 0 : zerolength + 1; +- if (code || (exrunlength > limit - i) || (exrunlength < 0) || (zerolength > 4) || (exflag && (exrunlength > params->SDNUMEXSYMS - j))) { ++ if (code || (exrunlength > limit - i) || (exrunlength < 0) || (zerolength > 4) || (exflag && (exrunlength + j > params->SDNUMEXSYMS))) { + if (code) + jbig2_error(ctx, JBIG2_SEVERITY_FATAL, segment->number, "failed to decode exrunlength for exported symbols"); + else if (exrunlength <= 0) +@@ -797,8 +798,8 @@ jbig2_symbol_dictionary(Jbig2Ctx *ctx, Jbig2Segment *segment, const byte *segmen + { + Jbig2SymbolDictParams params; + uint16_t flags; +- int sdat_bytes; +- int offset; ++ uint32_t sdat_bytes; ++ uint32_t offset; + Jbig2ArithCx *GB_stats = NULL; + Jbig2ArithCx *GR_stats = NULL; + int table_index = 0; +@@ -951,7 +952,7 @@ jbig2_symbol_dictionary(Jbig2Ctx *ctx, Jbig2Segment *segment, const byte *segmen + + /* 7.4.2.2 (2) */ + { +- int n_dicts = jbig2_sd_count_referred(ctx, segment); ++ uint32_t n_dicts = jbig2_sd_count_referred(ctx, segment); + Jbig2SymbolDict **dicts = NULL; + + if (n_dicts > 0) { +diff --git a/jbig2dec/jbig2_symbol_dict.h b/jbig2dec/jbig2_symbol_dict.h +index d56d62d..30211d4 100644 +--- a/jbig2dec/jbig2_symbol_dict.h ++++ b/jbig2dec/jbig2_symbol_dict.h +@@ -32,18 +32,18 @@ int jbig2_symbol_dictionary(Jbig2Ctx *ctx, Jbig2Segment *segment, const byte *se + Jbig2Image *jbig2_sd_glyph(Jbig2SymbolDict *dict, unsigned int id); + + /* return a new empty symbol dict */ +-Jbig2SymbolDict *jbig2_sd_new(Jbig2Ctx *ctx, int n_symbols); ++Jbig2SymbolDict *jbig2_sd_new(Jbig2Ctx *ctx, uint32_t n_symbols); + + /* release the memory associated with a symbol dict */ + void jbig2_sd_release(Jbig2Ctx *ctx, Jbig2SymbolDict *dict); + + /* generate a new symbol dictionary by concatenating a list of + existing dictionaries */ +-Jbig2SymbolDict *jbig2_sd_cat(Jbig2Ctx *ctx, int n_dicts, Jbig2SymbolDict **dicts); ++Jbig2SymbolDict *jbig2_sd_cat(Jbig2Ctx *ctx, uint32_t n_dicts, Jbig2SymbolDict **dicts); + + /* count the number of dictionary segments referred + to by the given segment */ +-int jbig2_sd_count_referred(Jbig2Ctx *ctx, Jbig2Segment *segment); ++uint32_t jbig2_sd_count_referred(Jbig2Ctx *ctx, Jbig2Segment *segment); + + /* return an array of pointers to symbol dictionaries referred + to by a segment */ +diff --git a/jbig2dec/jbig2_text.c b/jbig2dec/jbig2_text.c +index 5c99640..e77460f 100644 +--- a/jbig2dec/jbig2_text.c ++++ b/jbig2dec/jbig2_text.c +@@ -55,7 +55,7 @@ + int + jbig2_decode_text_region(Jbig2Ctx *ctx, Jbig2Segment *segment, + const Jbig2TextRegionParams *params, +- const Jbig2SymbolDict *const *dicts, const int n_dicts, ++ const Jbig2SymbolDict *const *dicts, const uint32_t n_dicts, + Jbig2Image *image, const byte *data, const size_t size, Jbig2ArithCx *GR_stats, Jbig2ArithState *as, Jbig2WordStream *ws) + { + /* relevent bits of 6.4.4 */ +@@ -476,19 +476,19 @@ cleanup2: + int + jbig2_text_region(Jbig2Ctx *ctx, Jbig2Segment *segment, const byte *segment_data) + { +- int offset = 0; ++ uint32_t offset = 0; + Jbig2RegionSegmentInfo region_info; + Jbig2TextRegionParams params; + Jbig2Image *image = NULL; + Jbig2SymbolDict **dicts = NULL; +- int n_dicts = 0; ++ uint32_t n_dicts = 0; + uint16_t flags = 0; + uint16_t huffman_flags = 0; + Jbig2ArithCx *GR_stats = NULL; + int code = 0; + Jbig2WordStream *ws = NULL; + Jbig2ArithState *as = NULL; +- int table_index = 0; ++ uint32_t table_index = 0; + const Jbig2HuffmanParams *huffman_params = NULL; + + /* 7.4.1 */ +@@ -779,7 +779,7 @@ jbig2_text_region(Jbig2Ctx *ctx, Jbig2Segment *segment, const byte *segment_data + code = jbig2_error(ctx, JBIG2_SEVERITY_FATAL, segment->number, "unable to retrive symbol dictionaries! previous parsing error?"); + goto cleanup1; + } else { +- int index; ++ uint32_t index; + + if (dicts[0] == NULL) { + code = jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "unable to find first referenced symbol dictionary!"); +@@ -823,8 +823,8 @@ jbig2_text_region(Jbig2Ctx *ctx, Jbig2Segment *segment, const byte *segment_data + } + + if (!params.SBHUFF) { +- int SBSYMCODELEN, index; +- int SBNUMSYMS = 0; ++ uint32_t SBSYMCODELEN, index; ++ uint32_t SBNUMSYMS = 0; + + for (index = 0; index < n_dicts; index++) { + SBNUMSYMS += dicts[index]->n_symbols; +@@ -840,7 +840,7 @@ jbig2_text_region(Jbig2Ctx *ctx, Jbig2Segment *segment, const byte *segment_data + } + + /* Table 31 */ +- for (SBSYMCODELEN = 0; (1 << SBSYMCODELEN) < SBNUMSYMS; SBSYMCODELEN++) { ++ for (SBSYMCODELEN = 0; (1U << SBSYMCODELEN) < SBNUMSYMS; SBSYMCODELEN++) { + } + params.IAID = jbig2_arith_iaid_ctx_new(ctx, SBSYMCODELEN); + params.IARI = jbig2_arith_int_ctx_new(ctx); +diff --git a/jbig2dec/jbig2_text.h b/jbig2dec/jbig2_text.h +index aec2732..51d242e 100644 +--- a/jbig2dec/jbig2_text.h ++++ b/jbig2dec/jbig2_text.h +@@ -70,5 +70,5 @@ typedef struct { + int + jbig2_decode_text_region(Jbig2Ctx *ctx, Jbig2Segment *segment, + const Jbig2TextRegionParams *params, +- const Jbig2SymbolDict *const *dicts, const int n_dicts, ++ const Jbig2SymbolDict *const *dicts, const uint32_t n_dicts, + Jbig2Image *image, const byte *data, const size_t size, Jbig2ArithCx *GR_stats, Jbig2ArithState *as, Jbig2WordStream *ws); +-- +2.9.3 \ No newline at end of file diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-9.20-fix-openjpeg-system-build.patch b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-fix-openjpeg-system-build.patch new file mode 100644 index 0000000000..3c990e67ef --- /dev/null +++ b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-fix-openjpeg-system-build.patch @@ -0,0 +1,55 @@ +From 99cf218dbd5f6fbdbda2ce6872eb9ab7f475c353 Mon Sep 17 00:00:00 2001 +From: Chris Liddell +Date: Tue, 27 Sep 2016 11:22:18 +0100 +Subject: [PATCH 1/2] Add pre-processor define for shared OpenJPEG + +--- + Makefile.in | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/Makefile.in b/Makefile.in +index 25875ad..2ca2a80 100644 +--- a/Makefile.in ++++ b/Makefile.in +@@ -290,7 +290,7 @@ JBIG2_CFLAGS=@JBIG2_AUTOCONF_CFLAGS@ + JPX_LIB=@JPX_DECODER@ + SHARE_JPX=@SHARE_JPX@ + JPXSRCDIR=@JPXDIR@ +-JPX_CFLAGS=@JPX_AUTOCONF_CFLAGS@ @JPX_SSE_CFLAGS@ ++JPX_CFLAGS=-DSHARE_JPX=$(SHARE_JPX) @JPX_AUTOCONF_CFLAGS@ @JPX_SSE_CFLAGS@ + + # uncomment the following three lines and one of the last two to + # compile in the Luratech lwf_jp2 codec +-- +2.7.4 + + +From 4f19ab99cac2d8a7d21aea34d8aea0727fad52d3 Mon Sep 17 00:00:00 2001 +From: Didier Raboud +Date: Thu, 6 Oct 2016 17:08:41 +0200 +Subject: [PATCH 2/2] Don't pass -DOPJ_STATIC when compiling the OpenJPEG code. + + It makes the symbols hidden when including + /usr/include/openjpeg-2.1/openjpeg.h. + Fixes a FTBFS against libopenjp2-7 (>= 2.1.1). + + Debian bug: https://bugs.debian.org/832873 +--- + base/lib.mak | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/base/lib.mak b/base/lib.mak +index 173e2c6..cffdc9d 100644 +--- a/base/lib.mak ++++ b/base/lib.mak +@@ -1849,7 +1849,7 @@ $(GLOBJ)sjpx_openjpeg.$(OBJ) : $(GLSRC)sjpx_openjpeg.c $(AK) \ + $(memory__h) $(gserror_h) $(gserrors_h) \ + $(gdebug_h) $(strimpl_h) $(sjpx_openjpeg_h) $(LIB_MAK) $(MAKEDIRS) + $(GLJPXOPJCC) $(GLO_)sjpx_openjpeg.$(OBJ) \ +- $(C_) -DOPJ_STATIC $(GLSRC)sjpx_openjpeg.c ++ $(C_) $(GLSRC)sjpx_openjpeg.c + + # ---------------- Pixel-difference filters ---------------- # + # The Predictor facility of the LZW and Flate filters uses these. +-- +2.7.4 \ No newline at end of file diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-9.20-handle-glyphdirectory-correctly.patch b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-handle-glyphdirectory-correctly.patch new file mode 100644 index 0000000000..c181ac2553 --- /dev/null +++ b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-handle-glyphdirectory-correctly.patch @@ -0,0 +1,51 @@ +From 329e0a6d187cc5b5698689d76636ed3214d7efa7 Mon Sep 17 00:00:00 2001 +From: Chris Liddell +Date: Thu, 3 Nov 2016 13:09:27 +0000 +Subject: [PATCH] Bug 697286: handle GlyphDirectory as an array + +For high level devices that need to copy CIDFonts, we need to establish the +highest CID in a given CIDFont. If the font has a GlyphDirectory dictionary +the only way to do so is to iterate through the keys to find the highest. + +The code handling this ignored that the GlyphDirectory could be an array, +which confused the dictionary content iterator, and caused a segfault. + +In the case of an array, set the high CID to the highest index available in the +array. +--- + psi/zfcid.c | 18 +++++++++++------- + 1 file changed, 11 insertions(+), 7 deletions(-) + +diff --git a/psi/zfcid.c b/psi/zfcid.c +index ce583af..3098a22 100644 +--- a/psi/zfcid.c ++++ b/psi/zfcid.c +@@ -76,15 +76,19 @@ cid_font_data_param(os_ptr op, gs_font_cid_data *pdata, ref *pGlyphDirectory) + * the number of CIDs in the font. We need to know the maximum CID + * when copying fonts, so calculate and store it now. + */ +- index = dict_first(pgdir); +- while (index >= 0) { +- index = dict_next(pgdir, index, (ref *)&element); +- if (index >= 0) { +- if (element[0].value.intval > pdata->MaxCID) +- pdata->MaxCID = element[0].value.intval; ++ if (r_has_type(pgdir, t_dictionary)) { ++ index = dict_first(pgdir); ++ while (index >= 0) { ++ index = dict_next(pgdir, index, (ref *)&element); ++ if (index >= 0) { ++ if (element[0].value.intval > pdata->MaxCID) ++ pdata->MaxCID = element[0].value.intval; ++ } + } + } +- ++ else { ++ pdata->MaxCID = r_size(pgdir) - 1; ++ } + return code; + } else { + return_error(gs_error_typecheck); +-- +2.7.4 diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-9.20-remove-and-reimplement-ConvertUTF.patch b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-remove-and-reimplement-ConvertUTF.patch new file mode 100644 index 0000000000..d64bd0f48c --- /dev/null +++ b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-remove-and-reimplement-ConvertUTF.patch @@ -0,0 +1,1227 @@ +From 273a133110838ee5702e7eb6409a853c598211b2 Mon Sep 17 00:00:00 2001 +From: Ken Sharp +Date: Thu, 29 Sep 2016 17:35:05 +0100 +Subject: [PATCH] Remove (and re-implement) ConvertUTF.c + +Bug #697122 " embedded ConvertUTF.c is buggy and licensed incompatibly with GPL/APGL" + +Its not clear that this code is incompatible with GPL, nor do we think +any 'bugginess' in the code affects us, since we are using a comparatively +small part of the included code. + +Nevertheless its possible to remove the code, and re-implement the small +part we actually need, and that is done here. + +Also removed the DSCEncodingToUnicode option which was insanely difficult +to use, and incorrectly documented. + +Yhis shows one difference, 692486_-_heap_overflow_in_pdf_to_ucs2.pdf +now correctly throws an error, because the PDF file contains document +information (Application) which has an invalid UTF16-BE sequence. +--- + base/ConvertUTF.c | 539 ----------------------------------------- + base/ConvertUTF.h | 155 ------------ + base/lib.mak | 4 - + devices/devs.mak | 5 +- + devices/vector/gdevpdf.c | 16 +- + devices/vector/gdevpdfb.h | 1 - + devices/vector/gdevpdfe.c | 270 +++++++++++---------- + devices/vector/gdevpdfp.c | 1 - + devices/vector/gdevpdfx.h | 17 +- + windows/ghostscript.vcproj | 8 - + windows/ghostscript_rt.vcxproj | 2 - + 11 files changed, 155 insertions(+), 863 deletions(-) + delete mode 100644 base/ConvertUTF.c + delete mode 100644 base/ConvertUTF.h + +diff --git a/base/ConvertUTF.c b/base/ConvertUTF.c +deleted file mode 100644 +index cb2e2de..0000000 +--- a/base/ConvertUTF.c ++++ /dev/null +@@ -1,539 +0,0 @@ +-/* +- * Copyright 2001-2004 Unicode, Inc. +- * +- * Disclaimer +- * +- * This source code is provided as is by Unicode, Inc. No claims are +- * made as to fitness for any particular purpose. No warranties of any +- * kind are expressed or implied. The recipient agrees to determine +- * applicability of information provided. If this file has been +- * purchased on magnetic or optical media from Unicode, Inc., the +- * sole remedy for any claim will be exchange of defective media +- * within 90 days of receipt. +- * +- * Limitations on Rights to Redistribute This Code +- * +- * Unicode, Inc. hereby grants the right to freely use the information +- * supplied in this file in the creation of products supporting the +- * Unicode Standard, and to make copies of this file in any form +- * for internal or external distribution as long as this notice +- * remains attached. +- */ +- +- +-/* --------------------------------------------------------------------- +- +- Conversions between UTF32, UTF-16, and UTF-8. Source code file. +- Author: Mark E. Davis, 1994. +- Rev History: Rick McGowan, fixes & updates May 2001. +- Sept 2001: fixed const & error conditions per +- mods suggested by S. Parent & A. Lillich. +- June 2002: Tim Dodd added detection and handling of incomplete +- source sequences, enhanced error detection, added casts +- to eliminate compiler warnings. +- July 2003: slight mods to back out aggressive FFFE detection. +- Jan 2004: updated switches in from-UTF8 conversions. +- Oct 2004: updated to use UNI_MAX_LEGAL_UTF32 in UTF-32 conversions. +- +- See the header file "ConvertUTF.h" for complete documentation. +- +------------------------------------------------------------------------- */ +- +-#include "ConvertUTF.h" +-#ifdef CVTUTF_DEBUG +-#include +-#endif +- +-static const int halfShift = 10; /* used for shifting by 10 bits */ +- +-static const UTF32 halfBase = 0x0010000UL; +-static const UTF32 halfMask = 0x3FFUL; +- +-#define UNI_SUR_HIGH_START (UTF32)0xD800 +-#define UNI_SUR_HIGH_END (UTF32)0xDBFF +-#define UNI_SUR_LOW_START (UTF32)0xDC00 +-#define UNI_SUR_LOW_END (UTF32)0xDFFF +-#define false 0 +-#define true 1 +- +-/* --------------------------------------------------------------------- */ +- +-ConversionResult ConvertUTF32toUTF16 ( +- const UTF32** sourceStart, const UTF32* sourceEnd, +- UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) { +- ConversionResult result = conversionOK; +- const UTF32* source = *sourceStart; +- UTF16* target = *targetStart; +- while (source < sourceEnd) { +- UTF32 ch; +- if (target >= targetEnd) { +- result = targetExhausted; break; +- } +- ch = *source++; +- if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */ +- /* UTF-16 surrogate values are illegal in UTF-32; 0xffff or 0xfffe are both reserved values */ +- if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) { +- if (flags == strictConversion) { +- --source; /* return to the illegal value itself */ +- result = sourceIllegal; +- break; +- } else { +- *target++ = UNI_REPLACEMENT_CHAR; +- } +- } else { +- *target++ = (UTF16)ch; /* normal case */ +- } +- } else if (ch > UNI_MAX_LEGAL_UTF32) { +- if (flags == strictConversion) { +- result = sourceIllegal; +- } else { +- *target++ = UNI_REPLACEMENT_CHAR; +- } +- } else { +- /* target is a character in range 0xFFFF - 0x10FFFF. */ +- if (target + 1 >= targetEnd) { +- --source; /* Back up source pointer! */ +- result = targetExhausted; break; +- } +- ch -= halfBase; +- *target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START); +- *target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START); +- } +- } +- *sourceStart = source; +- *targetStart = target; +- return result; +-} +- +-/* --------------------------------------------------------------------- */ +- +-ConversionResult ConvertUTF16toUTF32 ( +- const UTF16** sourceStart, const UTF16* sourceEnd, +- UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) { +- ConversionResult result = conversionOK; +- const UTF16* source = *sourceStart; +- UTF32* target = *targetStart; +- UTF32 ch, ch2; +- while (source < sourceEnd) { +- const UTF16* oldSource = source; /* In case we have to back up because of target overflow. */ +- ch = *source++; +- /* If we have a surrogate pair, convert to UTF32 first. */ +- if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) { +- /* If the 16 bits following the high surrogate are in the source buffer... */ +- if (source < sourceEnd) { +- ch2 = *source; +- /* If it's a low surrogate, convert to UTF32. */ +- if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) { +- ch = ((ch - UNI_SUR_HIGH_START) << halfShift) +- + (ch2 - UNI_SUR_LOW_START) + halfBase; +- ++source; +- } else if (flags == strictConversion) { /* it's an unpaired high surrogate */ +- --source; /* return to the illegal value itself */ +- result = sourceIllegal; +- break; +- } +- } else { /* We don't have the 16 bits following the high surrogate. */ +- --source; /* return to the high surrogate */ +- result = sourceExhausted; +- break; +- } +- } else if (flags == strictConversion) { +- /* UTF-16 surrogate values are illegal in UTF-32 */ +- if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) { +- --source; /* return to the illegal value itself */ +- result = sourceIllegal; +- break; +- } +- } +- if (target >= targetEnd) { +- source = oldSource; /* Back up source pointer! */ +- result = targetExhausted; break; +- } +- *target++ = ch; +- } +- *sourceStart = source; +- *targetStart = target; +-#ifdef CVTUTF_DEBUG +-if (result == sourceIllegal) { +- fprintf(stderr, "ConvertUTF16toUTF32 illegal seq 0x%04x,%04x\n", ch, ch2); +- fflush(stderr); +-} +-#endif +- return result; +-} +- +-/* --------------------------------------------------------------------- */ +- +-/* +- * Index into the table below with the first byte of a UTF-8 sequence to +- * get the number of trailing bytes that are supposed to follow it. +- * Note that *legal* UTF-8 values can't have 4 or 5-bytes. The table is +- * left as-is for anyone who may want to do such conversion, which was +- * allowed in earlier algorithms. +- */ +-static const char trailingBytesForUTF8[256] = { +- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +- 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +- 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 +-}; +- +-/* +- * Magic values subtracted from a buffer value during UTF8 conversion. +- * This table contains as many values as there might be trailing bytes +- * in a UTF-8 sequence. +- */ +-static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL, +- 0x03C82080UL, 0xFA082080UL, 0x82082080UL }; +- +-/* +- * Once the bits are split out into bytes of UTF-8, this is a mask OR-ed +- * into the first byte, depending on how many bytes follow. There are +- * as many entries in this table as there are UTF-8 sequence types. +- * (I.e., one byte sequence, two byte... etc.). Remember that sequencs +- * for *legal* UTF-8 will be 4 or fewer bytes total. +- */ +-static const UTF8 firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC }; +- +-/* --------------------------------------------------------------------- */ +- +-/* The interface converts a whole buffer to avoid function-call overhead. +- * Constants have been gathered. Loops & conditionals have been removed as +- * much as possible for efficiency, in favor of drop-through switches. +- * (See "Note A" at the bottom of the file for equivalent code.) +- * If your compiler supports it, the "isLegalUTF8" call can be turned +- * into an inline function. +- */ +- +-/* --------------------------------------------------------------------- */ +- +-ConversionResult ConvertUTF16toUTF8 ( +- const UTF16** sourceStart, const UTF16* sourceEnd, +- UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) { +- ConversionResult result = conversionOK; +- const UTF16* source = *sourceStart; +- UTF8* target = *targetStart; +- while (source < sourceEnd) { +- UTF32 ch; +- unsigned short bytesToWrite = 0; +- const UTF32 byteMask = 0xBF; +- const UTF32 byteMark = 0x80; +- const UTF16* oldSource = source; /* In case we have to back up because of target overflow. */ +- ch = *source++; +- /* If we have a surrogate pair, convert to UTF32 first. */ +- if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) { +- /* If the 16 bits following the high surrogate are in the source buffer... */ +- if (source < sourceEnd) { +- UTF32 ch2 = *source; +- /* If it's a low surrogate, convert to UTF32. */ +- if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) { +- ch = ((ch - UNI_SUR_HIGH_START) << halfShift) +- + (ch2 - UNI_SUR_LOW_START) + halfBase; +- ++source; +- } else if (flags == strictConversion) { /* it's an unpaired high surrogate */ +- --source; /* return to the illegal value itself */ +- result = sourceIllegal; +- break; +- } +- } else { /* We don't have the 16 bits following the high surrogate. */ +- --source; /* return to the high surrogate */ +- result = sourceExhausted; +- break; +- } +- } else if (flags == strictConversion) { +- /* UTF-16 surrogate values are illegal in UTF-32 */ +- if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) { +- --source; /* return to the illegal value itself */ +- result = sourceIllegal; +- break; +- } +- } +- /* Figure out how many bytes the result will require */ +- if (ch < (UTF32)0x80) { bytesToWrite = 1; +- } else if (ch < (UTF32)0x800) { bytesToWrite = 2; +- } else if (ch < (UTF32)0x10000) { bytesToWrite = 3; +- } else if (ch < (UTF32)0x110000) { bytesToWrite = 4; +- } else { bytesToWrite = 3; +- ch = UNI_REPLACEMENT_CHAR; +- } +- +- target += bytesToWrite; +- if (target > targetEnd) { +- source = oldSource; /* Back up source pointer! */ +- target -= bytesToWrite; result = targetExhausted; break; +- } +- switch (bytesToWrite) { /* note: everything falls through. */ +- case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; +- case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; +- case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; +- case 1: *--target = (UTF8)(ch | firstByteMark[bytesToWrite]); +- } +- target += bytesToWrite; +- } +- *sourceStart = source; +- *targetStart = target; +- return result; +-} +- +-/* --------------------------------------------------------------------- */ +- +-/* +- * Utility routine to tell whether a sequence of bytes is legal UTF-8. +- * This must be called with the length pre-determined by the first byte. +- * If not calling this from ConvertUTF8to*, then the length can be set by: +- * length = trailingBytesForUTF8[*source]+1; +- * and the sequence is illegal right away if there aren't that many bytes +- * available. +- * If presented with a length > 4, this returns false. The Unicode +- * definition of UTF-8 goes up to 4-byte sequences. +- */ +- +-static Boolean isLegalUTF8(const UTF8 *source, int length) { +- UTF8 a; +- const UTF8 *srcptr = source+length; +- switch (length) { +- default: return false; +- /* Everything else falls through when "true"... */ +- case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false; +- case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false; +- case 2: if ((a = (*--srcptr)) > 0xBF) return false; +- +- switch (*source) { +- /* no fall-through in this inner switch */ +- case 0xE0: if (a < 0xA0) return false; break; +- case 0xED: if (a > 0x9F) return false; break; +- case 0xF0: if (a < 0x90) return false; break; +- case 0xF4: if (a > 0x8F) return false; break; +- default: if (a < 0x80) return false; +- } +- +- case 1: if (*source >= 0x80 && *source < 0xC2) return false; +- } +- if (*source > 0xF4) return false; +- return true; +-} +- +-/* --------------------------------------------------------------------- */ +- +-/* +- * Exported function to return whether a UTF-8 sequence is legal or not. +- * This is not used here; it's just exported. +- */ +-Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd) { +- int length = trailingBytesForUTF8[*source]+1; +- if (source+length > sourceEnd) { +- return false; +- } +- return isLegalUTF8(source, length); +-} +- +-/* --------------------------------------------------------------------- */ +- +-ConversionResult ConvertUTF8toUTF16 ( +- const UTF8** sourceStart, const UTF8* sourceEnd, +- UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) { +- ConversionResult result = conversionOK; +- const UTF8* source = *sourceStart; +- UTF16* target = *targetStart; +- while (source < sourceEnd) { +- UTF32 ch = 0; +- unsigned short extraBytesToRead = trailingBytesForUTF8[*source]; +- if (source + extraBytesToRead >= sourceEnd) { +- result = sourceExhausted; break; +- } +- /* Do this check whether lenient or strict */ +- if (! isLegalUTF8(source, extraBytesToRead+1)) { +- result = sourceIllegal; +- break; +- } +- /* +- * The cases all fall through. See "Note A" below. +- */ +- switch (extraBytesToRead) { +- case 5: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */ +- case 4: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */ +- case 3: ch += *source++; ch <<= 6; +- case 2: ch += *source++; ch <<= 6; +- case 1: ch += *source++; ch <<= 6; +- case 0: ch += *source++; +- } +- ch -= offsetsFromUTF8[extraBytesToRead]; +- +- if (target >= targetEnd) { +- source -= (extraBytesToRead+1); /* Back up source pointer! */ +- result = targetExhausted; break; +- } +- if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */ +- /* UTF-16 surrogate values are illegal in UTF-32 */ +- if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) { +- if (flags == strictConversion) { +- source -= (extraBytesToRead+1); /* return to the illegal value itself */ +- result = sourceIllegal; +- break; +- } else { +- *target++ = UNI_REPLACEMENT_CHAR; +- } +- } else { +- *target++ = (UTF16)ch; /* normal case */ +- } +- } else if (ch > UNI_MAX_UTF16) { +- if (flags == strictConversion) { +- result = sourceIllegal; +- source -= (extraBytesToRead+1); /* return to the start */ +- break; /* Bail out; shouldn't continue */ +- } else { +- *target++ = UNI_REPLACEMENT_CHAR; +- } +- } else { +- /* target is a character in range 0xFFFF - 0x10FFFF. */ +- if (target + 1 >= targetEnd) { +- source -= (extraBytesToRead+1); /* Back up source pointer! */ +- result = targetExhausted; break; +- } +- ch -= halfBase; +- *target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START); +- *target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START); +- } +- } +- *sourceStart = source; +- *targetStart = target; +- return result; +-} +- +-/* --------------------------------------------------------------------- */ +- +-ConversionResult ConvertUTF32toUTF8 ( +- const UTF32** sourceStart, const UTF32* sourceEnd, +- UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) { +- ConversionResult result = conversionOK; +- const UTF32* source = *sourceStart; +- UTF8* target = *targetStart; +- while (source < sourceEnd) { +- UTF32 ch; +- unsigned short bytesToWrite = 0; +- const UTF32 byteMask = 0xBF; +- const UTF32 byteMark = 0x80; +- ch = *source++; +- if (flags == strictConversion ) { +- /* UTF-16 surrogate values are illegal in UTF-32 */ +- if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) { +- --source; /* return to the illegal value itself */ +- result = sourceIllegal; +- break; +- } +- } +- /* +- * Figure out how many bytes the result will require. Turn any +- * illegally large UTF32 things (> Plane 17) into replacement chars. +- */ +- if (ch < (UTF32)0x80) { bytesToWrite = 1; +- } else if (ch < (UTF32)0x800) { bytesToWrite = 2; +- } else if (ch < (UTF32)0x10000) { bytesToWrite = 3; +- } else if (ch <= UNI_MAX_LEGAL_UTF32) { bytesToWrite = 4; +- } else { bytesToWrite = 3; +- ch = UNI_REPLACEMENT_CHAR; +- result = sourceIllegal; +- } +- +- target += bytesToWrite; +- if (target > targetEnd) { +- --source; /* Back up source pointer! */ +- target -= bytesToWrite; result = targetExhausted; break; +- } +- switch (bytesToWrite) { /* note: everything falls through. */ +- case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; +- case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; +- case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; +- case 1: *--target = (UTF8) (ch | firstByteMark[bytesToWrite]); +- } +- target += bytesToWrite; +- } +- *sourceStart = source; +- *targetStart = target; +- return result; +-} +- +-/* --------------------------------------------------------------------- */ +- +-ConversionResult ConvertUTF8toUTF32 ( +- const UTF8** sourceStart, const UTF8* sourceEnd, +- UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) { +- ConversionResult result = conversionOK; +- const UTF8* source = *sourceStart; +- UTF32* target = *targetStart; +- while (source < sourceEnd) { +- UTF32 ch = 0; +- unsigned short extraBytesToRead = trailingBytesForUTF8[*source]; +- if (source + extraBytesToRead >= sourceEnd) { +- result = sourceExhausted; break; +- } +- /* Do this check whether lenient or strict */ +- if (! isLegalUTF8(source, extraBytesToRead+1)) { +- result = sourceIllegal; +- break; +- } +- /* +- * The cases all fall through. See "Note A" below. +- */ +- switch (extraBytesToRead) { +- case 5: ch += *source++; ch <<= 6; +- case 4: ch += *source++; ch <<= 6; +- case 3: ch += *source++; ch <<= 6; +- case 2: ch += *source++; ch <<= 6; +- case 1: ch += *source++; ch <<= 6; +- case 0: ch += *source++; +- } +- ch -= offsetsFromUTF8[extraBytesToRead]; +- +- if (target >= targetEnd) { +- source -= (extraBytesToRead+1); /* Back up the source pointer! */ +- result = targetExhausted; break; +- } +- if (ch <= UNI_MAX_LEGAL_UTF32) { +- /* +- * UTF-16 surrogate values are illegal in UTF-32, and anything +- * over Plane 17 (> 0x10FFFF) is illegal. +- */ +- if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) { +- if (flags == strictConversion) { +- source -= (extraBytesToRead+1); /* return to the illegal value itself */ +- result = sourceIllegal; +- break; +- } else { +- *target++ = UNI_REPLACEMENT_CHAR; +- } +- } else { +- *target++ = ch; +- } +- } else { /* i.e., ch > UNI_MAX_LEGAL_UTF32 */ +- result = sourceIllegal; +- *target++ = UNI_REPLACEMENT_CHAR; +- } +- } +- *sourceStart = source; +- *targetStart = target; +- return result; +-} +- +-/* --------------------------------------------------------------------- +- +- Note A. +- The fall-through switches in UTF-8 reading code save a +- temp variable, some decrements & conditionals. The switches +- are equivalent to the following loop: +- { +- int tmpBytesToRead = extraBytesToRead+1; +- do { +- ch += *source++; +- --tmpBytesToRead; +- if (tmpBytesToRead) ch <<= 6; +- } while (tmpBytesToRead > 0); +- } +- In UTF-8 writing code, the switches on "bytesToWrite" are +- similarly unrolled loops. +- +- --------------------------------------------------------------------- */ +diff --git a/base/ConvertUTF.h b/base/ConvertUTF.h +deleted file mode 100644 +index 538bec6..0000000 +--- a/base/ConvertUTF.h ++++ /dev/null +@@ -1,155 +0,0 @@ +-/* +- * Copyright 2001-2004 Unicode, Inc. +- * +- * Disclaimer +- * +- * This source code is provided as is by Unicode, Inc. No claims are +- * made as to fitness for any particular purpose. No warranties of any +- * kind are expressed or implied. The recipient agrees to determine +- * applicability of information provided. If this file has been +- * purchased on magnetic or optical media from Unicode, Inc., the +- * sole remedy for any claim will be exchange of defective media +- * within 90 days of receipt. +- * +- * Limitations on Rights to Redistribute This Code +- * +- * Unicode, Inc. hereby grants the right to freely use the information +- * supplied in this file in the creation of products supporting the +- * Unicode Standard, and to make copies of this file in any form +- * for internal or external distribution as long as this notice +- * remains attached. +- */ +- +- +-#ifndef ConvertUTF_INCLUDED +-#define ConvertUTF_INCLUDED +- +-/* --------------------------------------------------------------------- +- +- Conversions between UTF32, UTF-16, and UTF-8. Header file. +- +- Several funtions are included here, forming a complete set of +- conversions between the three formats. UTF-7 is not included +- here, but is handled in a separate source file. +- +- Each of these routines takes pointers to input buffers and output +- buffers. The input buffers are const. +- +- Each routine converts the text between *sourceStart and sourceEnd, +- putting the result into the buffer between *targetStart and +- targetEnd. Note: the end pointers are *after* the last item: e.g. +- *(sourceEnd - 1) is the last item. +- +- The return result indicates whether the conversion was successful, +- and if not, whether the problem was in the source or target buffers. +- (Only the first encountered problem is indicated.) +- +- After the conversion, *sourceStart and *targetStart are both +- updated to point to the end of last text successfully converted in +- the respective buffers. +- +- Input parameters: +- sourceStart - pointer to a pointer to the source buffer. +- The contents of this are modified on return so that +- it points at the next thing to be converted. +- targetStart - similarly, pointer to pointer to the target buffer. +- sourceEnd, targetEnd - respectively pointers to the ends of the +- two buffers, for overflow checking only. +- +- These conversion functions take a ConversionFlags argument. When this +- flag is set to strict, both irregular sequences and isolated surrogates +- will cause an error. When the flag is set to lenient, both irregular +- sequences and isolated surrogates are converted. +- +- Whether the flag is strict or lenient, all illegal sequences will cause +- an error return. This includes sequences such as: , , +- or in UTF-8, and values above 0x10FFFF in UTF-32. Conformant code +- must check for illegal sequences. +- +- When the flag is set to lenient, characters over 0x10FFFF are converted +- to the replacement character; otherwise (when the flag is set to strict) +- they constitute an error. +- +- Output parameters: +- The value "sourceIllegal" is returned from some routines if the input +- sequence is malformed. When "sourceIllegal" is returned, the source +- value will point to the illegal value that caused the problem. E.g., +- in UTF-8 when a sequence is malformed, it points to the start of the +- malformed sequence. +- +- Author: Mark E. Davis, 1994. +- Rev History: Rick McGowan, fixes & updates May 2001. +- Fixes & updates, Sept 2001. +- +------------------------------------------------------------------------- */ +- +-/* --------------------------------------------------------------------- +- The following 4 definitions are compiler-specific. +- The C standard does not guarantee that wchar_t has at least +- 16 bits, so wchar_t is no less portable than unsigned short! +- All should be unsigned values to avoid sign extension during +- bit mask & shift operations. +------------------------------------------------------------------------- */ +- +-typedef unsigned long UTF32; /* at least 32 bits */ +-typedef unsigned short UTF16; /* at least 16 bits */ +-typedef unsigned char UTF8; /* typically 8 bits */ +-typedef unsigned char Boolean; /* 0 or 1 */ +- +-/* Some fundamental constants */ +-#define UNI_REPLACEMENT_CHAR (UTF32)0x0000FFFD +-#define UNI_MAX_BMP (UTF32)0x0000FFFF +-#define UNI_MAX_UTF16 (UTF32)0x0010FFFF +-#define UNI_MAX_UTF32 (UTF32)0x7FFFFFFF +-#define UNI_MAX_LEGAL_UTF32 (UTF32)0x0010FFFF +- +-typedef enum { +- conversionOK, /* conversion successful */ +- sourceExhausted, /* partial character in source, but hit end */ +- targetExhausted, /* insuff. room in target for conversion */ +- sourceIllegal /* source sequence is illegal/malformed */ +-} ConversionResult; +- +-typedef enum { +- strictConversion = 0, +- lenientConversion +-} ConversionFlags; +- +-/* This is for C++ and does no harm in C */ +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-ConversionResult ConvertUTF8toUTF16 ( +- const UTF8** sourceStart, const UTF8* sourceEnd, +- UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags); +- +-ConversionResult ConvertUTF16toUTF8 ( +- const UTF16** sourceStart, const UTF16* sourceEnd, +- UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags); +- +-ConversionResult ConvertUTF8toUTF32 ( +- const UTF8** sourceStart, const UTF8* sourceEnd, +- UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags); +- +-ConversionResult ConvertUTF32toUTF8 ( +- const UTF32** sourceStart, const UTF32* sourceEnd, +- UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags); +- +-ConversionResult ConvertUTF16toUTF32 ( +- const UTF16** sourceStart, const UTF16* sourceEnd, +- UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags); +- +-ConversionResult ConvertUTF32toUTF16 ( +- const UTF32** sourceStart, const UTF32* sourceEnd, +- UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags); +- +-Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd); +- +-#ifdef __cplusplus +-} +-#endif +- +-/* --------------------------------------------------------------------- */ +- +-#endif /* ConvertUTF_INCLUDED */ +diff --git a/base/lib.mak b/base/lib.mak +index 173e2c6..2de6565 100644 +--- a/base/lib.mak ++++ b/base/lib.mak +@@ -52,7 +52,6 @@ GLLCMS2CC=$(CC) $(LCMS2_CFLAGS) $(CFLAGS) $(I_)$(GLI_) $(II)$(LCMS2SRCDIR)$(D)in + lcms2_h=$(LCMS2SRCDIR)$(D)include$(D)lcms2.h + lcms2_plugin_h=$(LCMS2SRCDIR)$(D)include$(D)lcms2_plugin.h + +-ConvertUTF_h=$(GLSRC)ConvertUTF.h + gdevdcrd_h=$(GLSRC)gdevdcrd.h + gdevpccm_h=$(GLSRC)gdevpccm.h + +@@ -1097,9 +1096,6 @@ $(GLOBJ)gdevpccm.$(OBJ) : $(GLSRC)gdevpccm.c $(AK)\ + $(gx_h) $(gsmatrix_h) $(gxdevice_h) $(gdevpccm_h) $(LIB_MAK) $(MAKEDIRS) + $(GLCC) $(GLO_)gdevpccm.$(OBJ) $(C_) $(GLSRC)gdevpccm.c + +-$(GLOBJ)ConvertUTF.$(OBJ) : $(GLSRC)ConvertUTF.c $(ConvertUTF_h) $(LIB_MAK) $(MAKEDIRS) +- $(GLCC) $(GLO_)ConvertUTF.$(OBJ) $(C_) $(GLSRC)ConvertUTF.c +- + ### Memory devices + + $(GLOBJ)gdevmem.$(OBJ) : $(GLSRC)gdevmem.c $(AK) $(gx_h) $(gserrors_h) \ +diff --git a/devices/devs.mak b/devices/devs.mak +index ea27ab0..51ec363 100644 +--- a/devices/devs.mak ++++ b/devices/devs.mak +@@ -835,9 +835,8 @@ pdfwrite5_=$(DEVOBJ)gdevpdfm.$(OBJ) + pdfwrite6_=$(DEVOBJ)gdevpdfo.$(OBJ) $(DEVOBJ)gdevpdfp.$(OBJ) $(DEVOBJ)gdevpdft.$(OBJ) + pdfwrite7_=$(DEVOBJ)gdevpdfr.$(OBJ) + pdfwrite8_=$(DEVOBJ)gdevpdfu.$(OBJ) $(DEVOBJ)gdevpdfv.$(OBJ) $(DEVOBJ)gdevagl.$(OBJ) +-pdfwrite9_= $(GLOBJ)ConvertUTF.$(OBJ) +-pdfwrite10_=$(DEVOBJ)gsflip.$(OBJ) +-pdfwrite11_=$(DEVOBJ)scantab.$(OBJ) $(DEVOBJ)sfilter2.$(OBJ) ++pdfwrite9_=$(DEVOBJ)gsflip.$(OBJ) ++pdfwrite10_=$(DEVOBJ)scantab.$(OBJ) $(DEVOBJ)sfilter2.$(OBJ) + pdfwrite_=$(pdfwrite1_) $(pdfwrite2_) $(pdfwrite3_) $(pdfwrite4_)\ + $(pdfwrite5_) $(pdfwrite6_) $(pdfwrite7_) $(pdfwrite8_) $(pdfwrite9_)\ + $(pdfwrite10_) $(pdfwrite11_) +diff --git a/devices/vector/gdevpdf.c b/devices/vector/gdevpdf.c +index 2b3186d..20e0ae8 100644 +--- a/devices/vector/gdevpdf.c ++++ b/devices/vector/gdevpdf.c +@@ -111,14 +111,13 @@ ENUM_PTRS_WITH(device_pdfwrite_enum_ptrs, gx_device_pdf *pdev) + ENUM_PTR(32, gx_device_pdf, pres_soft_mask_dict); + ENUM_PTR(33, gx_device_pdf, PDFXTrimBoxToMediaBoxOffset.data); + ENUM_PTR(34, gx_device_pdf, PDFXBleedBoxToTrimBoxOffset.data); +- ENUM_PTR(35, gx_device_pdf, DSCEncodingToUnicode.data); +- ENUM_PTR(36, gx_device_pdf, Identity_ToUnicode_CMaps[0]); +- ENUM_PTR(37, gx_device_pdf, Identity_ToUnicode_CMaps[1]); +- ENUM_PTR(38, gx_device_pdf, vgstack); +- ENUM_PTR(39, gx_device_pdf, outline_levels); +- ENUM_PTR(40, gx_device_pdf, EmbeddedFiles); +- ENUM_PTR(41, gx_device_pdf, pdf_font_dir); +- ENUM_PTR(42, gx_device_pdf, ExtensionMetadata); ++ ENUM_PTR(35, gx_device_pdf, Identity_ToUnicode_CMaps[0]); ++ ENUM_PTR(36, gx_device_pdf, Identity_ToUnicode_CMaps[1]); ++ ENUM_PTR(37, gx_device_pdf, vgstack); ++ ENUM_PTR(38, gx_device_pdf, outline_levels); ++ ENUM_PTR(39, gx_device_pdf, EmbeddedFiles); ++ ENUM_PTR(40, gx_device_pdf, pdf_font_dir); ++ ENUM_PTR(41, gx_device_pdf, ExtensionMetadata); + #define e1(i,elt) ENUM_PARAM_STRING_PTR(i + gx_device_pdf_num_ptrs, gx_device_pdf, elt); + gx_device_pdf_do_param_strings(e1) + #undef e1 +@@ -165,7 +164,6 @@ static RELOC_PTRS_WITH(device_pdfwrite_reloc_ptrs, gx_device_pdf *pdev) + RELOC_PTR(gx_device_pdf, pres_soft_mask_dict); + RELOC_PTR(gx_device_pdf, PDFXTrimBoxToMediaBoxOffset.data); + RELOC_PTR(gx_device_pdf, PDFXBleedBoxToTrimBoxOffset.data); +- RELOC_PTR(gx_device_pdf, DSCEncodingToUnicode.data); + RELOC_PTR(gx_device_pdf, Identity_ToUnicode_CMaps[0]); + RELOC_PTR(gx_device_pdf, Identity_ToUnicode_CMaps[1]); + RELOC_PTR(gx_device_pdf, vgstack); +diff --git a/devices/vector/gdevpdfb.h b/devices/vector/gdevpdfb.h +index 08f18c5..447f0f5 100644 +--- a/devices/vector/gdevpdfb.h ++++ b/devices/vector/gdevpdfb.h +@@ -141,7 +141,6 @@ const gx_device_pdf PDF_DEVICE_IDENT = + 12000, /* MaxClipPathSize */ /* HP LaserJet 1320 hangs with 14000. */ + 256000, /* MaxShadingBitmapSize */ + PDF_DEVICE_MaxInlineImageSize, /* MaxInlineImageSize */ +- {0, 0}, /* DSCEncodingToUnicode */ + {0, 0, 0}, /* OwnerPassword */ + {0, 0, 0}, /* UserPassword */ + 0, /* KeyLength */ +diff --git a/devices/vector/gdevpdfe.c b/devices/vector/gdevpdfe.c +index 1aa1f25..f23a02d 100644 +--- a/devices/vector/gdevpdfe.c ++++ b/devices/vector/gdevpdfe.c +@@ -26,7 +26,6 @@ + #include "gdevpdfx.h" + #include "gdevpdfg.h" + #include "gdevpdfo.h" +-#include "ConvertUTF.h" + + char PDFDocEncodingLookup [92] = { + 0x20, 0x22, 0x20, 0x20, 0x20, 0x21, 0x20, 0x26, +@@ -343,155 +342,162 @@ decode_escape(const byte *data, int data_length, int *index) + return c; /* A wrong escapement sequence. */ + } + +-static int +-pdf_xmp_write_translated(gx_device_pdf *pdev, stream *s, const byte *data, int data_length, +- void(*write)(stream *s, const byte *data, int data_length)) ++/* ++ * Once the bits are split out into bytes of UTF-8, this is a mask OR-ed ++ * into the first byte, depending on how many bytes follow. There are ++ * as many entries in this table as there are UTF-8 sequence types. ++ * (I.e., one byte sequence, two byte... etc.). Remember that sequencs ++ * for *legal* UTF-8 will be 4 or fewer bytes total. ++ */ ++static const char firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC }; ++ ++static int gs_ConvertUTF16(char *UTF16, int UTF16Len, unsigned char **UTF8Start, int UTF8Len) + { +- if (pdev->DSCEncodingToUnicode.data == 0) { +- int i, j=0; +- unsigned char *buf0; ++ int i, bytes = 0; ++ short U16; ++ unsigned char *UTF8 = *UTF8Start; ++ unsigned char *UTF8End = UTF8 + UTF8Len; + +- buf0 = (unsigned char *)gs_alloc_bytes(pdev->memory, data_length * sizeof(unsigned char), +- "pdf_xmp_write_translated"); +- if (buf0 == NULL) +- return_error(gs_error_VMerror); +- for (i = 0; i < data_length; i++) { +- byte c = data[i]; ++ if (fabs(UTF16Len % sizeof(short)) != 0) ++ return gs_note_error(gs_error_rangecheck); ++ ++ for (i=0;i= 0xD800 && U16 <= 0xDBFF) { ++ return gs_note_error(gs_error_rangecheck); + } +- if (buf0[0] != 0xfe || buf0[1] != 0xff) { +- unsigned char *buf1; +- /* We must assume that the information is PDFDocEncoding. In this case +- * we need to convert it into UTF-8. If we just convert it to UTF-16 +- * then we can safely fall through to the code below. +- */ +- /* NB the code below skips the BOM in positions 0 and 1, so we need +- * two extra bytes, to be ignored. +- */ +- buf1 = (unsigned char *)gs_alloc_bytes(pdev->memory, (j * sizeof(UTF16)) + 2, +- "pdf_xmp_write_translated"); +- if (buf1 == NULL) { +- gs_free_object(pdev->memory, buf0, "pdf_xmp_write_translated"); +- return_error(gs_error_VMerror); +- } +- memset(buf1, 0x00, (j * sizeof(UTF16)) + 2); +- for (i = 0; i < j; i++) { +- if (buf0[i] <= 0x7f || buf0[i] >= 0xAE) { +- if (buf0[i] == 0x7f) { +- emprintf1(pdev->memory, "PDFDocEncoding %x cannot be represented in Unicode\n", +- buf0[i]); +- } else +- buf1[(i * 2) + 3] = buf0[i]; ++ if (U16 >= 0xDC00 && U16 <= 0xDFFF) { ++ return gs_note_error(gs_error_rangecheck); ++ } ++ ++ if(U16 < 0x80) { ++ bytes = 1; ++ } else { ++ if (U16 < 0x800) { ++ bytes = 2; ++ } else { ++ if (U16 < 0x10000) { ++ bytes = 3; + } else { +- buf1[(i * 2) + 2] = PDFDocEncodingLookup[(buf0[i] - 0x80) * 2]; +- buf1[(i * 2) + 3] = PDFDocEncodingLookup[((buf0[i] - 0x80) * 2) + 1]; +- if (PDFDocEncodingLookup[((buf0[i] - 0x80) * 2) + 1] == 0x00) +- emprintf1(pdev->memory, "PDFDocEncoding %x cannot be represented in Unicode\n", +- PDFDocEncodingLookup[((buf0[i] - 0x80) * 2) + 1]); ++ if (U16 < 0x111000) { ++ bytes = 4; ++ } else { ++ bytes = 3; ++ U16 = 0xFFFD; ++ } + } + } ++ } ++ if (UTF8 + bytes > UTF8End) ++ return gs_note_error(gs_error_VMerror); ++ ++ /* Write from end to beginning, low bytes first */ ++ UTF8 += bytes; ++ ++ switch(bytes) { ++ case 4: ++ *--UTF8 = (unsigned char)((U16 | 0x80) & 0xBF); ++ U16 >>= 6; ++ case 3: ++ *--UTF8 = (unsigned char)((U16 | 0x80) & 0xBF); ++ U16 >>= 6; ++ case 2: ++ *--UTF8 = (unsigned char)((U16 | 0x80) & 0xBF); ++ U16 >>= 6; ++ case 1: ++ *--UTF8 = (unsigned char)(U16 | firstByteMark[bytes]); ++ break; ++ default: ++ return gs_note_error(gs_error_rangecheck); ++ } ++ ++ /* Move to start of next set */ ++ UTF8 += bytes; ++ } ++ *UTF8Start = UTF8; ++ return 0; ++} ++ ++static int ++pdf_xmp_write_translated(gx_device_pdf *pdev, stream *s, const byte *data, int data_length, ++ void(*write)(stream *s, const byte *data, int data_length)) ++{ ++ int i, j=0; ++ unsigned char *buf0; ++ ++ buf0 = (unsigned char *)gs_alloc_bytes(pdev->memory, data_length * sizeof(unsigned char), ++ "pdf_xmp_write_translated"); ++ if (buf0 == NULL) ++ return_error(gs_error_VMerror); ++ for (i = 0; i < data_length; i++) { ++ byte c = data[i]; ++ ++ if (c == '\\') ++ c = decode_escape(data, data_length, &i); ++ buf0[j] = c; ++ j++; ++ } ++ if (buf0[0] != 0xfe || buf0[1] != 0xff) { ++ unsigned char *buf1; ++ /* We must assume that the information is PDFDocEncoding. In this case ++ * we need to convert it into UTF-8. If we just convert it to UTF-16 ++ * then we can safely fall through to the code below. ++ */ ++ /* NB the code below skips the BOM in positions 0 and 1, so we need ++ * two extra bytes, to be ignored. ++ */ ++ buf1 = (unsigned char *)gs_alloc_bytes(pdev->memory, (j * sizeof(short)) + 2, ++ "pdf_xmp_write_translated"); ++ if (buf1 == NULL) { + gs_free_object(pdev->memory, buf0, "pdf_xmp_write_translated"); +- buf0 = buf1; +- data_length = j = (j * 2) + 2; ++ return_error(gs_error_VMerror); + } +- { +- /* Its a Unicode (UTF-16BE) string, convert to UTF-8 */ +- UTF16 *buf0b, U16; +- UTF8 *buf1, *buf1b; +- +- /* A single UTF-16 (2 bytes) can end up as 4 bytes in UTF-8 */ +- buf1 = (UTF8 *)gs_alloc_bytes(pdev->memory, data_length * 2 * sizeof(unsigned char), +- "pdf_xmp_write_translated"); +- if (buf1 == NULL) { +- gs_free_object(pdev->memory, buf0, "pdf_xmp_write_translated"); +- return_error(gs_error_VMerror); +- } +- buf1b = buf1; +- /* Skip the Byte Order Mark (0xfe 0xff) */ +- buf0b = (UTF16 *)(buf0 + 2); +- /* ConvertUTF16to UTF8 expects a buffer of UTF16s in the local +- * endian-ness, but the data is big-endian. In case this is a little-endian +- * machine, process the buffer from big-endian to whatever is right for this platform. +- */ +- for (i = 2; i < j; i+=2) { +- U16 = (buf0[i] << 8) + buf0[i + 1]; +- *(buf0b++) = U16; +- } +- buf0b = (UTF16 *)(buf0 + 2); +- switch (ConvertUTF16toUTF8((const UTF16**)&buf0b, (UTF16 *)(buf0 + j), +- &buf1b, buf1 + (data_length * 2 * sizeof(unsigned char)), strictConversion)) { +- case conversionOK: +- write(s, buf1, buf1b - buf1); +- gs_free_object(pdev->memory, buf1, "pdf_xmp_write_translated"); +- break; +- case sourceExhausted: +- case targetExhausted: +- case sourceIllegal: +- default: +- gs_free_object(pdev->memory, buf0, "pdf_xmp_write_translated"); +- gs_free_object(pdev->memory, buf1, "pdf_xmp_write_translated"); +- return_error(gs_error_rangecheck); ++ memset(buf1, 0x00, (j * sizeof(short)) + 2); ++ for (i = 0; i < j; i++) { ++ if (buf0[i] <= 0x7f || buf0[i] >= 0xAE) { ++ if (buf0[i] == 0x7f) { ++ emprintf1(pdev->memory, "PDFDocEncoding %x cannot be represented in Unicode\n", ++ buf0[i]); ++ } else ++ buf1[(i * 2) + 3] = buf0[i]; ++ } else { ++ buf1[(i * 2) + 2] = PDFDocEncodingLookup[(buf0[i] - 0x80) * 2]; ++ buf1[(i * 2) + 3] = PDFDocEncodingLookup[((buf0[i] - 0x80) * 2) + 1]; ++ if (PDFDocEncodingLookup[((buf0[i] - 0x80) * 2) + 1] == 0x00) ++ emprintf1(pdev->memory, "PDFDocEncoding %x cannot be represented in Unicode\n", ++ PDFDocEncodingLookup[((buf0[i] - 0x80) * 2) + 1]); + } + } + gs_free_object(pdev->memory, buf0, "pdf_xmp_write_translated"); +- return 0; +- } else { +- UTF16 *buf0; +- const UTF16 *buf0b; +- UTF8 *buf1, *buf1b; +- int i, j = 0; +- +- buf0 = (UTF16 *)gs_alloc_bytes(pdev->memory, data_length * sizeof(UTF16), +- "pdf_xmp_write_translated"); +- if (buf0 == NULL) +- return_error(gs_error_VMerror); +- buf1 = (UTF8 *)gs_alloc_bytes(pdev->memory, data_length * 2, +- "pdf_xmp_write_translated"); ++ buf0 = buf1; ++ data_length = j = (j * 2) + 2; ++ } ++ { ++ /* Its a Unicode (UTF-16BE) string, convert to UTF-8 */ ++ short *buf0b; ++ char *buf1, *buf1b; ++ int code; ++ ++ /* A single UTF-16 (2 bytes) can end up as 4 bytes in UTF-8 */ ++ buf1 = (char *)gs_alloc_bytes(pdev->memory, data_length * 2 * sizeof(unsigned char), ++ "pdf_xmp_write_translated"); + if (buf1 == NULL) { + gs_free_object(pdev->memory, buf0, "pdf_xmp_write_translated"); + return_error(gs_error_VMerror); + } +- buf0b = buf0; + buf1b = buf1; +- for (i = 0; i < data_length; i++) { +- byte c = data[i]; +- int v; +- +- if (c == '\\') +- c = decode_escape(data, data_length, &i); +- if (c > pdev->DSCEncodingToUnicode.size) { +- gs_free_object(pdev->memory, buf0, "pdf_xmp_write_translated"); +- gs_free_object(pdev->memory, buf1, "pdf_xmp_write_translated"); +- return_error(gs_error_rangecheck); +- } +- +- v = pdev->DSCEncodingToUnicode.data[c]; +- if (v == -1) +- v = '?'; /* Arbitrary. */ +- buf0[j] = v; +- j++; +- } +- switch (ConvertUTF16toUTF8(&buf0b, buf0 + j, +- &buf1b, buf1 + data_length * 2, strictConversion)) { +- case conversionOK: +- write(s, buf1, buf1b - buf1); +- break; +- case sourceExhausted: +- case targetExhausted: +- case sourceIllegal: +- default: +- gs_free_object(pdev->memory, buf0, "pdf_xmp_write_translated"); +- gs_free_object(pdev->memory, buf1, "pdf_xmp_write_translated"); +- return_error(gs_error_rangecheck); +- } +- gs_free_object(pdev->memory, buf0, "pdf_xmp_write_translated"); +- gs_free_object(pdev->memory, buf1, "pdf_xmp_write_translated"); +- return 0; ++ /* Skip the Byte Order Mark (0xfe 0xff) */ ++ buf0b = (short *)(buf0 + 2); ++ code = gs_ConvertUTF16((char *)buf0b, j - 2, (unsigned char **)&buf1b, data_length * 2 * sizeof(unsigned char)); ++ if (code < 0) ++ return code; ++ write(s, (const byte *)buf1, buf1b - buf1); + } ++ gs_free_object(pdev->memory, buf0, "pdf_xmp_write_translated"); ++ return 0; + } + + static int +diff --git a/devices/vector/gdevpdfp.c b/devices/vector/gdevpdfp.c +index 0fa07e3..6ebcb0d 100644 +--- a/devices/vector/gdevpdfp.c ++++ b/devices/vector/gdevpdfp.c +@@ -77,7 +77,6 @@ static const gs_param_item_t pdf_param_items[] = { + pi("CompressStreams", gs_param_type_bool, CompressStreams), + pi("PrintStatistics", gs_param_type_bool, PrintStatistics), + pi("MaxInlineImageSize", gs_param_type_long, MaxInlineImageSize), +- pi("DSCEncodingToUnicode", gs_param_type_int_array, DSCEncodingToUnicode), + + /* PDF Encryption */ + pi("OwnerPassword", gs_param_type_string, OwnerPassword), +diff --git a/devices/vector/gdevpdfx.h b/devices/vector/gdevpdfx.h +index 308900a..c436220 100644 +--- a/devices/vector/gdevpdfx.h ++++ b/devices/vector/gdevpdfx.h +@@ -601,7 +601,6 @@ struct gx_device_pdf_s { + a bitmap representation of a shading. + (Bigger shadings to be downsampled). */ + long MaxInlineImageSize; +- gs_param_int_array DSCEncodingToUnicode; + /* Encryption parameters */ + gs_param_string OwnerPassword; + gs_param_string UserPassword; +@@ -911,14 +910,14 @@ struct gx_device_pdf_s { + m(28,sbstack) m(29,substream_Resources) m(30,font3)\ + m(31,accumulating_substream_resource) \ + m(32,pres_soft_mask_dict) m(33,PDFXTrimBoxToMediaBoxOffset.data)\ +- m(34,PDFXBleedBoxToTrimBoxOffset.data) m(35, DSCEncodingToUnicode.data)\ +- m(36,Identity_ToUnicode_CMaps[0]) m(37,Identity_ToUnicode_CMaps[1])\ +- m(38,vgstack)\ +- m(39, outline_levels) +- m(40, gx_device_pdf, EmbeddedFiles); +- m(41, gx_device_pdf, pdf_font_dir); +- m(42, gx_device_pdf, Extension_Metadata);*/ +-#define gx_device_pdf_num_ptrs 43 ++ m(34,PDFXBleedBoxToTrimBoxOffset.data) ++ m(35,Identity_ToUnicode_CMaps[0]) m(36,Identity_ToUnicode_CMaps[1])\ ++ m(37,vgstack)\ ++ m(38, outline_levels) ++ m(39, gx_device_pdf, EmbeddedFiles); ++ m(40, gx_device_pdf, pdf_font_dir); ++ m(41, gx_device_pdf, Extension_Metadata);*/ ++#define gx_device_pdf_num_ptrs 42 + #define gx_device_pdf_do_param_strings(m)\ + m(0, OwnerPassword) m(1, UserPassword) m(2, NoEncrypt)\ + m(3, DocumentUUID) m(4, InstanceUUID) +diff --git a/windows/ghostscript.vcproj b/windows/ghostscript.vcproj +index a96d317..450cb26 100644 +--- a/windows/ghostscript.vcproj ++++ b/windows/ghostscript.vcproj +@@ -1794,10 +1794,6 @@ + > + + +- +- + +@@ -3330,10 +3326,6 @@ + > + + +- +- + +diff --git a/windows/ghostscript_rt.vcxproj b/windows/ghostscript_rt.vcxproj +index 2348f08..fae2e1f 100644 +--- a/windows/ghostscript_rt.vcxproj ++++ b/windows/ghostscript_rt.vcxproj +@@ -427,7 +427,6 @@ + + + +- + + + +@@ -1689,7 +1688,6 @@ + + + +- + + + +-- +2.9.3 \ No newline at end of file diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-scripts.patch b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-run-dvipdf-securely.patch similarity index 54% rename from office/postscript/ghostscript/files/fedora/ghostscript-scripts.patch rename to office/postscript/ghostscript/files/fedora/ghostscript-9.20-run-dvipdf-securely.patch index 2f050c26ab..9b010e31f2 100644 --- a/office/postscript/ghostscript/files/fedora/ghostscript-scripts.patch +++ b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-run-dvipdf-securely.patch @@ -1,10 +1,21 @@ -diff -up ghostscript-9.00/lib/dvipdf.scripts ghostscript-9.00/lib/dvipdf ---- ghostscript-9.00/lib/dvipdf.scripts 2010-06-03 01:32:07.000000000 +0100 -+++ ghostscript-9.00/lib/dvipdf 2010-09-23 09:56:35.592796899 +0100 -@@ -44,4 +44,4 @@ fi +From 32d8df77bf3326f708c13d6913547c01ce6d728c Mon Sep 17 00:00:00 2001 +From: "David Kaspar [Dee'Kej]" +Date: Fri, 7 Oct 2016 13:57:01 +0200 +Subject: [PATCH] Make sure 'dvipdf' is being run securely + +--- + lib/dvipdf | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/lib/dvipdf b/lib/dvipdf +index 802aeab..c92dfb0 100755 +--- a/lib/dvipdf ++++ b/lib/dvipdf +@@ -43,4 +43,4 @@ fi # We have to include the options twice because -I only takes effect if it # appears before other options. -exec dvips -Ppdf $DVIPSOPTIONS -q -f "$infile" | $GS_EXECUTABLE $OPTIONS -q -P- -dSAFER -dNOPAUSE -dBATCH -sDEVICE=pdfwrite -sstdout=%stderr -sOutputFile="$outfile" $OPTIONS -c .setpdfwrite - +exec dvips -R -Ppdf $DVIPSOPTIONS -q -f "$infile" | $GS_EXECUTABLE $OPTIONS -q -P- -dSAFER -dNOPAUSE -dBATCH -sDEVICE=pdfwrite -sstdout=%stderr -sOutputFile="$outfile" $OPTIONS -c .setpdfwrite - - +-- +2.7.4 \ No newline at end of file diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-9.20-runlibfileifexists.patch b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-runlibfileifexists.patch new file mode 100644 index 0000000000..7004bd71aa --- /dev/null +++ b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-runlibfileifexists.patch @@ -0,0 +1,92 @@ +From ea8addd686889af76d70031998680196913243ec Mon Sep 17 00:00:00 2001 +From: "David Kaspar [Dee'Kej]" +Date: Fri, 7 Oct 2016 12:20:29 +0200 +Subject: [PATCH 1/2] Fix error when using ImageMagick's convert: + + Error: /undefined in .runlibfileexists +--- + Resource/Init/gs_fonts.ps | 15 ++++++++++++--- + Resource/Init/gs_init.ps | 9 +++++++++ + 2 files changed, 21 insertions(+), 3 deletions(-) + +diff --git a/Resource/Init/gs_fonts.ps b/Resource/Init/gs_fonts.ps +index a3da615..77814b8 100644 +--- a/Resource/Init/gs_fonts.ps ++++ b/Resource/Init/gs_fonts.ps +@@ -96,10 +96,19 @@ userdict /.nativeFontmap .FontDirectory maxlength dict put + % stack: dict file fontname filename|aliasname + 1 index type /stringtype eq + 1 index type /nametype eq and 1 index xcheck and +- 1 index /run eq 2 index /.runlibfile eq or and { ++ 1 index /run eq 2 index /.runlibfile eq 3 index /.runlibfileifexists eq or or and { + % This is an inclusion entry. +- pop findlibfile { exch pop } { file } ifelse +- 2 index exch .readFontmap pop ++ 0 index /.runlibfileifexists eq { ++ pop findlibfile { ++ exch pop ++ 2 index exch .readFontmap pop ++ } { ++ pop ++ } ifelse ++ } { ++ pop findlibfile { exch pop } { file } ifelse ++ 2 index exch .readFontmap pop ++ } ifelse + } { + % This is a real entry. + % Read and pop tokens until a semicolon. +diff --git a/Resource/Init/gs_init.ps b/Resource/Init/gs_init.ps +index ab7cfed..f9e035b 100644 +--- a/Resource/Init/gs_init.ps ++++ b/Resource/Init/gs_init.ps +@@ -689,6 +689,14 @@ systemdict /internaldict dup .makeinternaldict .makeoperator + { /undefinedfilename signalerror } + ifelse + } bind def ++/runlibfileifexists ++ { % We don't want to bind 'run' into this procedure, ++ % since run may get redefined. ++ findlibfile ++ { exch pop /run .systemvar exec } ++ { pop } ++ ifelse ++ } bind def + /selectdevice + { finddevice setdevice .setdefaultscreen } bind def + /signalerror % signalerror - +@@ -857,6 +865,7 @@ userdict /.currentresourcefile //null put + } bind def + % Temporarily substitute it for the real runlibfile. + /.runlibfile /runlibfile load def ++/.runlibfileifexists /runlibfileifexists load def + /runlibfile /runlibfile0 load def + + % Create the error handling machinery. +-- +2.7.4 + + +From 9878f41a229c67aba2e62ee7ab22ff37c2e5a04f Mon Sep 17 00:00:00 2001 +From: "David Kaspar [Dee'Kej]" +Date: Fri, 7 Oct 2016 12:57:06 +0200 +Subject: [PATCH 2/2] Make sure customizations to + /etc/ghostscript/Fontmap.local are used + + For more info, see: https://bugzilla.redhat.com/show_bug.cgi?id=610301 +--- + Resource/Init/Fontmap | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/Resource/Init/Fontmap b/Resource/Init/Fontmap +index ae5af96..72aeb1f 100644 +--- a/Resource/Init/Fontmap ++++ b/Resource/Init/Fontmap +@@ -2,3 +2,5 @@ + % See Fontmap.GS for the syntax of real Fontmap files. + %% Replace 1 (Fontmap.GS) + (Fontmap.GS) .runlibfile ++% must be at the bottom of line to allow people overriding everything. ++(Fontmap.local) .runlibfileifexists +-- +2.7.4 \ No newline at end of file diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-9.20-urw-fonts-naming.patch b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-urw-fonts-naming.patch new file mode 100644 index 0000000000..11a5d51b85 --- /dev/null +++ b/office/postscript/ghostscript/files/fedora/ghostscript-9.20-urw-fonts-naming.patch @@ -0,0 +1,100 @@ +From 54572e8cf529eeb6a01234341d01a2fd555204e6 Mon Sep 17 00:00:00 2001 +From: "David Kaspar [Dee'Kej]" +Date: Fri, 7 Oct 2016 13:38:13 +0200 +Subject: [PATCH] Use old names of urw-fonts + +--- + Resource/Init/Fontmap.GS | 78 ++++++++++++++++++++++++++---------------------- + 1 file changed, 43 insertions(+), 35 deletions(-) + +diff --git a/Resource/Init/Fontmap.GS b/Resource/Init/Fontmap.GS +index a9fa335..949c152 100644 +--- a/Resource/Init/Fontmap.GS ++++ b/Resource/Init/Fontmap.GS +@@ -81,41 +81,49 @@ + + % Aliases + +-/AvantGarde-BookOblique /URWGothic-BookOblique ; +-/AvantGarde-Book /URWGothic-Book ; +-/AvantGarde-DemiOblique /URWGothic-DemiOblique ; +-/AvantGarde-Demi /URWGothic-Demi ; +-/Bookman-DemiItalic /URWBookman-DemiItalic ; +-/Bookman-Demi /URWBookman-Demi ; +-/Bookman-LightItalic /URWBookman-LightItalic ; +-/Bookman-Light /URWBookman-Light ; +-/Courier-Bold /NimbusMonoPS-Bold ; +-/Courier-BoldOblique /NimbusMonoPS-BoldItalic ; +-/Courier /NimbusMonoPS-Regular ; +-/Courier-Oblique /NimbusMonoPS-Italic ; +-/Helvetica-Bold /NimbusSans-Bold ; +-/Helvetica-BoldOblique /NimbusSans-BoldOblique ; +-/Helvetica-Narrow-Bold /NimbusSansNarrow-Bold ; +-/Helvetica-Narrow-BoldOblique /NimbusSansNarrow-BdOblique ; +-/Helvetica-Narrow /NimbusSansNarrow-Regular ; +-/Helvetica-Narrow-Oblique /NimbusSansNarrow-Oblique ; +-/Helvetica /NimbusSans-Regular ; +-/Helvetica-Oblique /NimbusSans-Oblique ; +-/NewCenturySchlbk-Bold /C059-Bold ; +-/NewCenturySchlbk-BoldItalic /C059-BdIta ; +-/NewCenturySchlbk-Italic /C059-Italic ; +-/NewCenturySchlbk-Roman /C059-Roman ; +-/Palatino-BoldItalic /P052-BoldItalic ; +-/Palatino-Bold /P052-Bold ; +-/Palatino-Italic /P052-Italic ; +-/Palatino-Roman /P052-Roman ; +-/Symbol /StandardSymbolsPS ; +-/Times-BoldItalic /NimbusRoman-BoldItalic ; +-/Times-Bold /NimbusRoman-Bold ; +-/Times-Italic /NimbusRoman-Italic ; +-/Times-Roman /NimbusRoman-Regular ; +-/ZapfChancery-MediumItalic /Z003-MediumItalic ; +-/ZapfDingbats /D050000L ; ++/AvantGarde-BookOblique /URWGothicL-BookObli ; ++/AvantGarde-Book /URWGothicL-Book ; ++/AvantGarde-DemiOblique /URWGothicL-DemiObli ; ++/AvantGarde-Demi /URWGothicL-Demi ; ++ ++/Bookman-DemiItalic /URWBookmanL-DemiBoldItal ; ++/Bookman-Demi /URWBookmanL-DemiBold ; ++/Bookman-LightItalic /URWBookmanL-LighItal ; ++/Bookman-Light /URWBookmanL-Ligh ; ++ ++/Courier-Bold /NimbusMonL-Bold ; ++/Courier-BoldOblique /NimbusMonL-BoldObli ; ++/Courier /NimbusMonL-Regu ; ++/Courier-Oblique /NimbusMonL-ReguObli ; ++ ++/Helvetica-Bold /NimbusSanL-Bold ; ++/Helvetica-BoldOblique /NimbusSanL-BoldItal ; ++/Helvetica-Narrow-Bold /NimbusSanL-BoldCond ; ++/Helvetica-Narrow-BoldOblique /NimbusSanL-BoldCondItal ; ++/Helvetica-Narrow /NimbusSanL-ReguCond ; ++/Helvetica-Narrow-Oblique /NimbusSanL-ReguCondItal ; ++/Helvetica /NimbusSanL-Regu ; ++/Helvetica-Oblique /NimbusSanL-ReguItal ; ++ ++/NewCenturySchlbk-Bold /CenturySchL-Bold ; ++/NewCenturySchlbk-BoldItalic /CenturySchL-BoldItal ; ++/NewCenturySchlbk-Italic /CenturySchL-Ital ; ++/NewCenturySchlbk-Roman /CenturySchL-Roma ; ++ ++/Palatino-Roman /URWPalladioL-Roma ; ++/Palatino-Italic /URWPalladioL-Ital ; ++/Palatino-Bold /URWPalladioL-Bold ; ++/Palatino-BoldItalic /URWPalladioL-BoldItal ; ++ ++/Symbol /StandardSymL ; ++ ++/Times-BoldItalic /NimbusRomNo9L-MediItal ; ++/Times-Bold /NimbusRomNo9L-Medi ; ++/Times-Italic /NimbusRomNo9L-ReguItal ; ++/Times-Roman /NimbusRomNo9L-Regu ; ++ ++/ZapfChancery-MediumItalic /URWChanceryL-MediItal ; ++/ZapfDingbats /Dingbats ; + + % + % +-- +2.7.4 diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-Fontmap.local.patch b/office/postscript/ghostscript/files/fedora/ghostscript-Fontmap.local.patch deleted file mode 100644 index 3d1fee2560..0000000000 --- a/office/postscript/ghostscript/files/fedora/ghostscript-Fontmap.local.patch +++ /dev/null @@ -1,9 +0,0 @@ -diff -up ghostscript-8.71/Resource/Init/Fontmap.Fontmap.local ghostscript-8.71/Resource/Init/Fontmap ---- ghostscript-8.71/Resource/Init/Fontmap.Fontmap.local 2008-08-08 05:22:38.000000000 +0100 -+++ ghostscript-8.71/Resource/Init/Fontmap 2010-09-03 11:53:47.273865979 +0100 -@@ -2,3 +2,5 @@ - % See Fontmap.GS for the syntax of real Fontmap files. - %% Replace 1 (Fontmap.GS) - (Fontmap.GS) .runlibfile -+% must be at the bottom of line to allow people overriding everything. -+(Fontmap.local) .runlibfileifexists diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-gdevcups-debug-uninit.patch b/office/postscript/ghostscript/files/fedora/ghostscript-gdevcups-debug-uninit.patch deleted file mode 100644 index 9122d1fc95..0000000000 --- a/office/postscript/ghostscript/files/fedora/ghostscript-gdevcups-debug-uninit.patch +++ /dev/null @@ -1,11 +0,0 @@ -diff -up ghostscript-9.07/cups/gdevcups.c.gdevcups-debug-uninit ghostscript-9.07/cups/gdevcups.c ---- ghostscript-9.07/cups/gdevcups.c.gdevcups-debug-uninit 2013-02-14 07:58:16.000000000 +0000 -+++ ghostscript-9.07/cups/gdevcups.c 2013-02-14 17:16:59.677951232 +0000 -@@ -830,6 +830,7 @@ cups_get_matrix(gx_device *pdev, /* I - - dmprintf4(pdev->memory, "DEBUG2: PageSize = [ %d %d ], HWResolution = [ %d %d ]\n", - cups->header.PageSize[0], cups->header.PageSize[1], - cups->header.HWResolution[0], cups->header.HWResolution[1]); -+ if (size_set) - dmprintf4(pdev->memory, "DEBUG2: HWMargins = [ %.3f %.3f %.3f %.3f ]\n", - pdev->HWMargins[0], pdev->HWMargins[1], pdev->HWMargins[2], - pdev->HWMargins[3]); diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-gs694154.patch b/office/postscript/ghostscript/files/fedora/ghostscript-gs694154.patch deleted file mode 100644 index 248aebbbe7..0000000000 --- a/office/postscript/ghostscript/files/fedora/ghostscript-gs694154.patch +++ /dev/null @@ -1,12 +0,0 @@ -diff -up ghostscript-9.12/base/gsicc.c.gs694154 ghostscript-9.12/base/gsicc.c ---- ghostscript-9.12/base/gsicc.c.gs694154 2014-03-25 08:52:16.000000000 +0000 -+++ ghostscript-9.12/base/gsicc.c 2014-03-26 11:32:31.406034840 +0000 -@@ -468,6 +468,8 @@ gx_remap_ICC_imagelab(const gs_client_co - cmm_dev_profile_t *dev_profile; - - code = dev_proc(dev, get_profile)(dev, &dev_profile); -+ if (dev_profile == NULL) -+ return gs_throw(gs_error_Fatal, "Attempting to do ICC remap with no profile"); - num_des_comps = gsicc_get_device_profile_comps(dev_profile); - rendering_params.black_point_comp = pis->blackptcomp; - rendering_params.graphics_type_tag = dev->graphics_type_tag; diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-icc-missing-check.patch b/office/postscript/ghostscript/files/fedora/ghostscript-icc-missing-check.patch deleted file mode 100644 index 9b9109ae37..0000000000 --- a/office/postscript/ghostscript/files/fedora/ghostscript-icc-missing-check.patch +++ /dev/null @@ -1,12 +0,0 @@ -diff -up ghostscript-9.12/base/gsicc_manage.c.icc-missing-check ghostscript-9.12/base/gsicc_manage.c ---- ghostscript-9.12/base/gsicc_manage.c.icc-missing-check 2014-03-26 11:31:11.296570797 +0000 -+++ ghostscript-9.12/base/gsicc_manage.c 2014-03-26 11:32:10.384912584 +0000 -@@ -613,6 +613,8 @@ gsicc_set_srcgtag_struct(gsicc_manager_t - icc_profile = - gsicc_profile_new(str, mem, curr_ptr, strlen(curr_ptr)); - code = sfclose(str); -+ } -+ if (str != NULL && icc_profile != NULL) { - gsicc_init_profile_info(icc_profile); - cmm = gsCMM_DEFAULT; - /* Check if this object is a devicelink profile. diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-iccprofiles-initdir.patch b/office/postscript/ghostscript/files/fedora/ghostscript-iccprofiles-initdir.patch deleted file mode 100644 index b47511ced6..0000000000 --- a/office/postscript/ghostscript/files/fedora/ghostscript-iccprofiles-initdir.patch +++ /dev/null @@ -1,35 +0,0 @@ -diff -up ghostscript-9.06/base/gsicc_manage.c.iccprofiles-initdir ghostscript-9.06/base/gsicc_manage.c ---- ghostscript-9.06/base/gsicc_manage.c.iccprofiles-initdir 2012-08-09 13:58:22.102364807 +0100 -+++ ghostscript-9.06/base/gsicc_manage.c 2012-08-09 14:09:24.495864641 +0100 -@@ -38,6 +38,7 @@ - #include "gsicc_create.h" - #include "gpmisc.h" - #include "gxdevice.h" -+#include "gxiodev.h" - - #define ICC_HEADER_SIZE 128 - -@@ -2176,8 +2177,21 @@ gs_currenticcdirectory(const gs_state * - const gs_lib_ctx_t *lib_ctx = pgs->memory->gs_lib_ctx; - - if (lib_ctx->profiledir == NULL) { -- pval->data = (const byte *)rfs; -- pval->size = strlen(rfs); -+ int have_rom_device = 0; -+ int i; -+ -+ for (i = 0; i < gx_io_device_table_count; i++) { -+ const gx_io_device *iodev = lib_ctx->io_device_table[i]; -+ const char *dname = iodev->dname; -+ -+ if (dname && strlen(dname) == 5 && !memcmp("%rom%", dname, 5)) { -+ have_rom_device = 1; -+ break; -+ } -+ } -+ -+ pval->data = (const byte *)(have_rom_device ? rfs : ""); -+ pval->size = strlen((const char *)pval->data); - pval->persistent = true; - } else { - pval->data = (const byte *)(lib_ctx->profiledir); diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-multilib.patch b/office/postscript/ghostscript/files/fedora/ghostscript-multilib.patch deleted file mode 100644 index 27bf5e663a..0000000000 --- a/office/postscript/ghostscript/files/fedora/ghostscript-multilib.patch +++ /dev/null @@ -1,14 +0,0 @@ -diff -up ghostscript-8.61/ijs/Makefile.am.multilib ghostscript-8.61/ijs/Makefile.am -diff -up ghostscript-8.61/ijs/ijs-config.in.multilib ghostscript-8.61/ijs/ijs-config.in ---- ghostscript-8.61/ijs/ijs-config.in.multilib 2002-01-31 19:09:46.000000000 +0000 -+++ ghostscript-8.61/ijs/ijs-config.in 2007-11-23 09:19:18.000000000 +0000 -@@ -43,8 +43,7 @@ while test $# -gt 0; do - echo $includes - ;; - --libs) -- libdirs=-L@libdir@ -- echo $libdirs -lijs -+ echo -lijs - ;; - *) - echo "${usage}" 1>&2 diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-noopt.patch b/office/postscript/ghostscript/files/fedora/ghostscript-noopt.patch deleted file mode 100644 index 589cf822b5..0000000000 --- a/office/postscript/ghostscript/files/fedora/ghostscript-noopt.patch +++ /dev/null @@ -1,12 +0,0 @@ -diff -up ghostscript-8.64/psi/int.mak.noopt ghostscript-8.64/psi/int.mak ---- ghostscript-8.64/psi/int.mak.noopt 2008-12-26 07:25:31.000000000 +0000 -+++ ghostscript-8.64/psi/int.mak 2009-02-04 11:33:48.000000000 +0000 -@@ -111,7 +111,7 @@ $(PSOBJ)igc.$(OBJ) : $(PSSRC)igc.c $(GH) - $(PSOBJ)igcref.$(OBJ) : $(PSSRC)igcref.c $(GH) $(memory__h)\ - $(gsexit_h) $(gsstruct_h)\ - $(iastate_h) $(idebug_h) $(igc_h) $(iname_h) $(ipacked_h) $(store_h) -- $(PSCC) $(PSO_)igcref.$(OBJ) $(C_) $(PSSRC)igcref.c -+ $(PSCC) -O0 $(PSO_)igcref.$(OBJ) $(C_) $(PSSRC)igcref.c - - $(PSOBJ)igcstr.$(OBJ) : $(PSSRC)igcstr.c $(GH) $(memory__h)\ - $(gsmdebug_h) $(gsstruct_h) $(iastate_h) $(igcstr_h) diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-runlibfileifexists.patch b/office/postscript/ghostscript/files/fedora/ghostscript-runlibfileifexists.patch deleted file mode 100644 index 03b731c5d3..0000000000 --- a/office/postscript/ghostscript/files/fedora/ghostscript-runlibfileifexists.patch +++ /dev/null @@ -1,52 +0,0 @@ -diff -up ghostscript-9.12/Resource/Init/gs_fonts.ps.runlibfileifexists ghostscript-9.12/Resource/Init/gs_fonts.ps ---- ghostscript-9.12/Resource/Init/gs_fonts.ps.runlibfileifexists 2014-03-25 08:52:16.000000000 +0000 -+++ ghostscript-9.12/Resource/Init/gs_fonts.ps 2014-03-26 12:01:48.248748767 +0000 -@@ -95,10 +95,19 @@ userdict /Fontmap .FontDirectory maxleng - % stack: dict file fontname filename|aliasname - 1 index type /stringtype eq - 1 index type /nametype eq and 1 index xcheck and -- 1 index /run eq 2 index /.runlibfile eq or and { -+ 1 index /run eq 2 index /.runlibfile eq 3 index /.runlibfileifexists eq or or and { - % This is an inclusion entry. -- pop findlibfile { exch pop } { file } ifelse -- 2 index exch .readFontmap pop -+ 0 index /.runlibfileifexists eq { -+ pop findlibfile { -+ exch pop -+ 2 index exch .readFontmap pop -+ } { -+ pop -+ } ifelse -+ } { -+ pop findlibfile { exch pop } { file } ifelse -+ 2 index exch .readFontmap pop -+ } ifelse - } { - % This is a real entry. - % Read and pop tokens until a semicolon. -diff -up ghostscript-9.12/Resource/Init/gs_init.ps.runlibfileifexists ghostscript-9.12/Resource/Init/gs_init.ps ---- ghostscript-9.12/Resource/Init/gs_init.ps.runlibfileifexists 2014-03-25 08:52:16.000000000 +0000 -+++ ghostscript-9.12/Resource/Init/gs_init.ps 2014-03-26 12:01:48.248748767 +0000 -@@ -681,6 +681,14 @@ systemdict /internaldict dup .makeintern - { /undefinedfilename signalerror } - ifelse - } bind def -+/runlibfileifexists -+ { % We don't want to bind 'run' into this procedure, -+ % since run may get redefined. -+ findlibfile -+ { exch pop /run .systemvar exec } -+ { pop } -+ ifelse -+ } bind def - /selectdevice - { finddevice setdevice .setdefaultscreen } bind def - /signalerror % signalerror - -@@ -849,6 +857,7 @@ userdict /.currentresourcefile //null pu - } bind def - % Temporarily substitute it for the real runlibfile. - /.runlibfile /runlibfile load def -+/.runlibfileifexists /runlibfileifexists load def - /runlibfile /runlibfile0 load def - - % Create the error handling machinery. diff --git a/office/postscript/ghostscript/files/fedora/ghostscript-wrf-snprintf.patch b/office/postscript/ghostscript/files/fedora/ghostscript-wrf-snprintf.patch deleted file mode 100644 index 74d8c2a5c6..0000000000 --- a/office/postscript/ghostscript/files/fedora/ghostscript-wrf-snprintf.patch +++ /dev/null @@ -1,22 +0,0 @@ -diff -up ghostscript-9.07/base/wrfont.c.wrf-snprintf ghostscript-9.07/base/wrfont.c ---- ghostscript-9.07/base/wrfont.c.wrf-snprintf 2013-07-01 13:02:33.373244683 +0100 -+++ ghostscript-9.07/base/wrfont.c 2013-07-01 13:04:55.022864299 +0100 -@@ -72,7 +72,8 @@ WRF_wfloat(WRF_output * a_output, double - { - char buffer[32]; - -- gs_sprintf(buffer, "%f", a_float); -+ if (gs_snprintf(buffer, sizeof (buffer), "%f", a_float) >= sizeof (buffer)) -+ abort(); - WRF_wstring(a_output, buffer); - } - -@@ -81,6 +82,7 @@ WRF_wint(WRF_output * a_output, long a_i - { - char buffer[32]; - -- gs_sprintf(buffer, "%ld", a_int); -+ if (gs_snprintf(buffer, sizeof (buffer), "%ld", a_int) >= sizeof (buffer)) -+ abort(); - WRF_wstring(a_output, buffer); - } diff --git a/office/postscript/ghostscript/pspec.xml b/office/postscript/ghostscript/pspec.xml index 862c708365..e89cb23178 100644 --- a/office/postscript/ghostscript/pspec.xml +++ b/office/postscript/ghostscript/pspec.xml @@ -12,7 +12,7 @@ library A PostScript interpreter and renderer ghostscript is a set of software that provides a PostScript interpreter, a set of C procedures and an interpreter for PDF files. ghostscript is normally used to display PostScript files and to print PostScript files to non-PostScript printers. - https://github.com/ArtifexSoftware/ghostpdl-downloads/releases/download/gs919/ghostscript-9.19.tar.gz + https://github.com/ArtifexSoftware/ghostpdl-downloads/releases/download/gs920/ghostscript-9.20.tar.xz tiff-devel zlib-devel @@ -21,27 +21,26 @@ libSM-devel freetype-devel libjpeg-turbo-devel - lcms2-devel + lcms2-devel libXt-devel libpng-devel libpaper-devel fontconfig-devel - - - - fedora/ghostscript-sys-zlib.patch - + fedora/ghostscript-9.20-cve-2016-7976.patch + fedora/ghostscript-9.20-cve-2016-7977.patch + fedora/ghostscript-9.20-cve-2016-7978.patch + fedora/ghostscript-9.20-cve-2016-7979.patch + fedora/ghostscript-9.20-cve-2016-8602.patch + fedora/ghostscript-9.20-cve-2016-9601.patch + fedora/ghostscript-9.20-fix-openjpeg-system-build.patch + fedora/ghostscript-9.20-handle-glyphdirectory-correctly.patch + fedora/ghostscript-9.20-remove-and-reimplement-ConvertUTF.patch + fedora/ghostscript-9.20-run-dvipdf-securely.patch + fedora/ghostscript-9.20-runlibfileifexists.patch + fedora/ghostscript-9.20-urw-fonts-naming.patch @@ -54,7 +53,7 @@ freetype libjpeg-turbo tiff - lcms2 + lcms2 libXt libpaper fontconfig @@ -137,6 +136,13 @@ + + 2017-02-05 + 9.20 + Version Bump + Pisi Linux Community + admin@pisilinux.org + 2016-06-09 9.19