zlibsupport.c

   1 /* Support for compressed modules.  Willy Tarreau <willy@meta-x.org>
   2  * did the support for modutils, Andrey Borzenkov <arvidjaar@mail.ru>
   3  * ported it to module-init-tools, and I said it was too ugly to live
   4  * and rewrote it 8).
   5  *
   6  * (C) 2003 Rusty Russell, IBM Corporation.
   7  */
   8 #include <sys/types.h>
   9 #include <sys/stat.h>
  10 #include <fcntl.h>
  11 #include <stdlib.h>
  12 #include <unistd.h>
  13 #include <sys/mman.h>
  14
  15 #include "zlibsupport.h"
  16 #include "testing.h"
  17
  18 #ifdef CONFIG_USE_ZLIB
  19 #include <zlib.h>
  20
  21 void *grab_contents(gzFile *gzfd, unsigned long *size)
  22 {
  23         unsigned int max = 16384;
  24         void *buffer = malloc(max);
  25         int ret;
  26
  27         if (!buffer)
  28                 return NULL;
  29
  30         *size = 0;
  31         while ((ret = gzread(gzfd, buffer + *size, max - *size)) > 0) {
  32                 *size += ret;
  33                 if (*size == max) {
  34                         void *p;
  35
  36                         p = realloc(buffer, max *= 2);
  37                         if (!p)
  38                                 goto out_err;
  39
  40                         buffer = p;
  41                 }
  42         }
  43         if (ret < 0)
  44                 goto out_err;
  45
  46         return buffer;
  47
  48 out_err:
  49         free(buffer);
  50         return NULL;
  51 }
  52
  53 void *grab_fd(int fd, unsigned long *size)
  54 {
  55         gzFile gzfd;
  56
  57         gzfd = gzdopen(fd, "rb");
  58         if (!gzfd)
  59                 return NULL;
  60
  61         /* gzclose(gzfd) would close fd, which would drop locks.
  62            Don't blame zlib: POSIX locking semantics are so horribly
  63            broken that they should be ripped out. */
  64         return grab_contents(gzfd, size);
  65 }
  66
  67 /* gzopen handles uncompressed files transparently. */
  68 void *grab_file(const char *filename, unsigned long *size)
  69 {
  70         gzFile gzfd;
  71         void *buffer;
  72
  73         gzfd = gzopen(filename, "rb");
  74         if (!gzfd)
  75                 return NULL;
  76         buffer = grab_contents(gzfd, size);
  77         gzclose(gzfd);
  78         return buffer;
  79 }
  80
  81 void release_file(void *data, unsigned long size)
  82 {
  83         free(data);
  84 }
  85 #else /* ... !CONFIG_USE_ZLIB */
  86
  87 void *grab_fd(int fd, unsigned long *size)
  88 {
  89         struct stat st;
  90         void *map;
  91         int ret;
  92
  93         ret = fstat(fd, &st);
  94         if (ret < 0)
  95                 return NULL;
  96         *size = st.st_size;
  97         map = mmap(0, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
  98         if (map == MAP_FAILED)
  99                 map = NULL;
 100         return map;
 101 }
 102
 103 void *grab_file(const char *filename, unsigned long *size)
 104 {
 105         int fd;
 106         void *map;
 107
 108         fd = open(filename, O_RDONLY, 0);
 109         if (fd < 0)
 110                 return NULL;
 111         map = grab_fd(fd, size);
 112         close(fd);
 113         return map;
 114 }
 115
 116 void release_file(void *data, unsigned long size)
 117 {
 118         munmap(data, size);
 119 }
 120 #endif