src/3rdparty/libpng/pngerror.c

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