Merge debian changes from 3.0.34-6.
[privoxy.git] / deanimate.c
1 /*********************************************************************
2  *
3  * File        :  $Source: /cvsroot/ijbswa/current/deanimate.c,v $
4  *
5  * Purpose     :  Declares functions to manipulate binary images on the
6  *                fly.  High-level functions include:
7  *                  - Deanimation of GIF images
8  *
9  * Copyright   :  Written by and Copyright (C) 2001-2021 by the
10  *                Privoxy team. https://www.privoxy.org/
11  *
12  *                Based on the GIF file format specification (see
13  *                https://tronche.com/computer-graphics/gif/gif89a.html)
14  *                and ideas from the Image::DeAnim Perl module by
15  *                Ken MacFarlane, <ksm+cpan@universal.dca.net>
16  *
17  *                This program is free software; you can redistribute it
18  *                and/or modify it under the terms of the GNU General
19  *                Public License as published by the Free Software
20  *                Foundation; either version 2 of the License, or (at
21  *                your option) any later version.
22  *
23  *                This program is distributed in the hope that it will
24  *                be useful, but WITHOUT ANY WARRANTY; without even the
25  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
26  *                PARTICULAR PURPOSE.  See the GNU General Public
27  *                License for more details.
28  *
29  *                The GNU General Public License should be included with
30  *                this file.  If not, you can view it at
31  *                http://www.gnu.org/copyleft/gpl.html
32  *                or write to the Free Software Foundation, Inc., 59
33  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
34  *
35  **********************************************************************/
36
37
38 #include "config.h"
39
40 #include <string.h>
41 #include <fcntl.h>
42
43 #include "project.h"
44 #include "errlog.h"
45 #include "deanimate.h"
46 #include "miscutil.h"
47
48 /*********************************************************************
49  *
50  * Function    :  buf_free
51  *
52  * Description :  Safely frees a struct binbuffer
53  *
54  * Parameters  :
55  *          1  :  buf = Pointer to the binbuffer to be freed
56  *
57  * Returns     :  N/A
58  *
59  *********************************************************************/
60 void buf_free(struct binbuffer *buf)
61 {
62    if (buf == NULL) return;
63
64    if (buf->buffer != NULL)
65    {
66       free(buf->buffer);
67    }
68
69    free(buf);
70
71 }
72
73
74 /*********************************************************************
75  *
76  * Function    :  buf_extend
77  *
78  * Description :  Ensure that a given binbuffer can hold a given amount
79  *                of bytes, by reallocating its buffer if necessary.
80  *                Allocate new mem in chunks of 1024 bytes, so we don't
81  *                have to realloc() too often.
82  *
83  * Parameters  :
84  *          1  :  buf = Pointer to the binbuffer
85  *          2  :  length = Desired minimum size
86  *
87  *
88  * Returns     :  0 on success, 1 on failure.
89  *
90  *********************************************************************/
91 static int buf_extend(struct binbuffer *buf, size_t length)
92 {
93    char *newbuf;
94
95    if (buf->offset + length > buf->size)
96    {
97       buf->size = ((buf->size + length + (size_t)1023) & ~(size_t)1023);
98       newbuf = (char *)realloc(buf->buffer, buf->size);
99
100       if (newbuf == NULL)
101       {
102          freez(buf->buffer);
103          return 1;
104       }
105       else
106       {
107          buf->buffer = newbuf;
108          return 0;
109       }
110    }
111    return 0;
112
113 }
114
115
116 /*********************************************************************
117  *
118  * Function    :  buf_copy
119  *
120  * Description :  Safely copies a given amount of bytes from one
121  *                struct binbuffer to another, advancing the
122  *                offsets appropriately.
123  *
124  * Parameters  :
125  *          1  :  src = Pointer to the source binbuffer
126  *          2  :  dst = Pointer to the destination binbuffer
127  *          3  :  length = Number of bytes to be copied
128  *
129  * Returns     :  0 on success, 1 on failure.
130  *
131  *********************************************************************/
132 static int buf_copy(struct binbuffer *src, struct binbuffer *dst, size_t length)
133 {
134    /*
135     * Sanity check: Make sure the source buffer contains
136     * data and there's work to be done.
137     */
138    if (src->buffer == NULL || src->size == 0 || length == 0)
139    {
140       return 1;
141    }
142
143    /*
144     * Sanity check: Can't copy more data than we have
145     */
146    if (src->offset + length > src->size)
147    {
148       return 1;
149    }
150
151    /*
152     * Ensure that dst can hold the new data
153     */
154    if (buf_extend(dst, length))
155    {
156       return 1;
157    }
158
159    /*
160     * Now that it's safe, memcpy() the desired amount of
161     * data from src to dst and adjust the offsets
162     */
163    memcpy(dst->buffer + dst->offset, src->buffer + src->offset, length);
164    src->offset += length;
165    dst->offset += length;
166
167    return 0;
168
169 }
170
171
172 /*********************************************************************
173  *
174  * Function    :  buf_getbyte
175  *
176  * Description :  Safely gets a byte from a given binbuffer at a
177  *                given offset
178  *
179  * Parameters  :
180  *          1  :  src = Pointer to the source binbuffer
181  *          2  :  offset = Offset to the desired byte
182  *
183  * Returns     :  The byte on success, or 0 on failure
184  *
185  *********************************************************************/
186 static unsigned char buf_getbyte(const struct binbuffer *src, size_t offset)
187 {
188    if (src->offset + offset < src->size)
189    {
190       return (unsigned char)*(src->buffer + src->offset + offset);
191    }
192    else
193    {
194       return '\0';
195    }
196
197 }
198
199
200 /*********************************************************************
201  *
202  * Function    :  gif_skip_data_block
203  *
204  * Description :  Safely advances the offset of a given struct binbuffer
205  *                that contains a GIF image and whose offset is
206  *                positioned at the start of a data block, behind
207  *                that block.
208  *
209  * Parameters  :
210  *          1  :  buf = Pointer to the binbuffer
211  *
212  * Returns     :  0 on success, or 1 on failure
213  *
214  *********************************************************************/
215 static int gif_skip_data_block(struct binbuffer *buf)
216 {
217    unsigned char c;
218
219    /*
220     * Data blocks are sequences of chunks, which are headed
221     * by a one-byte length field, with the last chunk having
222     * zero length.
223     */
224    while((c = buf_getbyte(buf, 0)) != '\0')
225    {
226       buf->offset += (size_t)c + 1;
227       if (buf->offset >= buf->size - 1)
228       {
229          return 1;
230       }
231    }
232    buf->offset++;
233
234    return 0;
235
236 }
237
238
239 /*********************************************************************
240  *
241  * Function    :  gif_extract_image
242  *
243  * Description :  Safely extracts an image data block from a given
244  *                struct binbuffer that contains a GIF image and whose
245  *                offset is positioned at the start of a data block
246  *                into a given destination binbuffer.
247  *
248  * Parameters  :
249  *          1  :  src = Pointer to the source binbuffer
250  *          2  :  dst = Pointer to the destination binbuffer
251  *
252  * Returns     :  0 on success, or 1 on failure
253  *
254  *********************************************************************/
255 static int gif_extract_image(struct binbuffer *src, struct binbuffer *dst)
256 {
257    unsigned char c;
258
259    /*
260     * Remember the colormap flag and copy the image head
261     */
262    c = buf_getbyte(src, 9);
263    if (buf_copy(src, dst, 10))
264    {
265       return 1;
266    }
267
268    /*
269     * If the image has a local colormap, copy it.
270     */
271    if (c & 0x80)
272    {
273       int map_length = 3 * (1 << ((c & 0x07) + 1));
274       if (map_length <= 0)
275       {
276          log_error(LOG_LEVEL_DEANIMATE,
277             "colormap length = %d (%c)?", map_length, c);
278          return 1;
279       }
280       if (buf_copy(src, dst, (size_t)map_length))
281       {
282          return 1;
283       }
284    }
285    if (buf_copy(src, dst, 1)) return 1;
286
287    /*
288     * Copy the image chunk by chunk.
289     */
290    while((c = buf_getbyte(src, 0)) != '\0')
291    {
292       if (buf_copy(src, dst, 1 + (size_t) c)) return 1;
293    }
294    if (buf_copy(src, dst, 1)) return 1;
295
296    /*
297     * Trim and rewind the dst buffer
298     */
299    if (NULL == (dst->buffer = (char *)realloc(dst->buffer, dst->offset))) return 1;
300    dst->size = dst->offset;
301    dst->offset = 0;
302
303    return(0);
304
305 }
306
307 /*********************************************************************
308  *
309  * Function    :  gif_deanimate
310  *
311  * Description :  Deanimate a given GIF image, i.e. given a GIF with
312  *                an (optional) image block and an arbitrary number
313  *                of image extension blocks, produce an output GIF with
314  *                only one image block that contains the last image
315  *                (extension) block of the original.
316  *                Also strip Comments, Application extensions, etc.
317  *
318  * Parameters  :
319  *          1  :  src = Pointer to the source binbuffer
320  *          2  :  dst = Pointer to the destination binbuffer
321  *          3  :  get_first_image = Flag: If set, get the first image
322  *                                        If unset (default), get the last
323  *
324  * Returns     :  0 on success, or 1 on failure
325  *
326  *********************************************************************/
327 int gif_deanimate(struct binbuffer *src, struct binbuffer *dst, int get_first_image)
328 {
329    unsigned char c;
330    struct binbuffer *image;
331    int image_buffered = 0;
332
333    if (NULL == src || NULL == dst)
334    {
335       return 1;
336    }
337    if (src->size <= 10)
338    {
339       return 1;
340    }
341
342    c = buf_getbyte(src, 10);
343
344    /*
345     * Check & copy GIF header
346     */
347    if (strncmp(src->buffer, "GIF89a", 6) && strncmp(src->buffer, "GIF87a", 6))
348    {
349       return 1;
350    }
351    else
352    {
353       if (buf_copy(src, dst, 13))
354       {
355          return 1;
356       }
357    }
358
359    /*
360     * Look for global colormap and  copy if found.
361     */
362    if (c & 0x80)
363    {
364       int map_length = 3 * (1 << ((c & 0x07) + 1));
365       if (map_length <= 0)
366       {
367          log_error(LOG_LEVEL_DEANIMATE,
368             "colormap length = %d (%c)?", map_length, c);
369          return 1;
370       }
371       if (buf_copy(src, dst, (size_t)map_length))
372       {
373          return 1;
374       }
375    }
376
377    /*
378     * Reserve a buffer for the current image block
379     */
380    image = zalloc_or_die(sizeof(*image));
381
382    /*
383     * Parse the GIF block by block and copy the relevant
384     * parts to dst
385     */
386    while (src->offset < src->size)
387    {
388       switch (buf_getbyte(src, 0))
389       {
390          /*
391           * End-of-GIF Marker: Append current image if we got
392           * one and return.
393           */
394       case 0x3b:
395          if (image->size == 0) goto failed;
396          goto write;
397
398          /*
399           * Image block: Extract to current image buffer.
400           */
401       case 0x2c:
402          if (image_buffered == 1)
403          {
404             /* Discard previous image. */
405             image->offset = 0;
406             image_buffered = 0;
407          }
408          if (gif_extract_image(src, image)) goto failed;
409          image_buffered = 1;
410          if (get_first_image) goto write;
411          continue;
412
413          /*
414           * Extension block: Look at next byte and decide
415           */
416       case 0x21:
417          switch (buf_getbyte(src, 1))
418          {
419             /*
420              * Image extension: Copy extension header
421              * and continue looking for new blocks.
422              */
423          case 0xf9:
424             if (image_buffered == 1)
425             {
426                image->offset = 0;
427                image_buffered = 0;
428             }
429             if (buf_copy(src, image, 8)) goto failed;
430             continue;
431
432             /*
433              * Application extension: Skip
434              */
435          case 0xff:
436             if ((src->offset += 14) >= src->size || gif_skip_data_block(src)) goto failed;
437             continue;
438
439             /*
440              * Comment extension: Skip
441              */
442          case 0xfe:
443             if ((src->offset += 2) >= src->size || gif_skip_data_block(src)) goto failed;
444             continue;
445
446             /*
447              * Plain text extension: Skip
448              */
449          case 0x01:
450             if ((src->offset += 15) >= src->size || gif_skip_data_block(src)) goto failed;
451             continue;
452
453             /*
454              * Ooops, what type of extension is that?
455              */
456          default:
457             goto failed;
458
459          }
460
461          /*
462           * Ooops, what type of block is that?
463           */
464       default:
465          goto failed;
466
467       }
468    } /* -END- while src */
469
470    /*
471     * Either we got here by goto, or because the GIF is
472     * bogus and EOF was reached before an end-of-gif marker
473     * was found.
474     */
475
476 failed:
477    buf_free(image);
478    return 1;
479
480    /*
481     * Append the current image to dst and return
482     */
483
484 write:
485    if (buf_copy(image, dst, image->size)) goto failed;
486    if (buf_extend(dst, 1)) goto failed;
487    *(dst->buffer + dst->offset++) = 0x3b;
488    buf_free(image);
489    return 0;
490
491 }
492
493
494 /*
495   Local Variables:
496   tab-width: 3
497   end:
498 */