contrib/libarchive/libarchive/archive_write_set_format_zip.c

   1 /*-
   2  * Copyright (c) 2008 Anselm Strauss
   3  * Copyright (c) 2009 Joerg Sonnenberger
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 /*
  28  * Development supported by Google Summer of Code 2008.
  29  */
  30
  31 /*
  32  * The current implementation is very limited:
  33  *
  34  *   - No encryption support.
  35  *   - No ZIP64 support.
  36  *   - No support for splitting and spanning.
  37  *   - Only supports regular file and folder entries.
  38  *
  39  * Note that generally data in ZIP files is little-endian encoded,
  40  * with some exceptions.
  41  *
  42  * TODO: Since Libarchive is generally 64bit oriented, but this implementation
  43  * does not yet support sizes exceeding 32bit, it is highly fragile for
  44  * big archives. This should change when ZIP64 is finally implemented, otherwise
  45  * some serious checking has to be done.
  46  *
  47  */
  48
  49 #include "archive_platform.h"
  50 __FBSDID("$FreeBSD: head/lib/libarchive/archive_write_set_format_zip.c 201168 2009-12-29 06:15:32Z kientzle $");
  51
  52 #ifdef HAVE_ERRNO_H
  53 #include <errno.h>
  54 #endif
  55 #include <stdio.h>
  56 #ifdef HAVE_STDLIB_H
  57 #include <stdlib.h>
  58 #endif
  59 #ifdef HAVE_STRING_H
  60 #include <string.h>
  61 #endif
  62 #ifdef HAVE_ZLIB_H
  63 #include <zlib.h>
  64 #endif
  65
  66 #include "archive.h"
  67 #include "archive_endian.h"
  68 #include "archive_entry.h"
  69 #include "archive_private.h"
  70 #include "archive_write_private.h"
  71
  72 #ifndef HAVE_ZLIB_H
  73 #include "archive_crc32.h"
  74 #endif
  75
  76 #define ZIP_SIGNATURE_LOCAL_FILE_HEADER 0x04034b50
  77 #define ZIP_SIGNATURE_DATA_DESCRIPTOR 0x08074b50
  78 #define ZIP_SIGNATURE_FILE_HEADER 0x02014b50
  79 #define ZIP_SIGNATURE_CENTRAL_DIRECTORY_END 0x06054b50
  80 #define ZIP_SIGNATURE_EXTRA_TIMESTAMP 0x5455
  81 #define ZIP_SIGNATURE_EXTRA_UNIX 0x7855
  82 #define ZIP_VERSION_EXTRACT 0x0014 /* ZIP version 2.0 is needed. */
  83 #define ZIP_VERSION_BY 0x0314 /* Made by UNIX, using ZIP version 2.0. */
  84 #define ZIP_FLAGS 0x08 /* Flagging bit 3 (count from 0) for using data descriptor. */
  85
  86 enum compression {
  87         COMPRESSION_STORE = 0
  88 #ifdef HAVE_ZLIB_H
  89         ,
  90         COMPRESSION_DEFLATE = 8
  91 #endif
  92 };
  93
  94 static ssize_t archive_write_zip_data(struct archive_write *, const void *buff, size_t s);
  95 static int archive_write_zip_finish(struct archive_write *);
  96 static int archive_write_zip_destroy(struct archive_write *);
  97 static int archive_write_zip_finish_entry(struct archive_write *);
  98 static int archive_write_zip_header(struct archive_write *, struct archive_entry *);
  99 static unsigned int dos_time(const time_t);
 100 static size_t path_length(struct archive_entry *);
 101 static int write_path(struct archive_entry *, struct archive_write *);
 102
 103 struct zip_local_file_header {
 104         char signature[4];
 105         char version[2];
 106         char flags[2];
 107         char compression[2];
 108         char timedate[4];
 109         char crc32[4];
 110         char compressed_size[4];
 111         char uncompressed_size[4];
 112         char filename_length[2];
 113         char extra_length[2];
 114 };
 115
 116 struct zip_file_header {
 117         char signature[4];
 118         char version_by[2];
 119         char version_extract[2];
 120         char flags[2];
 121         char compression[2];
 122         char timedate[4];
 123         char crc32[4];
 124         char compressed_size[4];
 125         char uncompressed_size[4];
 126         char filename_length[2];
 127         char extra_length[2];
 128         char comment_length[2];
 129         char disk_number[2];
 130         char attributes_internal[2];
 131         char attributes_external[4];
 132         char offset[4];
 133 };
 134
 135 struct zip_data_descriptor {
 136         char signature[4]; /* Not mandatory, but recommended by specification. */
 137         char crc32[4];
 138         char compressed_size[4];
 139         char uncompressed_size[4];
 140 };
 141
 142 struct zip_extra_data_local {
 143         char time_id[2];
 144         char time_size[2];
 145         char time_flag[1];
 146         char mtime[4];
 147         char atime[4];
 148         char ctime[4];
 149         char unix_id[2];
 150         char unix_size[2];
 151         char unix_uid[2];
 152         char unix_gid[2];
 153 };
 154
 155 struct zip_extra_data_central {
 156         char time_id[2];
 157         char time_size[2];
 158         char time_flag[1];
 159         char mtime[4];
 160         char unix_id[2];
 161         char unix_size[2];
 162 };
 163
 164 struct zip_file_header_link {
 165         struct zip_file_header_link *next;
 166         struct archive_entry *entry;
 167         off_t offset;
 168         unsigned long crc32;
 169         off_t compressed_size;
 170         enum compression compression;
 171 };
 172
 173 struct zip {
 174         struct zip_data_descriptor data_descriptor;
 175         struct zip_file_header_link *central_directory;
 176         struct zip_file_header_link *central_directory_end;
 177         int64_t offset;
 178         int64_t written_bytes;
 179         int64_t remaining_data_bytes;
 180         enum compression compression;
 181
 182 #ifdef HAVE_ZLIB_H
 183         z_stream stream;
 184         size_t len_buf;
 185         unsigned char *buf;
 186 #endif
 187 };
 188
 189 struct zip_central_directory_end {
 190         char signature[4];
 191         char disk[2];
 192         char start_disk[2];
 193         char entries_disk[2];
 194         char entries[2];
 195         char size[4];
 196         char offset[4];
 197         char comment_length[2];
 198 };
 199
 200 static int
 201 archive_write_zip_options(struct archive_write *a, const char *key,
 202     const char *value)
 203 {
 204         struct zip *zip = a->format_data;
 205
 206         if (strcmp(key, "compression") == 0) {
 207                 if (strcmp(value, "deflate") == 0) {
 208 #ifdef HAVE_ZLIB_H
 209                         zip->compression = COMPRESSION_DEFLATE;
 210 #else
 211                         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
 212                             "deflate compression not supported");
 213                         return ARCHIVE_WARN;
 214 #endif
 215                 } else if (strcmp(value, "store") == 0)
 216                         zip->compression = COMPRESSION_STORE;
 217                 else
 218                         return (ARCHIVE_WARN);
 219                 return (ARCHIVE_OK);
 220         }
 221         return (ARCHIVE_WARN);
 222 }
 223
 224 int
 225 archive_write_set_format_zip(struct archive *_a)
 226 {
 227         struct archive_write *a = (struct archive_write *)_a;
 228         struct zip *zip;
 229
 230         /* If another format was already registered, unregister it. */
 231         if (a->format_destroy != NULL)
 232                 (a->format_destroy)(a);
 233
 234         zip = (struct zip *) calloc(1, sizeof(*zip));
 235         if (zip == NULL) {
 236                 archive_set_error(&a->archive, ENOMEM, "Can't allocate zip data");
 237                 return (ARCHIVE_FATAL);
 238         }
 239         zip->central_directory = NULL;
 240         zip->central_directory_end = NULL;
 241         zip->offset = 0;
 242         zip->written_bytes = 0;
 243         zip->remaining_data_bytes = 0;
 244
 245 #ifdef HAVE_ZLIB_H
 246         zip->compression = COMPRESSION_DEFLATE;
 247         zip->len_buf = 65536;
 248         zip->buf = malloc(zip->len_buf);
 249         if (zip->buf == NULL) {
 250                 archive_set_error(&a->archive, ENOMEM, "Can't allocate compression buffer");
 251                 return (ARCHIVE_FATAL);
 252         }
 253 #else
 254         zip->compression = COMPRESSION_STORE;
 255 #endif
 256
 257         a->format_data = zip;
 258
 259         a->pad_uncompressed = 0; /* Actually not needed for now, since no compression support yet. */
 260         a->format_name = "zip";
 261         a->format_options = archive_write_zip_options;
 262         a->format_write_header = archive_write_zip_header;
 263         a->format_write_data = archive_write_zip_data;
 264         a->format_finish_entry = archive_write_zip_finish_entry;
 265         a->format_finish = archive_write_zip_finish;
 266         a->format_destroy = archive_write_zip_destroy;
 267         a->archive.archive_format = ARCHIVE_FORMAT_ZIP;
 268         a->archive.archive_format_name = "ZIP";
 269
 270         archive_le32enc(&zip->data_descriptor.signature,
 271             ZIP_SIGNATURE_DATA_DESCRIPTOR);
 272
 273         return (ARCHIVE_OK);
 274 }
 275
 276 static int
 277 archive_write_zip_header(struct archive_write *a, struct archive_entry *entry)
 278 {
 279         struct zip *zip;
 280         struct zip_local_file_header h;
 281         struct zip_extra_data_local e;
 282         struct zip_data_descriptor *d;
 283         struct zip_file_header_link *l;
 284         int ret;
 285         int64_t size;
 286         mode_t type;
 287
 288         /* Entries other than a regular file or a folder are skipped. */
 289         type = archive_entry_filetype(entry);
 290         if ((type != AE_IFREG) & (type != AE_IFDIR)) {
 291                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, "Filetype not supported");
 292                 return ARCHIVE_FAILED;
 293         };
 294
 295         /* Directory entries should have a size of 0. */
 296         if (type == AE_IFDIR)
 297                 archive_entry_set_size(entry, 0);
 298
 299         zip = a->format_data;
 300         d = &zip->data_descriptor;
 301         size = archive_entry_size(entry);
 302         zip->remaining_data_bytes = size;
 303
 304         /* Append archive entry to the central directory data. */
 305         l = (struct zip_file_header_link *) malloc(sizeof(*l));
 306         if (l == NULL) {
 307                 archive_set_error(&a->archive, ENOMEM, "Can't allocate zip header data");
 308                 return (ARCHIVE_FATAL);
 309         }
 310         l->entry = archive_entry_clone(entry);
 311         /* Initialize the CRC variable and potentially the local crc32(). */
 312         l->crc32 = crc32(0, NULL, 0);
 313         l->compression = zip->compression;
 314         l->compressed_size = 0;
 315         l->next = NULL;
 316         if (zip->central_directory == NULL) {
 317                 zip->central_directory = l;
 318         } else {
 319                 zip->central_directory_end->next = l;
 320         }
 321         zip->central_directory_end = l;
 322
 323         /* Store the offset of this header for later use in central directory. */
 324         l->offset = zip->written_bytes;
 325
 326         memset(&h, 0, sizeof(h));
 327         archive_le32enc(&h.signature, ZIP_SIGNATURE_LOCAL_FILE_HEADER);
 328         archive_le16enc(&h.version, ZIP_VERSION_EXTRACT);
 329         archive_le16enc(&h.flags, ZIP_FLAGS);
 330         archive_le16enc(&h.compression, zip->compression);
 331         archive_le32enc(&h.timedate, dos_time(archive_entry_mtime(entry)));
 332         archive_le16enc(&h.filename_length, (uint16_t)path_length(entry));
 333
 334         switch (zip->compression) {
 335         case COMPRESSION_STORE:
 336                 /* Setting compressed and uncompressed sizes even when specification says
 337                  * to set to zero when using data descriptors. Otherwise the end of the
 338                  * data for an entry is rather difficult to find. */
 339                 archive_le32enc(&h.compressed_size, size);
 340                 archive_le32enc(&h.uncompressed_size, size);
 341                 break;
 342 #ifdef HAVE_ZLIB_H
 343         case COMPRESSION_DEFLATE:
 344                 archive_le32enc(&h.uncompressed_size, size);
 345
 346                 zip->stream.zalloc = Z_NULL;
 347                 zip->stream.zfree = Z_NULL;
 348                 zip->stream.opaque = Z_NULL;
 349                 zip->stream.next_out = zip->buf;
 350                 zip->stream.avail_out = zip->len_buf;
 351                 if (deflateInit2(&zip->stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
 352                     -15, 8, Z_DEFAULT_STRATEGY) != Z_OK) {
 353                         archive_set_error(&a->archive, ENOMEM, "Can't init deflate compressor");
 354                         return (ARCHIVE_FATAL);
 355                 }
 356                 break;
 357 #endif
 358         }
 359
 360         /* Formatting extra data. */
 361         archive_le16enc(&h.extra_length, sizeof(e));
 362         archive_le16enc(&e.time_id, ZIP_SIGNATURE_EXTRA_TIMESTAMP);
 363         archive_le16enc(&e.time_size, sizeof(e.time_flag) +
 364             sizeof(e.mtime) + sizeof(e.atime) + sizeof(e.ctime));
 365         e.time_flag[0] = 0x07;
 366         archive_le32enc(&e.mtime, archive_entry_mtime(entry));
 367         archive_le32enc(&e.atime, archive_entry_atime(entry));
 368         archive_le32enc(&e.ctime, archive_entry_ctime(entry));
 369
 370         archive_le16enc(&e.unix_id, ZIP_SIGNATURE_EXTRA_UNIX);
 371         archive_le16enc(&e.unix_size, sizeof(e.unix_uid) + sizeof(e.unix_gid));
 372         archive_le16enc(&e.unix_uid, archive_entry_uid(entry));
 373         archive_le16enc(&e.unix_gid, archive_entry_gid(entry));
 374
 375         archive_le32enc(&d->uncompressed_size, size);
 376
 377         ret = (a->compressor.write)(a, &h, sizeof(h));
 378         if (ret != ARCHIVE_OK)
 379                 return (ARCHIVE_FATAL);
 380         zip->written_bytes += sizeof(h);
 381
 382         ret = write_path(entry, a);
 383         if (ret <= ARCHIVE_OK)
 384                 return (ARCHIVE_FATAL);
 385         zip->written_bytes += ret;
 386
 387         ret = (a->compressor.write)(a, &e, sizeof(e));
 388         if (ret != ARCHIVE_OK)
 389                 return (ARCHIVE_FATAL);
 390         zip->written_bytes += sizeof(e);
 391
 392         return (ARCHIVE_OK);
 393 }
 394
 395 static ssize_t
 396 archive_write_zip_data(struct archive_write *a, const void *buff, size_t s)
 397 {
 398         int ret;
 399         struct zip *zip = a->format_data;
 400         struct zip_file_header_link *l = zip->central_directory_end;
 401
 402         if ((int64_t)s > zip->remaining_data_bytes)
 403                 s = (size_t)zip->remaining_data_bytes;
 404
 405         if (s == 0) return 0;
 406
 407         switch (zip->compression) {
 408         case COMPRESSION_STORE:
 409                 ret = (a->compressor.write)(a, buff, s);
 410                 if (ret != ARCHIVE_OK) return (ret);
 411                 zip->written_bytes += s;
 412                 zip->remaining_data_bytes -= s;
 413                 l->compressed_size += s;
 414                 l->crc32 = crc32(l->crc32, buff, s);
 415                 return (s);
 416 #if HAVE_ZLIB_H
 417         case COMPRESSION_DEFLATE:
 418                 zip->stream.next_in = (unsigned char*)(uintptr_t)buff;
 419                 zip->stream.avail_in = s;
 420                 do {
 421                         ret = deflate(&zip->stream, Z_NO_FLUSH);
 422                         if (ret == Z_STREAM_ERROR)
 423                                 return (ARCHIVE_FATAL);
 424                         if (zip->stream.avail_out == 0) {
 425                                 ret = (a->compressor.write)(a, zip->buf, zip->len_buf);
 426                                 if (ret != ARCHIVE_OK)
 427                                         return (ret);
 428                                 l->compressed_size += zip->len_buf;
 429                                 zip->written_bytes += zip->len_buf;
 430                                 zip->stream.next_out = zip->buf;
 431                                 zip->stream.avail_out = zip->len_buf;
 432                         }
 433                 } while (zip->stream.avail_in != 0);
 434                 zip->remaining_data_bytes -= s;
 435                 /* If we have it, use zlib's fast crc32() */
 436                 l->crc32 = crc32(l->crc32, buff, s);
 437                 return (s);
 438 #endif
 439
 440         default:
 441                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
 442                     "Invalid ZIP compression type");
 443                 return ARCHIVE_FATAL;
 444         }
 445 }
 446
 447 static int
 448 archive_write_zip_finish_entry(struct archive_write *a)
 449 {
 450         /* Write the data descripter after file data has been written. */
 451         int ret;
 452         struct zip *zip = a->format_data;
 453         struct zip_data_descriptor *d = &zip->data_descriptor;
 454         struct zip_file_header_link *l = zip->central_directory_end;
 455 #if HAVE_ZLIB_H
 456         size_t reminder;
 457 #endif
 458
 459         switch(zip->compression) {
 460         case COMPRESSION_STORE:
 461                 break;
 462 #if HAVE_ZLIB_H
 463         case COMPRESSION_DEFLATE:
 464                 for (;;) {
 465                         ret = deflate(&zip->stream, Z_FINISH);
 466                         if (ret == Z_STREAM_ERROR)
 467                                 return (ARCHIVE_FATAL);
 468                         reminder = zip->len_buf - zip->stream.avail_out;
 469                         ret = (a->compressor.write)(a, zip->buf, reminder);
 470                         if (ret != ARCHIVE_OK)
 471                                 return (ret);
 472                         l->compressed_size += reminder;
 473                         zip->written_bytes += reminder;
 474                         zip->stream.next_out = zip->buf;
 475                         if (zip->stream.avail_out != 0)
 476                                 break;
 477                         zip->stream.avail_out = zip->len_buf;
 478                 }
 479                 deflateEnd(&zip->stream);
 480                 break;
 481 #endif
 482         }
 483
 484         archive_le32enc(&d->crc32, l->crc32);
 485         archive_le32enc(&d->compressed_size, l->compressed_size);
 486         ret = (a->compressor.write)(a, d, sizeof(*d));
 487         if (ret != ARCHIVE_OK)
 488                 return (ARCHIVE_FATAL);
 489         zip->written_bytes += sizeof(*d);
 490         return (ARCHIVE_OK);
 491 }
 492
 493 static int
 494 archive_write_zip_finish(struct archive_write *a)
 495 {
 496         struct zip *zip;
 497         struct zip_file_header_link *l;
 498         struct zip_file_header h;
 499         struct zip_central_directory_end end;
 500         struct zip_extra_data_central e;
 501         off_t offset_start, offset_end;
 502         int entries;
 503         int ret;
 504
 505         zip = a->format_data;
 506         l = zip->central_directory;
 507
 508         /*
 509          * Formatting central directory file header fields that are fixed for all entries.
 510          * Fields not used (and therefor 0) are:
 511          *
 512          *   - comment_length
 513          *   - disk_number
 514          *   - attributes_internal
 515          */
 516         memset(&h, 0, sizeof(h));
 517         archive_le32enc(&h.signature, ZIP_SIGNATURE_FILE_HEADER);
 518         archive_le16enc(&h.version_by, ZIP_VERSION_BY);
 519         archive_le16enc(&h.version_extract, ZIP_VERSION_EXTRACT);
 520         archive_le16enc(&h.flags, ZIP_FLAGS);
 521
 522         entries = 0;
 523         offset_start = zip->written_bytes;
 524
 525         /* Formatting individual header fields per entry and
 526          * writing each entry. */
 527         while (l != NULL) {
 528                 archive_le16enc(&h.compression, l->compression);
 529                 archive_le32enc(&h.timedate, dos_time(archive_entry_mtime(l->entry)));
 530                 archive_le32enc(&h.crc32, l->crc32);
 531                 archive_le32enc(&h.compressed_size, l->compressed_size);
 532                 archive_le32enc(&h.uncompressed_size, archive_entry_size(l->entry));
 533                 archive_le16enc(&h.filename_length, (uint16_t)path_length(l->entry));
 534                 archive_le16enc(&h.extra_length, sizeof(e));
 535                 archive_le16enc(&h.attributes_external[2], archive_entry_mode(l->entry));
 536                 archive_le32enc(&h.offset, l->offset);
 537
 538                 /* Formatting extra data. */
 539                 archive_le16enc(&e.time_id, ZIP_SIGNATURE_EXTRA_TIMESTAMP);
 540                 archive_le16enc(&e.time_size, sizeof(e.mtime) + sizeof(e.time_flag));
 541                 e.time_flag[0] = 0x07;
 542                 archive_le32enc(&e.mtime, archive_entry_mtime(l->entry));
 543                 archive_le16enc(&e.unix_id, ZIP_SIGNATURE_EXTRA_UNIX);
 544                 archive_le16enc(&e.unix_size, 0x0000);
 545
 546                 ret = (a->compressor.write)(a, &h, sizeof(h));
 547                 if (ret != ARCHIVE_OK)
 548                         return (ARCHIVE_FATAL);
 549                 zip->written_bytes += sizeof(h);
 550
 551                 ret = write_path(l->entry, a);
 552                 if (ret <= ARCHIVE_OK)
 553                         return (ARCHIVE_FATAL);
 554                 zip->written_bytes += ret;
 555
 556                 ret = (a->compressor.write)(a, &e, sizeof(e));
 557                 if (ret != ARCHIVE_OK)
 558                         return (ARCHIVE_FATAL);
 559                 zip->written_bytes += sizeof(e);
 560
 561                 l = l->next;
 562                 entries++;
 563         }
 564         offset_end = zip->written_bytes;
 565
 566         /* Formatting end of central directory. */
 567         memset(&end, 0, sizeof(end));
 568         archive_le32enc(&end.signature, ZIP_SIGNATURE_CENTRAL_DIRECTORY_END);
 569         archive_le16enc(&end.entries_disk, entries);
 570         archive_le16enc(&end.entries, entries);
 571         archive_le32enc(&end.size, offset_end - offset_start);
 572         archive_le32enc(&end.offset, offset_start);
 573
 574         /* Writing end of central directory. */
 575         ret = (a->compressor.write)(a, &end, sizeof(end));
 576         if (ret != ARCHIVE_OK)
 577                 return (ARCHIVE_FATAL);
 578         zip->written_bytes += sizeof(end);
 579         return (ARCHIVE_OK);
 580 }
 581
 582 static int
 583 archive_write_zip_destroy(struct archive_write *a)
 584 {
 585         struct zip *zip;
 586         struct zip_file_header_link *l;
 587
 588         zip = a->format_data;
 589         while (zip->central_directory != NULL) {
 590            l = zip->central_directory;
 591            zip->central_directory = l->next;
 592            archive_entry_free(l->entry);
 593            free(l);
 594         }
 595 #ifdef HAVE_ZLIB_H
 596         free(zip->buf);
 597 #endif
 598         free(zip);
 599         a->format_data = NULL;
 600         return (ARCHIVE_OK);
 601 }
 602
 603 /* Convert into MSDOS-style date/time. */
 604 static unsigned int
 605 dos_time(const time_t unix_time)
 606 {
 607         struct tm *t;
 608         unsigned int dt;
 609
 610         /* This will not preserve time when creating/extracting the archive
 611          * on two systems with different time zones. */
 612         t = localtime(&unix_time);
 613
 614         dt = 0;
 615         dt += ((t->tm_year - 80) & 0x7f) << 9;
 616         dt += ((t->tm_mon + 1) & 0x0f) << 5;
 617         dt += (t->tm_mday & 0x1f);
 618         dt <<= 16;
 619         dt += (t->tm_hour & 0x1f) << 11;
 620         dt += (t->tm_min & 0x3f) << 5;
 621         dt += (t->tm_sec & 0x3e) >> 1; /* Only counting every 2 seconds. */
 622         return dt;
 623 }
 624
 625 static size_t
 626 path_length(struct archive_entry *entry)
 627 {
 628         mode_t type;
 629         const char *path;
 630
 631         type = archive_entry_filetype(entry);
 632         path = archive_entry_pathname(entry);
 633
 634         if ((type == AE_IFDIR) & (path[strlen(path) - 1] != '/')) {
 635                 return strlen(path) + 1;
 636         } else {
 637                 return strlen(path);
 638         }
 639 }
 640
 641 static int
 642 write_path(struct archive_entry *entry, struct archive_write *archive)
 643 {
 644         int ret;
 645         const char *path;
 646         mode_t type;
 647         size_t written_bytes;
 648
 649         path = archive_entry_pathname(entry);
 650         type = archive_entry_filetype(entry);
 651         written_bytes = 0;
 652
 653         ret = (archive->compressor.write)(archive, path, strlen(path));
 654         if (ret != ARCHIVE_OK)
 655                 return (ARCHIVE_FATAL);
 656         written_bytes += strlen(path);
 657
 658         /* Folders are recognized by a traling slash. */
 659         if ((type == AE_IFDIR) & (path[strlen(path) - 1] != '/')) {
 660                 ret = (archive->compressor.write)(archive, "/", 1);
 661                 if (ret != ARCHIVE_OK)
 662                         return (ARCHIVE_FATAL);
 663                 written_bytes += 1;
 664         }
 665
 666         return ((int)written_bytes);
 667 }