ext/zip/lib/zip

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
zip_close
add_data
copy_data
copy_source
write_cdir
_zip_changed
   1 /*
   2   zip_close.c -- close zip archive and update changes
   3   Copyright (C) 1999-2015 Dieter Baron and Thomas Klausner
   4 
   5   This file is part of libzip, a library to manipulate ZIP archives.
   6   The authors can be contacted at <libzip@nih.at>
   7 
   8   Redistribution and use in source and binary forms, with or without
   9   modification, are permitted provided that the following conditions
  10   are met:
  11   1. Redistributions of source code must retain the above copyright
  12      notice, this list of conditions and the following disclaimer.
  13   2. Redistributions in binary form must reproduce the above copyright
  14      notice, this list of conditions and the following disclaimer in
  15      the documentation and/or other materials provided with the
  16      distribution.
  17   3. The names of the authors may not be used to endorse or promote
  18      products derived from this software without specific prior
  19      written permission.
  20  
  21   THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
  22   OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  23   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
  25   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  27   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  28   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  29   IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  30   OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  31   IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32 */
  33 
  34 
  35 #include "zipint.h"
  36 
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #ifdef HAVE_STRINGS_H
  41 #include <strings.h>
  42 #endif
  43 #ifdef HAVE_UNISTD_H
  44 #include <unistd.h>
  45 #endif
  46 #include <sys/types.h>
  47 #include <sys/stat.h>
  48 #ifdef _WIN32
  49 #include <io.h>
  50 #include <fcntl.h>
  51 #endif
  52 
  53 
  54 /* max deflate size increase: size + ceil(size/16k)*5+6 */
  55 #define MAX_DEFLATE_SIZE_32     4293656963u
  56 
  57 static int add_data(zip_t *, zip_source_t *, zip_dirent_t *);
  58 static int copy_data(zip_t *, zip_uint64_t);
  59 static int copy_source(zip_t *, zip_source_t *);
  60 static int write_cdir(zip_t *, const zip_filelist_t *, zip_uint64_t);
  61 
  62 
  63 ZIP_EXTERN int
  64 zip_close(zip_t *za)
  65 {
  66     zip_uint64_t i, j, survivors;
  67     zip_int64_t off;
  68     int error;
  69     zip_filelist_t *filelist;
  70     int changed;
  71 
  72     if (za == NULL)
  73         return -1;
  74 
  75     changed = _zip_changed(za, &survivors);
  76 
  77     /* don't create zip files with no entries */
  78     if (survivors == 0) {
  79         if ((za->open_flags & ZIP_TRUNCATE) || changed) {
  80             if (zip_source_remove(za->src) < 0) {
  81                 _zip_error_set_from_source(&za->error, za->src);
  82                 return -1;
  83             }
  84         }
  85         zip_discard(za);
  86         return 0;
  87     }          
  88 
  89     if (!changed) {
  90         zip_discard(za);
  91         return 0;
  92     }
  93 
  94     if (survivors > za->nentry) {
  95         zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
  96         return -1;
  97     }
  98     
  99     if ((filelist=(zip_filelist_t *)malloc(sizeof(filelist[0])*(size_t)survivors)) == NULL)
 100         return -1;
 101 
 102     /* create list of files with index into original archive  */
 103     for (i=j=0; i<za->nentry; i++) {
 104         if (za->entry[i].deleted)
 105             continue;
 106 
 107         if (j >= survivors) {
 108             free(filelist);
 109             zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
 110             return -1;
 111         }
 112         
 113         filelist[j].idx = i;
 114         j++;
 115     }
 116     if (j < survivors) {
 117         free(filelist);
 118         zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
 119         return -1;
 120     }
 121 
 122     if (zip_source_begin_write(za->src) < 0) {
 123         _zip_error_set_from_source(&za->error, za->src);
 124         free(filelist);
 125         return -1;
 126     }
 127     
 128     error = 0;
 129     for (j=0; j<survivors; j++) {
 130         int new_data;
 131         zip_entry_t *entry;
 132         zip_dirent_t *de;
 133 
 134         i = filelist[j].idx;
 135         entry = za->entry+i;
 136 
 137         new_data = (ZIP_ENTRY_DATA_CHANGED(entry) || ZIP_ENTRY_CHANGED(entry, ZIP_DIRENT_COMP_METHOD));
 138 
 139         /* create new local directory entry */
 140         if (entry->changes == NULL) {
 141             if ((entry->changes=_zip_dirent_clone(entry->orig)) == NULL) {
 142                 zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
 143                 error = 1;
 144                 break;
 145             }
 146         }
 147         de = entry->changes;
 148 
 149         if (_zip_read_local_ef(za, i) < 0) {
 150             error = 1;
 151             break;
 152         }
 153 
 154         if ((off = zip_source_tell_write(za->src)) < 0) {
 155             error = 1;
 156             break;
 157         }
 158         de->offset = (zip_uint64_t)off;
 159 
 160         if (new_data) {
 161             zip_source_t *zs;
 162 
 163             zs = NULL;
 164             if (!ZIP_ENTRY_DATA_CHANGED(entry)) {
 165                 if ((zs=_zip_source_zip_new(za, za, i, ZIP_FL_UNCHANGED, 0, 0, NULL)) == NULL) {
 166                     error = 1;
 167                     break;
 168                 }
 169             }
 170 
 171             /* add_data writes dirent */
 172             if (add_data(za, zs ? zs : entry->source, de) < 0) {
 173                 error = 1;
 174                 if (zs)
 175                     zip_source_free(zs);
 176                 break;
 177             }
 178             if (zs)
 179                 zip_source_free(zs);
 180         }
 181         else {
 182             zip_uint64_t offset;
 183 
 184             /* when copying data, all sizes are known -> no data descriptor needed */
 185             de->bitflags &= (zip_uint16_t)~ZIP_GPBF_DATA_DESCRIPTOR;
 186             if (_zip_dirent_write(za, de, ZIP_FL_LOCAL) < 0) {
 187                 error = 1;
 188                 break;
 189             }
 190             if ((offset=_zip_file_get_offset(za, i, &za->error)) == 0) {
 191                 error = 1;
 192                 break;
 193             }
 194             if (zip_source_seek(za->src, (zip_int64_t)offset, SEEK_SET) < 0) {
 195                 _zip_error_set_from_source(&za->error, za->src);
 196                 error = 1;
 197                 break;
 198             }
 199             if (copy_data(za, de->comp_size) < 0) {
 200                 error = 1;
 201                 break;
 202             }
 203         }
 204     }
 205 
 206     if (!error) {
 207         if (write_cdir(za, filelist, survivors) < 0)
 208             error = 1;
 209     }
 210 
 211     free(filelist);
 212 
 213     if (!error) {
 214         if (zip_source_commit_write(za->src) != 0) {
 215             _zip_error_set_from_source(&za->error, za->src);
 216             error = 1;
 217         }
 218     }
 219 
 220     if (error) {
 221         zip_source_rollback_write(za->src);
 222         return -1;
 223     }
 224 
 225     zip_discard(za);
 226     
 227     return 0;
 228 }
 229 
 230 
 231 static int
 232 add_data(zip_t *za, zip_source_t *src, zip_dirent_t *de)
 233 {
 234     zip_int64_t offstart, offdata, offend;
 235     struct zip_stat st;
 236     zip_source_t *s2;
 237     int ret;
 238     int is_zip64;
 239     zip_flags_t flags;
 240     
 241     if (zip_source_stat(src, &st) < 0) {
 242         _zip_error_set_from_source(&za->error, src);
 243         return -1;
 244     }
 245 
 246     if ((st.valid & ZIP_STAT_COMP_METHOD) == 0) {
 247         st.valid |= ZIP_STAT_COMP_METHOD;
 248         st.comp_method = ZIP_CM_STORE;
 249     }
 250 
 251     if (ZIP_CM_IS_DEFAULT(de->comp_method) && st.comp_method != ZIP_CM_STORE)
 252         de->comp_method = st.comp_method;
 253     else if (de->comp_method == ZIP_CM_STORE && (st.valid & ZIP_STAT_SIZE)) {
 254         st.valid |= ZIP_STAT_COMP_SIZE;
 255         st.comp_size = st.size;
 256     }
 257     else {
 258         /* we'll recompress */
 259         st.valid &= ~ZIP_STAT_COMP_SIZE;
 260     }
 261 
 262 
 263     flags = ZIP_EF_LOCAL;
 264 
 265     if ((st.valid & ZIP_STAT_SIZE) == 0)
 266         flags |= ZIP_FL_FORCE_ZIP64;
 267     else {
 268         de->uncomp_size = st.size;
 269         
 270         if ((st.valid & ZIP_STAT_COMP_SIZE) == 0) {
 271             if (( ((de->comp_method == ZIP_CM_DEFLATE || ZIP_CM_IS_DEFAULT(de->comp_method)) && st.size > MAX_DEFLATE_SIZE_32)
 272                   || (de->comp_method != ZIP_CM_STORE && de->comp_method != ZIP_CM_DEFLATE && !ZIP_CM_IS_DEFAULT(de->comp_method))))
 273                 flags |= ZIP_FL_FORCE_ZIP64;
 274         }
 275         else
 276             de->comp_size = st.comp_size;
 277     }
 278 
 279     if ((offstart = zip_source_tell_write(za->src)) < 0) {
 280         return -1;
 281     }
 282 
 283     /* as long as we don't support non-seekable output, clear data descriptor bit */
 284     de->bitflags &= (zip_uint16_t)~ZIP_GPBF_DATA_DESCRIPTOR;
 285     if ((is_zip64=_zip_dirent_write(za, de, flags)) < 0)
 286         return -1;
 287 
 288 
 289     if (st.comp_method == ZIP_CM_STORE || (ZIP_CM_IS_DEFAULT(de->comp_method) && st.comp_method != de->comp_method)) {
 290         zip_source_t *s_store, *s_crc;
 291         zip_compression_implementation comp_impl;
 292         
 293         if (st.comp_method != ZIP_CM_STORE) {
 294             if ((comp_impl=_zip_get_compression_implementation(st.comp_method)) == NULL) {
 295                 zip_error_set(&za->error, ZIP_ER_COMPNOTSUPP, 0);
 296                 return -1;
 297             }
 298             if ((s_store=comp_impl(za, src, st.comp_method, ZIP_CODEC_DECODE)) == NULL) {
 299                 /* error set by comp_impl */
 300                 return -1;
 301             }
 302         }
 303         else {
 304             /* to have the same reference count to src as in the case where it's not stored */
 305             zip_source_keep(src);
 306             s_store = src;
 307         }
 308 
 309         s_crc = zip_source_crc(za, s_store, 0);
 310         zip_source_free(s_store);
 311         if (s_crc == NULL) {
 312             return -1;
 313         }
 314 
 315         if (de->comp_method != ZIP_CM_STORE && ((st.valid & ZIP_STAT_SIZE) == 0 || st.size != 0)) {
 316             if ((comp_impl=_zip_get_compression_implementation(de->comp_method)) == NULL) {
 317                 zip_error_set(&za->error, ZIP_ER_COMPNOTSUPP, 0);
 318                 zip_source_free(s_crc);
 319                 return -1;
 320             }
 321             s2 = comp_impl(za, s_crc, de->comp_method, ZIP_CODEC_ENCODE);
 322             zip_source_free(s_crc);
 323             if (s2 == NULL) {
 324                 return -1;
 325             }
 326         }
 327         else {
 328             s2 = s_crc;
 329         }
 330     }
 331     else {
 332         zip_source_keep(src);
 333         s2 = src;
 334     }
 335 
 336     if ((offdata = zip_source_tell_write(za->src)) < 0) {
 337         return -1;
 338     }
 339 
 340     ret = copy_source(za, s2);
 341         
 342     if (zip_source_stat(s2, &st) < 0)
 343         ret = -1;
 344 
 345     zip_source_free(s2);
 346 
 347     if (ret < 0)
 348         return -1;
 349 
 350     if ((offend = zip_source_tell_write(za->src)) < 0) {
 351         return -1;
 352     }
 353 
 354     if (zip_source_seek_write(za->src, offstart, SEEK_SET) < 0) {
 355         _zip_error_set_from_source(&za->error, za->src);
 356         return -1;
 357     }
 358 
 359     if ((st.valid & (ZIP_STAT_COMP_METHOD|ZIP_STAT_CRC|ZIP_STAT_SIZE)) != (ZIP_STAT_COMP_METHOD|ZIP_STAT_CRC|ZIP_STAT_SIZE)) {
 360         zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
 361         return -1;
 362     }
 363 
 364     if ((de->changed & ZIP_DIRENT_LAST_MOD) == 0) {
 365         if (st.valid & ZIP_STAT_MTIME)
 366             de->last_mod = st.mtime;
 367         else
 368             time(&de->last_mod);
 369     }
 370     de->comp_method = st.comp_method;
 371     de->crc = st.crc;
 372     de->uncomp_size = st.size;
 373     de->comp_size = (zip_uint64_t)(offend - offdata);
 374 
 375     if ((ret=_zip_dirent_write(za, de, flags)) < 0)
 376         return -1;
 377  
 378     if (is_zip64 != ret) {
 379         /* Zip64 mismatch between preliminary file header written before data and final file header written afterwards */
 380         zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
 381         return -1;
 382     }
 383 
 384    
 385     if (zip_source_seek_write(za->src, offend, SEEK_SET) < 0) {
 386         _zip_error_set_from_source(&za->error, za->src);
 387         return -1;
 388     }
 389 
 390     return 0;
 391 }
 392 
 393 
 394 static int
 395 copy_data(zip_t *za, zip_uint64_t len)
 396 {
 397     zip_uint8_t buf[BUFSIZE];
 398     size_t n;
 399 
 400     while (len > 0) {
 401         n = len > sizeof(buf) ? sizeof(buf) : len;
 402         if (_zip_read(za->src, buf, n, &za->error) < 0) {
 403             return -1;
 404         }
 405 
 406         if (_zip_write(za, buf, n) < 0) {
 407             return -1;
 408         }
 409         
 410         len -= n;
 411     }
 412 
 413     return 0;
 414 }
 415 
 416 
 417 static int
 418 copy_source(zip_t *za, zip_source_t *src)
 419 {
 420     zip_uint8_t buf[BUFSIZE];
 421     zip_int64_t n;
 422     int ret;
 423 
 424     if (zip_source_open(src) < 0) {
 425         _zip_error_set_from_source(&za->error, src);
 426         return -1;
 427     }
 428 
 429     ret = 0;
 430     while ((n=zip_source_read(src, buf, sizeof(buf))) > 0) {
 431         if (_zip_write(za, buf, (zip_uint64_t)n) < 0) {
 432             ret = -1;
 433             break;
 434         }
 435     }
 436     
 437     if (n < 0) {
 438         _zip_error_set_from_source(&za->error, src);
 439         ret = -1;
 440     }
 441 
 442     zip_source_close(src);
 443     
 444     return ret;
 445 }
 446 
 447 
 448 static int
 449 write_cdir(zip_t *za, const zip_filelist_t *filelist, zip_uint64_t survivors)
 450 {
 451     zip_int64_t cd_start, end, size;
 452     
 453     if ((cd_start = zip_source_tell_write(za->src)) < 0) {
 454         return -1;
 455     }
 456 
 457     if ((size=_zip_cdir_write(za, filelist, survivors)) < 0) {
 458         return -1;
 459     }
 460     
 461     if ((end = zip_source_tell_write(za->src)) < 0) {
 462         return -1;
 463     }
 464 
 465     return 0;
 466 }
 467 
 468 
 469 int
 470 _zip_changed(const zip_t *za, zip_uint64_t *survivorsp)
 471 {
 472     int changed;
 473     zip_uint64_t i, survivors;
 474 
 475     changed = 0;
 476     survivors = 0;
 477 
 478     if (za->comment_changed || za->ch_flags != za->flags)
 479         changed = 1;
 480 
 481     for (i=0; i<za->nentry; i++) {
 482         if (za->entry[i].deleted || za->entry[i].source || (za->entry[i].changes && za->entry[i].changes->changed != 0))
 483             changed = 1;
 484         if (!za->entry[i].deleted)
 485             survivors++;
 486     }
 487 
 488     if (survivorsp)
 489         *survivorsp = survivors;
 490 
 491     return changed;
 492 }
/* [<][>][^][v][top][bottom][index][help] */
root/ext/zip/lib/zip_close.c

DEFINITIONS
