1 /* 2 * Copyright (c) 2011, Novell Inc. 3 * 4 * This program is licensed under the BSD license, read LICENSE.BSD 5 * for further information 6 */ 7 8 #define _GNU_SOURCE 9 10 #include <stdio.h> 11 #include <stdlib.h> 12 #include <string.h> 13 #include <zlib.h> 14 #include <fcntl.h> 15 16 #include "solv_xfopen.h" 17 #include "util.h" 18 19 20 static FILE *cookieopen(void *cookie, const char *mode, 21 ssize_t (*cread)(void *, char *, size_t), 22 ssize_t (*cwrite)(void *, const char *, size_t), 23 int (*cclose)(void *)) 24 { 25 #ifdef HAVE_FUNOPEN 26 if (!cookie) 27 return 0; 28 return funopen(cookie, 29 (int (*)(void *, char *, int))(*mode == 'r' ? cread : NULL), /* readfn */ 30 (int (*)(void *, const char *, int))(*mode == 'w' ? cwrite : NULL), /* writefn */ 31 (fpos_t (*)(void *, fpos_t, int))NULL, /* seekfn */ 32 cclose 33 ); 34 #elif defined(HAVE_FOPENCOOKIE) 35 cookie_io_functions_t cio; 36 37 if (!cookie) 38 return 0; 39 memset(&cio, 0, sizeof(cio)); 40 if (*mode == 'r') 41 cio.read = cread; 42 else if (*mode == 'w') 43 cio.write = cwrite; 44 cio.close = cclose; 45 return fopencookie(cookie, *mode == 'w' ? "w" : "r", cio); 46 #else 47 # error Need to implement custom I/O 48 #endif 49 } 50 51 52 /* gzip compression */ 53 54 static ssize_t cookie_gzread(void *cookie, char *buf, size_t nbytes) 55 { 56 return gzread((gzFile)cookie, buf, nbytes); 57 } 58 59 static ssize_t cookie_gzwrite(void *cookie, const char *buf, size_t nbytes) 60 { 61 return gzwrite((gzFile)cookie, buf, nbytes); 62 } 63 64 static int cookie_gzclose(void *cookie) 65 { 66 return gzclose((gzFile)cookie); 67 } 68 69 static inline FILE *mygzfopen(const char *fn, const char *mode) 70 { 71 gzFile gzf = gzopen(fn, mode); 72 return cookieopen(gzf, mode, cookie_gzread, cookie_gzwrite, cookie_gzclose); 73 } 74 75 static inline FILE *mygzfdopen(int fd, const char *mode) 76 { 77 gzFile gzf = gzdopen(fd, mode); 78 return cookieopen(gzf, mode, cookie_gzread, cookie_gzwrite, cookie_gzclose); 79 } 80 81 #ifdef ENABLE_BZIP2_COMPRESSION 82 83 #include <bzlib.h> 84 85 /* bzip2 compression */ 86 87 static ssize_t cookie_bzread(void *cookie, char *buf, size_t nbytes) 88 { 89 return BZ2_bzread((BZFILE *)cookie, buf, nbytes); 90 } 91 92 static ssize_t cookie_bzwrite(void *cookie, const char *buf, size_t nbytes) 93 { 94 return BZ2_bzwrite((BZFILE *)cookie, (char *)buf, nbytes); 95 } 96 97 static int cookie_bzclose(void *cookie) 98 { 99 BZ2_bzclose((BZFILE *)cookie); 100 return 0; 101 } 102 103 static inline FILE *mybzfopen(const char *fn, const char *mode) 104 { 105 BZFILE *bzf = BZ2_bzopen(fn, mode); 106 return cookieopen(bzf, mode, cookie_bzread, cookie_bzwrite, cookie_bzclose); 107 } 108 109 static inline FILE *mybzfdopen(int fd, const char *mode) 110 { 111 BZFILE *bzf = BZ2_bzdopen(fd, mode); 112 return cookieopen(bzf, mode, cookie_bzread, cookie_bzwrite, cookie_bzclose); 113 } 114 115 #endif 116 117 118 #ifdef ENABLE_LZMA_COMPRESSION 119 120 #include <lzma.h> 121 122 /* lzma code written by me in 2008 for rpm's rpmio.c */ 123 124 typedef struct lzfile { 125 unsigned char buf[1 << 15]; 126 lzma_stream strm; 127 FILE *file; 128 int encoding; 129 int eof; 130 } LZFILE; 131 132 static inline lzma_ret setup_alone_encoder(lzma_stream *strm, int level) 133 { 134 lzma_options_lzma options; 135 lzma_lzma_preset(&options, level); 136 return lzma_alone_encoder(strm, &options); 137 } 138 139 static lzma_stream stream_init = LZMA_STREAM_INIT; 140 141 static LZFILE *lzopen(const char *path, const char *mode, int fd, int isxz) 142 { 143 int level = 7; 144 int encoding = 0; 145 FILE *fp; 146 LZFILE *lzfile; 147 lzma_ret ret; 148 149 if (!path && fd < 0) 150 return 0; 151 for (; *mode; mode++) 152 { 153 if (*mode == 'w') 154 encoding = 1; 155 else if (*mode == 'r') 156 encoding = 0; 157 else if (*mode >= '1' && *mode <= '9') 158 level = *mode - '0'; 159 } 160 if (fd != -1) 161 fp = fdopen(fd, encoding ? "w" : "r"); 162 else 163 fp = fopen(path, encoding ? "w" : "r"); 164 if (!fp) 165 return 0; 166 lzfile = calloc(1, sizeof(*lzfile)); 167 if (!lzfile) 168 { 169 fclose(fp); 170 return 0; 171 } 172 lzfile->file = fp; 173 lzfile->encoding = encoding; 174 lzfile->eof = 0; 175 lzfile->strm = stream_init; 176 if (encoding) 177 { 178 if (isxz) 179 ret = lzma_easy_encoder(&lzfile->strm, level, LZMA_CHECK_SHA256); 180 else 181 ret = setup_alone_encoder(&lzfile->strm, level); 182 } 183 else 184 ret = lzma_auto_decoder(&lzfile->strm, 100 << 20, 0); 185 if (ret != LZMA_OK) 186 { 187 fclose(fp); 188 free(lzfile); 189 return 0; 190 } 191 return lzfile; 192 } 193 194 static int lzclose(void *cookie) 195 { 196 LZFILE *lzfile = cookie; 197 lzma_ret ret; 198 size_t n; 199 int rc; 200 201 if (!lzfile) 202 return -1; 203 if (lzfile->encoding) 204 { 205 for (;;) 206 { 207 lzfile->strm.avail_out = sizeof(lzfile->buf); 208 lzfile->strm.next_out = lzfile->buf; 209 ret = lzma_code(&lzfile->strm, LZMA_FINISH); 210 if (ret != LZMA_OK && ret != LZMA_STREAM_END) 211 return -1; 212 n = sizeof(lzfile->buf) - lzfile->strm.avail_out; 213 if (n && fwrite(lzfile->buf, 1, n, lzfile->file) != n) 214 return -1; 215 if (ret == LZMA_STREAM_END) 216 break; 217 } 218 } 219 lzma_end(&lzfile->strm); 220 rc = fclose(lzfile->file); 221 free(lzfile); 222 return rc; 223 } 224 225 static ssize_t lzread(void *cookie, char *buf, size_t len) 226 { 227 LZFILE *lzfile = cookie; 228 lzma_ret ret; 229 int eof = 0; 230 231 if (!lzfile || lzfile->encoding) 232 return -1; 233 if (lzfile->eof) 234 return 0; 235 lzfile->strm.next_out = (unsigned char *)buf; 236 lzfile->strm.avail_out = len; 237 for (;;) 238 { 239 if (!lzfile->strm.avail_in) 240 { 241 lzfile->strm.next_in = lzfile->buf; 242 lzfile->strm.avail_in = fread(lzfile->buf, 1, sizeof(lzfile->buf), lzfile->file); 243 if (!lzfile->strm.avail_in) 244 eof = 1; 245 } 246 ret = lzma_code(&lzfile->strm, LZMA_RUN); 247 if (ret == LZMA_STREAM_END) 248 { 249 lzfile->eof = 1; 250 return len - lzfile->strm.avail_out; 251 } 252 if (ret != LZMA_OK) 253 return -1; 254 if (!lzfile->strm.avail_out) 255 return len; 256 if (eof) 257 return -1; 258 } 259 } 260 261 static ssize_t lzwrite(void *cookie, const char *buf, size_t len) 262 { 263 LZFILE *lzfile = cookie; 264 lzma_ret ret; 265 size_t n; 266 if (!lzfile || !lzfile->encoding) 267 return -1; 268 if (!len) 269 return 0; 270 lzfile->strm.next_in = (unsigned char *)buf; 271 lzfile->strm.avail_in = len; 272 for (;;) 273 { 274 lzfile->strm.next_out = lzfile->buf; 275 lzfile->strm.avail_out = sizeof(lzfile->buf); 276 ret = lzma_code(&lzfile->strm, LZMA_RUN); 277 if (ret != LZMA_OK) 278 return -1; 279 n = sizeof(lzfile->buf) - lzfile->strm.avail_out; 280 if (n && fwrite(lzfile->buf, 1, n, lzfile->file) != n) 281 return -1; 282 if (!lzfile->strm.avail_in) 283 return len; 284 } 285 } 286 287 static inline FILE *myxzfopen(const char *fn, const char *mode) 288 { 289 LZFILE *lzf = lzopen(fn, mode, -1, 1); 290 return cookieopen(lzf, mode, lzread, lzwrite, lzclose); 291 } 292 293 static inline FILE *myxzfdopen(int fd, const char *mode) 294 { 295 LZFILE *lzf = lzopen(0, mode, fd, 1); 296 return cookieopen(lzf, mode, lzread, lzwrite, lzclose); 297 } 298 299 static inline FILE *mylzfopen(const char *fn, const char *mode) 300 { 301 LZFILE *lzf = lzopen(fn, mode, -1, 0); 302 return cookieopen(lzf, mode, lzread, lzwrite, lzclose); 303 } 304 305 static inline FILE *mylzfdopen(int fd, const char *mode) 306 { 307 LZFILE *lzf = lzopen(0, mode, fd, 0); 308 return cookieopen(lzf, mode, lzread, lzwrite, lzclose); 309 } 310 311 #endif /* ENABLE_LZMA_COMPRESSION */ 312 313 314 FILE * 315 solv_xfopen(const char *fn, const char *mode) 316 { 317 char *suf; 318 319 if (!fn) 320 return 0; 321 if (!mode) 322 mode = "r"; 323 suf = strrchr(fn, '.'); 324 if (suf && !strcmp(suf, ".gz")) 325 return mygzfopen(fn, mode); 326 #ifdef ENABLE_LZMA_COMPRESSION 327 if (suf && !strcmp(suf, ".xz")) 328 return myxzfopen(fn, mode); 329 if (suf && !strcmp(suf, ".lzma")) 330 return mylzfopen(fn, mode); 331 #else 332 if (suf && !strcmp(suf, ".xz")) 333 return 0; 334 if (suf && !strcmp(suf, ".lzma")) 335 return 0; 336 #endif 337 #ifdef ENABLE_BZIP2_COMPRESSION 338 if (suf && !strcmp(suf, ".bz2")) 339 return mybzfopen(fn, mode); 340 #else 341 if (suf && !strcmp(suf, ".bz2")) 342 return 0; 343 #endif 344 return fopen(fn, mode); 345 } 346 347 FILE * 348 solv_xfopen_fd(const char *fn, int fd, const char *mode) 349 { 350 const char *simplemode = mode; 351 char *suf; 352 353 suf = fn ? strrchr(fn, '.') : 0; 354 if (!mode) 355 { 356 int fl = fcntl(fd, F_GETFL, 0); 357 if (fl == -1) 358 return 0; 359 fl &= O_RDONLY|O_WRONLY|O_RDWR; 360 if (fl == O_WRONLY) 361 mode = simplemode = "w"; 362 else if (fl == O_RDWR) 363 { 364 mode = "r+"; 365 simplemode = "r"; 366 } 367 else 368 mode = simplemode = "r"; 369 } 370 if (suf && !strcmp(suf, ".gz")) 371 return mygzfdopen(fd, simplemode); 372 #ifdef ENABLE_LZMA_COMPRESSION 373 if (suf && !strcmp(suf, ".xz")) 374 return myxzfdopen(fd, simplemode); 375 if (suf && !strcmp(suf, ".lzma")) 376 return mylzfdopen(fd, simplemode); 377 #else 378 if (suf && !strcmp(suf, ".xz")) 379 return 0; 380 if (suf && !strcmp(suf, ".lzma")) 381 return 0; 382 #endif 383 #ifdef ENABLE_BZIP2_COMPRESSION 384 if (suf && !strcmp(suf, ".bz2")) 385 return mybzfdopen(fd, simplemode); 386 #else 387 if (suf && !strcmp(suf, ".bz2")) 388 return 0; 389 #endif 390 return fdopen(fd, mode); 391 } 392 393 int 394 solv_xfopen_iscompressed(const char *fn) 395 { 396 const char *suf = fn ? strrchr(fn, '.') : 0; 397 if (!suf) 398 return 0; 399 if (!strcmp(suf, ".gz")) 400 return 1; 401 if (!strcmp(suf, ".xz") || !strcmp(suf, ".lzma")) 402 #ifdef ENABLE_LZMA_COMPRESSION 403 return 1; 404 #else 405 return -1; 406 #endif 407 if (!strcmp(suf, ".bz2")) 408 #ifdef ENABLE_BZIP2_COMPRESSION 409 return 1; 410 #else 411 return -1; 412 #endif 413 return 0; 414 } 415 416 struct bufcookie { 417 char **bufp; 418 size_t *buflp; 419 char *freemem; 420 size_t bufl_int; 421 }; 422 423 static ssize_t cookie_bufread(void *cookie, char *buf, size_t nbytes) 424 { 425 struct bufcookie *bc = cookie; 426 size_t n = *bc->buflp > nbytes ? nbytes : *bc->buflp; 427 if (n) 428 { 429 memcpy(buf, *bc->bufp, n); 430 *bc->bufp += n; 431 *bc->buflp -= n; 432 } 433 return n; 434 } 435 436 static ssize_t cookie_bufwrite(void *cookie, const char *buf, size_t nbytes) 437 { 438 struct bufcookie *bc = cookie; 439 int n = nbytes > 0x40000000 ? 0x40000000 : nbytes; 440 if (n) 441 { 442 *bc->bufp = solv_extend(*bc->bufp, *bc->buflp, n + 1, 1, 4095); 443 memcpy(*bc->bufp, buf, n); 444 (*bc->bufp)[n] = 0; /* zero-terminate */ 445 *bc->buflp += n; 446 } 447 return n; 448 } 449 450 static int cookie_bufclose(void *cookie) 451 { 452 struct bufcookie *bc = cookie; 453 if (bc->freemem) 454 solv_free(bc->freemem); 455 solv_free(bc); 456 return 0; 457 } 458 459 FILE * 460 solv_xfopen_buf(const char *fn, char **bufp, size_t *buflp, const char *mode) 461 { 462 struct bufcookie *bc; 463 FILE *fp; 464 if (*mode != 'r' && *mode != 'w') 465 return 0; 466 bc = solv_calloc(1, sizeof(*bc)); 467 bc->freemem = 0; 468 bc->bufp = bufp; 469 if (!buflp) 470 { 471 bc->bufl_int = *mode == 'w' ? 0 : strlen(*bufp); 472 buflp = &bc->bufl_int; 473 } 474 bc->buflp = buflp; 475 if (*mode == 'w') 476 { 477 *bc->bufp = solv_extend(0, 0, 1, 1, 4095); /* always zero-terminate */ 478 (*bc->bufp)[0] = 0; 479 *bc->buflp = 0; 480 } 481 fp = cookieopen(bc, mode, cookie_bufread, cookie_bufwrite, cookie_bufclose); 482 if (!strcmp(mode, "rf")) /* auto-free */ 483 bc->freemem = *bufp; 484 if (!fp) 485 { 486 if (*mode == 'w') 487 *bc->bufp = solv_free(*bc->bufp); 488 cookie_bufclose(bc); 489 } 490 return fp; 491 } 492