root/src/modules/loaders/loader_zlib.c

DEFINITIONS

1. uncompress_file
2. load
3. formats

#include "loader_common.h"
#include <zlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <assert.h>

#define OUTBUF_SIZE 16484

static int uncompress_file (int src, int dest)
{
        gzFile gf;
        DATA8 outbuf[OUTBUF_SIZE];
        int ret = 1, bytes;

        gf = gzdopen (dup (src), "rb");
        if (!gf)
                return 0;

        while (1) {
                bytes = gzread (gf, outbuf, OUTBUF_SIZE);

                if (!bytes)
                        break;
                else if (bytes == -1) {
                        ret = 0;
                        break;
                } else
                        write (dest, outbuf, bytes);
        }

        gzclose (gf);

        return ret;
}

char load (ImlibImage *im, ImlibProgressFunction progress,
           char progress_granularity, char immediate_load)
{
        ImlibLoader *loader;
        int src, dest, res;
        char *file, *p, tmp[] = "/tmp/imlib2_loader_zlib-XXXXXX";
        char real_ext[16];
        struct stat st;

        assert (im);

        /* check that this file ends in *.gz and that there's another ext
         * (e.g. "foo.png.gz"
         */
        p = strrchr(im->real_file, '.');
        if (p && p != im->real_file) {
                if (strcasecmp(p + 1, "gz"))
                        return 0;
        } else
                return 0;

        strncpy (real_ext, p - sizeof (real_ext) + 1, sizeof (real_ext));
        real_ext[sizeof (real_ext) - 1] = '\0';

        /* abort if there's no dot in the "real" filename */
        if (!strrchr (real_ext, '.'))
                return 0;

        if (stat (im->real_file, &st) < 0)
                return 0;

        if ((src = open (im->real_file, O_RDONLY)) < 0) {
                return 0;
        }

        if ((dest = mkstemp (tmp)) < 0) {
                close (src);
                return 0;
        }

        res = uncompress_file (src, dest);
        close (src);
        close (dest);

        if (!res) {
                unlink (tmp);
                return 0;
        }

        if (!(loader = __imlib_FindBestLoaderForFile (real_ext, 0))) {
                unlink (tmp);
                return 0;
        }

        /* remember the original filename */
        file = strdup (im->real_file);

        free (im->real_file);
        im->real_file = strdup (tmp);
        loader->load (im, progress, progress_granularity, immediate_load);

        free (im->real_file);
        im->real_file = file;
        unlink (tmp);

        return 1;
}

void formats (ImlibLoader *l)
{
        /* this is the only bit you have to change... */
        char *list_formats[] = {"gz"};
        int i;

   /* don't bother changing any of this - it just reads this in
        * and sets the struct values and makes copies
        */
        l->num_formats = sizeof (list_formats) / sizeof (char *);
        l->formats = malloc (sizeof (char *) * l->num_formats);

        for (i = 0; i < l->num_formats; i++)
                l->formats[i] = strdup (list_formats[i]);
}