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