git.mutantstargoat.com Git - dosrtxon/blob - libs/imago/libpng/pngerror.c

   1 \r
   2 /* pngerror.c - stub functions for i/o and memory allocation\r
   3  *\r
   4  * Last changed in libpng 1.2.30 [August 15, 2008]\r
   5  * For conditions of distribution and use, see copyright notice in png.h\r
   6  * Copyright (c) 1998-2008 Glenn Randers-Pehrson\r
   7  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
   8  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
   9  *\r
  10  * This file provides a location for all error handling.  Users who\r
  11  * need special error handling are expected to write replacement functions\r
  12  * and use png_set_error_fn() to use those functions.  See the instructions\r
  13  * at each function.\r
  14  */\r
  15 \r
  16 #define PNG_INTERNAL\r
  17 #include "png.h"\r
  18 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)\r
  19 \r
  20 static void /* PRIVATE */\r
  21 png_default_error PNGARG((png_structp png_ptr,\r
  22   png_const_charp error_message));\r
  23 #ifndef PNG_NO_WARNINGS\r
  24 static void /* PRIVATE */\r
  25 png_default_warning PNGARG((png_structp png_ptr,\r
  26   png_const_charp warning_message));\r
  27 #endif /* PNG_NO_WARNINGS */\r
  28 \r
  29 /* This function is called whenever there is a fatal error.  This function\r
  30  * should not be changed.  If there is a need to handle errors differently,\r
  31  * you should supply a replacement error function and use png_set_error_fn()\r
  32  * to replace the error function at run-time.\r
  33  */\r
  34 #ifndef PNG_NO_ERROR_TEXT\r
  35 void PNGAPI\r
  36 png_error(png_structp png_ptr, png_const_charp error_message)\r
  37 {\r
  38 #ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
  39    char msg[16];\r
  40    if (png_ptr != NULL)\r
  41    {\r
  42      if (png_ptr->flags&\r
  43        (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))\r
  44      {\r
  45        if (*error_message == '#')\r
  46        {\r
  47          /* Strip "#nnnn " from beginning of error message. */\r
  48            int offset;\r
  49            for (offset = 1; offset<15; offset++)\r
  50               if (error_message[offset] == ' ')\r
  51                   break;\r
  52            if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)\r
  53            {\r
  54               int i;\r
  55               for (i = 0; i < offset - 1; i++)\r
  56                  msg[i] = error_message[i + 1];\r
  57               msg[i - 1] = '\0';\r
  58               error_message = msg;\r
  59            }\r
  60            else\r
  61               error_message += offset;\r
  62        }\r
  63        else\r
  64        {\r
  65            if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)\r
  66            {\r
  67               msg[0] = '0';\r
  68               msg[1] = '\0';\r
  69               error_message = msg;\r
  70            }\r
  71        }\r
  72      }\r
  73    }\r
  74 #endif\r
  75    if (png_ptr != NULL && png_ptr->error_fn != NULL)\r
  76       (*(png_ptr->error_fn))(png_ptr, error_message);\r
  77 \r
  78    /* If the custom handler doesn't exist, or if it returns,\r
  79       use the default handler, which will not return. */\r
  80    png_default_error(png_ptr, error_message);\r
  81 }\r
  82 #else\r
  83 void PNGAPI\r
  84 png_err(png_structp png_ptr)\r
  85 {\r
  86    if (png_ptr != NULL && png_ptr->error_fn != NULL)\r
  87       (*(png_ptr->error_fn))(png_ptr, '\0');\r
  88 \r
  89    /* If the custom handler doesn't exist, or if it returns,\r
  90       use the default handler, which will not return. */\r
  91    png_default_error(png_ptr, '\0');\r
  92 }\r
  93 #endif /* PNG_NO_ERROR_TEXT */\r
  94 \r
  95 #ifndef PNG_NO_WARNINGS\r
  96 /* This function is called whenever there is a non-fatal error.  This function\r
  97  * should not be changed.  If there is a need to handle warnings differently,\r
  98  * you should supply a replacement warning function and use\r
  99  * png_set_error_fn() to replace the warning function at run-time.\r
 100  */\r
 101 void PNGAPI\r
 102 png_warning(png_structp png_ptr, png_const_charp warning_message)\r
 103 {\r
 104    int offset = 0;\r
 105    if (png_ptr != NULL)\r
 106    {\r
 107 #ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
 108    if (png_ptr->flags&\r
 109      (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))\r
 110 #endif\r
 111      {\r
 112        if (*warning_message == '#')\r
 113        {\r
 114            for (offset = 1; offset < 15; offset++)\r
 115               if (warning_message[offset] == ' ')\r
 116                   break;\r
 117        }\r
 118      }\r
 119      if (png_ptr != NULL && png_ptr->warning_fn != NULL)\r
 120         (*(png_ptr->warning_fn))(png_ptr, warning_message + offset);\r
 121    }\r
 122    else\r
 123       png_default_warning(png_ptr, warning_message + offset);\r
 124 }\r
 125 #endif /* PNG_NO_WARNINGS */\r
 126 \r
 127 \r
 128 /* These utilities are used internally to build an error message that relates\r
 129  * to the current chunk.  The chunk name comes from png_ptr->chunk_name,\r
 130  * this is used to prefix the message.  The message is limited in length\r
 131  * to 63 bytes, the name characters are output as hex digits wrapped in []\r
 132  * if the character is invalid.\r
 133  */\r
 134 #define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))\r
 135 static PNG_CONST char png_digit[16] = {\r
 136    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',\r
 137    'A', 'B', 'C', 'D', 'E', 'F'\r
 138 };\r
 139 \r
 140 #define PNG_MAX_ERROR_TEXT 64\r
 141 \r
 142 #if !defined(PNG_NO_WARNINGS) || !defined(PNG_NO_ERROR_TEXT)\r
 143 static void /* PRIVATE */\r
 144 png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp\r
 145    error_message)\r
 146 {\r
 147    int iout = 0, iin = 0;\r
 148 \r
 149    while (iin < 4)\r
 150    {\r
 151       int c = png_ptr->chunk_name[iin++];\r
 152       if (isnonalpha(c))\r
 153       {\r
 154          buffer[iout++] = '[';\r
 155          buffer[iout++] = png_digit[(c & 0xf0) >> 4];\r
 156          buffer[iout++] = png_digit[c & 0x0f];\r
 157          buffer[iout++] = ']';\r
 158       }\r
 159       else\r
 160       {\r
 161          buffer[iout++] = (png_byte)c;\r
 162       }\r
 163    }\r
 164 \r
 165    if (error_message == NULL)\r
 166       buffer[iout] = '\0';\r
 167    else\r
 168    {\r
 169       buffer[iout++] = ':';\r
 170       buffer[iout++] = ' ';\r
 171       png_memcpy(buffer + iout, error_message, PNG_MAX_ERROR_TEXT);\r
 172       buffer[iout + PNG_MAX_ERROR_TEXT - 1] = '\0';\r
 173    }\r
 174 }\r
 175 \r
 176 #ifdef PNG_READ_SUPPORTED\r
 177 void PNGAPI\r
 178 png_chunk_error(png_structp png_ptr, png_const_charp error_message)\r
 179 {\r
 180    char msg[18+PNG_MAX_ERROR_TEXT];\r
 181    if (png_ptr == NULL)\r
 182      png_error(png_ptr, error_message);\r
 183    else\r
 184    {\r
 185      png_format_buffer(png_ptr, msg, error_message);\r
 186      png_error(png_ptr, msg);\r
 187    }\r
 188 }\r
 189 #endif /* PNG_READ_SUPPORTED */\r
 190 #endif /* !defined(PNG_NO_WARNINGS) || !defined(PNG_NO_ERROR_TEXT) */\r
 191 \r
 192 #ifndef PNG_NO_WARNINGS\r
 193 void PNGAPI\r
 194 png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)\r
 195 {\r
 196    char msg[18+PNG_MAX_ERROR_TEXT];\r
 197    if (png_ptr == NULL)\r
 198      png_warning(png_ptr, warning_message);\r
 199    else\r
 200    {\r
 201      png_format_buffer(png_ptr, msg, warning_message);\r
 202      png_warning(png_ptr, msg);\r
 203    }\r
 204 }\r
 205 #endif /* PNG_NO_WARNINGS */\r
 206 \r
 207 \r
 208 /* This is the default error handling function.  Note that replacements for\r
 209  * this function MUST NOT RETURN, or the program will likely crash.  This\r
 210  * function is used by default, or if the program supplies NULL for the\r
 211  * error function pointer in png_set_error_fn().\r
 212  */\r
 213 static void /* PRIVATE */\r
 214 png_default_error(png_structp png_ptr, png_const_charp error_message)\r
 215 {\r
 216 #ifndef PNG_NO_CONSOLE_IO\r
 217 #ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
 218    if (*error_message == '#')\r
 219    {\r
 220      /* Strip "#nnnn " from beginning of warning message. */\r
 221      int offset;\r
 222      char error_number[16];\r
 223      for (offset = 0; offset<15; offset++)\r
 224      {\r
 225          error_number[offset] = error_message[offset + 1];\r
 226          if (error_message[offset] == ' ')\r
 227              break;\r
 228      }\r
 229      if ((offset > 1) && (offset < 15))\r
 230      {\r
 231        error_number[offset - 1] = '\0';\r
 232        fprintf(stderr, "libpng error no. %s: %s\n", error_number,\r
 233           error_message + offset + 1);\r
 234      }\r
 235      else\r
 236        fprintf(stderr, "libpng error: %s, offset=%d\n", error_message, offset);\r
 237    }\r
 238    else\r
 239 #endif\r
 240    fprintf(stderr, "libpng error: %s\n", error_message);\r
 241 #endif\r
 242 \r
 243 #ifdef PNG_SETJMP_SUPPORTED\r
 244    if (png_ptr)\r
 245    {\r
 246 #  ifdef USE_FAR_KEYWORD\r
 247    {\r
 248       jmp_buf jmpbuf;\r
 249       png_memcpy(jmpbuf, png_ptr->jmpbuf, png_sizeof(jmp_buf));\r
 250       longjmp(jmpbuf, 1);\r
 251    }\r
 252 #  else\r
 253    longjmp(png_ptr->jmpbuf, 1);\r
 254 #  endif\r
 255    }\r
 256 #else\r
 257    PNG_ABORT();\r
 258 #endif\r
 259 #ifdef PNG_NO_CONSOLE_IO\r
 260    error_message = error_message; /* make compiler happy */\r
 261 #endif\r
 262 }\r
 263 \r
 264 #ifndef PNG_NO_WARNINGS\r
 265 /* This function is called when there is a warning, but the library thinks\r
 266  * it can continue anyway.  Replacement functions don't have to do anything\r
 267  * here if you don't want them to.  In the default configuration, png_ptr is\r
 268  * not used, but it is passed in case it may be useful.\r
 269  */\r
 270 static void /* PRIVATE */\r
 271 png_default_warning(png_structp png_ptr, png_const_charp warning_message)\r
 272 {\r
 273 #ifndef PNG_NO_CONSOLE_IO\r
 274 #  ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
 275    if (*warning_message == '#')\r
 276    {\r
 277      int offset;\r
 278      char warning_number[16];\r
 279      for (offset = 0; offset < 15; offset++)\r
 280      {\r
 281         warning_number[offset] = warning_message[offset + 1];\r
 282         if (warning_message[offset] == ' ')\r
 283             break;\r
 284      }\r
 285      if ((offset > 1) && (offset < 15))\r
 286      {\r
 287        warning_number[offset + 1] = '\0';\r
 288        fprintf(stderr, "libpng warning no. %s: %s\n", warning_number,\r
 289           warning_message + offset);\r
 290      }\r
 291      else\r
 292        fprintf(stderr, "libpng warning: %s\n", warning_message);\r
 293    }\r
 294    else\r
 295 #  endif\r
 296      fprintf(stderr, "libpng warning: %s\n", warning_message);\r
 297 #else\r
 298    warning_message = warning_message; /* make compiler happy */\r
 299 #endif\r
 300    png_ptr = png_ptr; /* make compiler happy */\r
 301 }\r
 302 #endif /* PNG_NO_WARNINGS */\r
 303 \r
 304 /* This function is called when the application wants to use another method\r
 305  * of handling errors and warnings.  Note that the error function MUST NOT\r
 306  * return to the calling routine or serious problems will occur.  The return\r
 307  * method used in the default routine calls longjmp(png_ptr->jmpbuf, 1)\r
 308  */\r
 309 void PNGAPI\r
 310 png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,\r
 311    png_error_ptr error_fn, png_error_ptr warning_fn)\r
 312 {\r
 313    if (png_ptr == NULL)\r
 314       return;\r
 315    png_ptr->error_ptr = error_ptr;\r
 316    png_ptr->error_fn = error_fn;\r
 317    png_ptr->warning_fn = warning_fn;\r
 318 }\r
 319 \r
 320 \r
 321 /* This function returns a pointer to the error_ptr associated with the user\r
 322  * functions.  The application should free any memory associated with this\r
 323  * pointer before png_write_destroy and png_read_destroy are called.\r
 324  */\r
 325 png_voidp PNGAPI\r
 326 png_get_error_ptr(png_structp png_ptr)\r
 327 {\r
 328    if (png_ptr == NULL)\r
 329       return NULL;\r
 330    return ((png_voidp)png_ptr->error_ptr);\r
 331 }\r
 332 \r
 333 \r
 334 #ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
 335 void PNGAPI\r
 336 png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)\r
 337 {\r
 338    if (png_ptr != NULL)\r
 339    {\r
 340      png_ptr->flags &=\r
 341        ((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);\r
 342    }\r
 343 }\r
 344 #endif\r
 345 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */\r