diff -pur dillo-0.2.4/src/png.c dillo-0.2.4.pngerror/src/png.c
--- dillo-0.2.4/src/png.c	Mon Aug  7 11:27:48 2000
+++ dillo-0.2.4.pngerror/src/png.c	Mon Oct 16 02:08:55 2000
@@ -68,11 +68,12 @@ struct _DilloPng {
    double display_exponent;     /* gamma correction */
    gulong width;                /* png image width */
    gulong height;               /* png image height */
-   void *png_ptr;               /* png private data */
-   void *info_ptr;              /*  "     "     "  */
+   png_structp png_ptr;         /* libpng private data */
+   png_infop info_ptr;          /* libpng private info */
    guchar *image_data;          /* decoded image data    */
    guchar **row_pointers;       /* pntr to row starts    */
    jmp_buf jmpbuf;              /* png error processing */
+   gint error;			/* error flag */
    gint rowbytes;               /* No. bytes in image row */
    short passes;
    short channels;              /* No. image channels */
@@ -97,13 +98,22 @@ struct _DilloPng {
 } DilloPng;
 
 #define DATASIZE  (png->ipbufsize - png->ipbufstart)
-#define SUSPEND   return
 #define BLACK     0
 #define WHITE     255
 
-#define PROTECT if ( !setjmp(png->jmpbuf) ) {
-#define RECOVER } else {
-#define ENDPROT }
+static
+void Png_error_handling(png_structp png_ptr, png_const_charp msg)
+{
+   DilloPng *png;
+   
+   g_print("Png_error_handling: %s\n", msg);
+   png = png_get_error_ptr(png_ptr);
+
+   png->error = 1;
+   png->state = IS_finished;
+
+   longjmp(png->jmpbuf, 1);
+}
 
 static
 void Png_datainfo_callback(png_structp png_ptr, png_infop info_ptr)
@@ -295,7 +305,7 @@ void Png_callback(int Terminate, void *C
       if (png->linebuf != NULL)
          g_free(png->linebuf);
       if (setjmp(png->jmpbuf))
-         png_destroy_read_struct(png->png_ptr, png->info_ptr, NULL);
+         png_destroy_read_struct(&png->png_ptr, &png->info_ptr, NULL);
       g_free(png);
       return;
    }
@@ -324,7 +334,7 @@ void Png_callback(int Terminate, void *C
       switch (png->state) {
       case IS_init:
          if (DATASIZE < 8) {
-            SUSPEND;            /* need MORE data */
+            return;            /* need MORE data */
          }
          /* check the image signature - DONT update ipbufstart! */
          if (!png_check_sig(png->ipbuf, DATASIZE)) {
@@ -335,51 +345,36 @@ void Png_callback(int Terminate, void *C
          /* OK, it looks like a PNG image, lets do some set up stuff */
          png->png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING,
                                                 png,
-                                                NULL /* FIXME? */ ,
-                                                NULL);
-         assert(png->png_ptr != NULL);
+                                                (png_error_ptr)Png_error_handling,
+                                                (png_error_ptr)Png_error_handling);
+         assert(png->png_ptr);
          png->info_ptr = png_create_info_struct(png->png_ptr);
          assert(png->info_ptr);
 
-         /*
-          * the following is extremely barfish - libpng uses longjmp's
-          * as part of it's error processing and we cannot rely on
-          * jmpbuf data across calls - who knows the state of the
-          * stack at each call.  So we have to update jmpbuf before
-          * every call to a libpng function... oh hum.
-          */
-
-         /* set up a progressive read of the image data */
-         PROTECT
-             png_set_progressive_read_fn( png->png_ptr,
-                                          png,
-                                          Png_datainfo_callback,   /* performs local init functions */
-                                          Png_datarow_callback,    /* performs per row action */
-                                          Png_dataend_callback);   /* performs cleanup actions */
-         png->state = IS_nextdata;
-         RECOVER
-             /* failed for some reason */
-             png->state = IS_finished;
+         setjmp(png->jmpbuf);
+         if(!png->error)
+         {
+            png_set_progressive_read_fn( png->png_ptr,
+                                      png,
+                                      Png_datainfo_callback,   /* performs local init functions */
+                                      Png_datarow_callback,    /* performs per row action */
+                                      Png_dataend_callback);   /* performs cleanup actions */
+            png->state = IS_nextdata;
+         }
          break;
-         ENDPROT
-             break;
 
       case IS_nextdata:
-         PROTECT
-             png_process_data(
-                                png->png_ptr,
-                                png->info_ptr,
-                                png->ipbuf + png->ipbufstart,
-                                DATASIZE);
-         png->ipbufstart += DATASIZE;
-         SUSPEND;
-         RECOVER
-             /* failed for some reason */
-             g_warning("decoding failed for some reason...\n");
-             png->state = IS_finished;
+         setjmp(png->jmpbuf);
+         if(!png->error)
+         {
+            png_process_data( png->png_ptr,
+                              png->info_ptr,
+                              png->ipbuf + png->ipbufstart,
+                              DATASIZE);
+
+            png->ipbufstart += DATASIZE;
+         }
          break;
-         ENDPROT
-             break;
 
       default:
          g_warning("bad state = %d\n", png->state);
@@ -431,6 +426,7 @@ Dw *a_Png_image(const char *Type, void *
    imgsink->RefCount++;
    imgsink->Parent = &(png->imgsink);
    png->state = IS_init;
+   png->error = 0;
    png->ipbuf = NULL;
    png->ipbufstart = 0;
    png->ipbufsize = 0;