zlib.c

   1 /*
   2  * zlib wrappers to make sure we don't silently miss errors
   3  * at init time.
   4  */
   5 #include "cache.h"
   6
   7 static const char *zerr_to_string(int status)
   8 {
   9         switch (status) {
  10         case Z_MEM_ERROR:
  11                 return "out of memory";
  12         case Z_VERSION_ERROR:
  13                 return "wrong version";
  14         case Z_NEED_DICT:
  15                 return "needs dictionary";
  16         case Z_DATA_ERROR:
  17                 return "data stream error";
  18         case Z_STREAM_ERROR:
  19                 return "stream consistency error";
  20         default:
  21                 return "unknown error";
  22         }
  23 }
  24
  25 /*
  26  * avail_in and avail_out in zlib are counted in uInt, which typically
  27  * limits the size of the buffer we can use to 4GB when interacting
  28  * with zlib in a single call to inflate/deflate.
  29  */
  30 /* #define ZLIB_BUF_MAX ((uInt)-1) */
  31 #define ZLIB_BUF_MAX ((uInt) 1024 * 1024 * 1024) /* 1GB */
  32 static inline uInt zlib_buf_cap(unsigned long len)
  33 {
  34         return (ZLIB_BUF_MAX < len) ? ZLIB_BUF_MAX : len;
  35 }
  36
  37 static void zlib_pre_call(git_zstream *s)
  38 {
  39         s->z.next_in = s->next_in;
  40         s->z.next_out = s->next_out;
  41         s->z.total_in = s->total_in;
  42         s->z.total_out = s->total_out;
  43         s->z.avail_in = zlib_buf_cap(s->avail_in);
  44         s->z.avail_out = zlib_buf_cap(s->avail_out);
  45 }
  46
  47 static void zlib_post_call(git_zstream *s)
  48 {
  49         unsigned long bytes_consumed;
  50         unsigned long bytes_produced;
  51
  52         bytes_consumed = s->z.next_in - s->next_in;
  53         bytes_produced = s->z.next_out - s->next_out;
  54         if (s->z.total_out != s->total_out + bytes_produced)
  55                 die("BUG: total_out mismatch");
  56         if (s->z.total_in != s->total_in + bytes_consumed)
  57                 die("BUG: total_in mismatch");
  58
  59         s->total_out = s->z.total_out;
  60         s->total_in = s->z.total_in;
  61         s->next_in = s->z.next_in;
  62         s->next_out = s->z.next_out;
  63         s->avail_in -= bytes_consumed;
  64         s->avail_out -= bytes_produced;
  65 }
  66
  67 void git_inflate_init(git_zstream *strm)
  68 {
  69         int status;
  70
  71         zlib_pre_call(strm);
  72         status = inflateInit(&strm->z);
  73         zlib_post_call(strm);
  74         if (status == Z_OK)
  75                 return;
  76         die("inflateInit: %s (%s)", zerr_to_string(status),
  77             strm->z.msg ? strm->z.msg : "no message");
  78 }
  79
  80 void git_inflate_init_gzip_only(git_zstream *strm)
  81 {
  82         /*
  83          * Use default 15 bits, +16 is to accept only gzip and to
  84          * yield Z_DATA_ERROR when fed zlib format.
  85          */
  86         const int windowBits = 15 + 16;
  87         int status;
  88
  89         zlib_pre_call(strm);
  90         status = inflateInit2(&strm->z, windowBits);
  91         zlib_post_call(strm);
  92         if (status == Z_OK)
  93                 return;
  94         die("inflateInit2: %s (%s)", zerr_to_string(status),
  95             strm->z.msg ? strm->z.msg : "no message");
  96 }
  97
  98 void git_inflate_end(git_zstream *strm)
  99 {
 100         int status;
 101
 102         zlib_pre_call(strm);
 103         status = inflateEnd(&strm->z);
 104         zlib_post_call(strm);
 105         if (status == Z_OK)
 106                 return;
 107         error("inflateEnd: %s (%s)", zerr_to_string(status),
 108               strm->z.msg ? strm->z.msg : "no message");
 109 }
 110
 111 int git_inflate(git_zstream *strm, int flush)
 112 {
 113         int status;
 114
 115         for (;;) {
 116                 zlib_pre_call(strm);
 117                 /* Never say Z_FINISH unless we are feeding everything */
 118                 status = inflate(&strm->z,
 119                                  (strm->z.avail_in != strm->avail_in)
 120                                  ? 0 : flush);
 121                 if (status == Z_MEM_ERROR)
 122                         die("inflate: out of memory");
 123                 zlib_post_call(strm);
 124
 125                 /*
 126                  * Let zlib work another round, while we can still
 127                  * make progress.
 128                  */
 129                 if ((strm->avail_out && !strm->z.avail_out) &&
 130                     (status == Z_OK || status == Z_BUF_ERROR))
 131                         continue;
 132                 break;
 133         }
 134
 135         switch (status) {
 136         /* Z_BUF_ERROR: normal, needs more space in the output buffer */
 137         case Z_BUF_ERROR:
 138         case Z_OK:
 139         case Z_STREAM_END:
 140                 return status;
 141         default:
 142                 break;
 143         }
 144         error("inflate: %s (%s)", zerr_to_string(status),
 145               strm->z.msg ? strm->z.msg : "no message");
 146         return status;
 147 }
 148
 149 #if defined(NO_DEFLATE_BOUND) || ZLIB_VERNUM < 0x1200
 150 #define deflateBound(c,s)  ((s) + (((s) + 7) >> 3) + (((s) + 63) >> 6) + 11)
 151 #endif
 152
 153 unsigned long git_deflate_bound(git_zstream *strm, unsigned long size)
 154 {
 155         return deflateBound(&strm->z, size);
 156 }
 157
 158 void git_deflate_init(git_zstream *strm, int level)
 159 {
 160         int status;
 161
 162         memset(strm, 0, sizeof(*strm));
 163         zlib_pre_call(strm);
 164         status = deflateInit(&strm->z, level);
 165         zlib_post_call(strm);
 166         if (status == Z_OK)
 167                 return;
 168         die("deflateInit: %s (%s)", zerr_to_string(status),
 169             strm->z.msg ? strm->z.msg : "no message");
 170 }
 171
 172 static void do_git_deflate_init(git_zstream *strm, int level, int windowBits)
 173 {
 174         int status;
 175
 176         memset(strm, 0, sizeof(*strm));
 177         zlib_pre_call(strm);
 178         status = deflateInit2(&strm->z, level,
 179                                   Z_DEFLATED, windowBits,
 180                                   8, Z_DEFAULT_STRATEGY);
 181         zlib_post_call(strm);
 182         if (status == Z_OK)
 183                 return;
 184         die("deflateInit2: %s (%s)", zerr_to_string(status),
 185             strm->z.msg ? strm->z.msg : "no message");
 186 }
 187
 188 void git_deflate_init_gzip(git_zstream *strm, int level)
 189 {
 190         /*
 191          * Use default 15 bits, +16 is to generate gzip header/trailer
 192          * instead of the zlib wrapper.
 193          */
 194         do_git_deflate_init(strm, level, 15 + 16);
 195 }
 196
 197 void git_deflate_init_raw(git_zstream *strm, int level)
 198 {
 199         /*
 200          * Use default 15 bits, negate the value to get raw compressed
 201          * data without zlib header and trailer.
 202          */
 203         do_git_deflate_init(strm, level, -15);
 204 }
 205
 206 int git_deflate_abort(git_zstream *strm)
 207 {
 208         int status;
 209
 210         zlib_pre_call(strm);
 211         status = deflateEnd(&strm->z);
 212         zlib_post_call(strm);
 213         return status;
 214 }
 215
 216 void git_deflate_end(git_zstream *strm)
 217 {
 218         int status = git_deflate_abort(strm);
 219
 220         if (status == Z_OK)
 221                 return;
 222         error("deflateEnd: %s (%s)", zerr_to_string(status),
 223               strm->z.msg ? strm->z.msg : "no message");
 224 }
 225
 226 int git_deflate_end_gently(git_zstream *strm)
 227 {
 228         int status;
 229
 230         zlib_pre_call(strm);
 231         status = deflateEnd(&strm->z);
 232         zlib_post_call(strm);
 233         return status;
 234 }
 235
 236 int git_deflate(git_zstream *strm, int flush)
 237 {
 238         int status;
 239
 240         for (;;) {
 241                 zlib_pre_call(strm);
 242
 243                 /* Never say Z_FINISH unless we are feeding everything */
 244                 status = deflate(&strm->z,
 245                                  (strm->z.avail_in != strm->avail_in)
 246                                  ? 0 : flush);
 247                 if (status == Z_MEM_ERROR)
 248                         die("deflate: out of memory");
 249                 zlib_post_call(strm);
 250
 251                 /*
 252                  * Let zlib work another round, while we can still
 253                  * make progress.
 254                  */
 255                 if ((strm->avail_out && !strm->z.avail_out) &&
 256                     (status == Z_OK || status == Z_BUF_ERROR))
 257                         continue;
 258                 break;
 259         }
 260
 261         switch (status) {
 262         /* Z_BUF_ERROR: normal, needs more space in the output buffer */
 263         case Z_BUF_ERROR:
 264         case Z_OK:
 265         case Z_STREAM_END:
 266                 return status;
 267         default:
 268                 break;
 269         }
 270         error("deflate: %s (%s)", zerr_to_string(status),
 271               strm->z.msg ? strm->z.msg : "no message");
 272         return status;
 273 }