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
archive_write_zip_options(struct archive_write * a,const char * key,const char * value)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
archive_write_set_format_zip(struct archive * _a)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
archive_write_zip_header(struct archive_write * a,struct archive_entry * entry)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
archive_write_zip_data(struct archive_write * a,const void * buff,size_t s)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
archive_write_zip_finish_entry(struct archive_write * a)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
archive_write_zip_finish(struct archive_write * a)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
archive_write_zip_destroy(struct archive_write * a)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
dos_time(const time_t unix_time)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
path_length(struct archive_entry * entry)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
write_path(struct archive_entry * entry,struct archive_write * archive)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 }
668