kuba--/zip

By default, opening an archive for writing with the literal mode character 'w' enables ZIP64 output. To produce a ZIP archive that is NOT ZIP64, use an alternate mode value that selects the same semantic mode but does not equal the literal 'w'.

Use the following pattern (subtracting 64 from the character literal) to select the non-ZIP64 variant:

• Write mode: 'w' - 64 (integer value 55)
• Read mode: 'r' - 64
• Append mode: 'a' - 64
• Delete mode: 'd' - 64

The library supports Traditional PKWARE Encryption.

• To create: Use zip_open_with_password with the 'w' mode and provide the password string.
• To extract: Use zip_open_with_password with the 'r' mode and provide the password string.
• To delete: Use zip_open_with_password with the 'd' mode and provide the password string.

To iterate through all entries in an archive, use zip_entries_total to get the count, then loop through indices using zip_entry_openbyindex. For each entry, you can retrieve metadata such as the name, directory status, symlink status, size, and CRC32.

struct zip_t *zip = zip_open("foo.zip", 0, 'r');
int i, n = zip_entries_total(zip);
for (i = 0; i < n; ++i) {
    zip_entry_openbyindex(zip, i);
    {
        const char *name = zip_entry_name(zip);
        int isdir = zip_entry_isdir(zip);
        int issymlink = zip_entry_issymlink(zip);
        unsigned long long size = zip_entry_size(zip);
        unsigned int crc32 = zip_entry_crc32(zip);
    }
    zip_entry_close(zip);
}
zip_close(zip);

To add new entries to an existing archive, use zip_open with the 'a' mode. The workflow for opening and writing entries remains the same as creating a new archive.

struct zip_t *zip = zip_open("foo.zip", ZIP_DEFAULT_COMPRESSION_LEVEL, 'a');
{
    zip_entry_open(zip, "foo-3.txt");
    {
        const char *buf = "Append some data here...\0";
        zip_entry_write(zip, buf, strlen(buf));
    }
    zip_entry_close(zip);
}
zip_close(zip);

Use zip_extract to extract all contents of a zip file from disk into a target directory. This function requires a callback function that is invoked for each extracted entry.

int on_extract_entry(const char *filename, void *arg) {
    static int i = 0;
    int n = *(int *)arg;
    printf("Extracted: %s (%d of %d)\n", filename, ++i, n);

    return 0;
}

// From "foo.zip" on disk
int arg = 2;
zip_extract("foo.zip", "/tmp", on_extract_entry, &arg);

To read a specific segment of an entry, use zip_entry_noallocreadwithoffset. This function reads up to size bytes starting at offset into a caller-owned buffer. It does not perform internal allocations. The call returns the number of bytes actually written, or a negative error code if the offset is invalid.

unsigned char buf[16];
size_t bufsize = sizeof(buf);

struct zip_t *zip = zip_open("foo.zip", 0, 'r');
{
    zip_entry_open(zip, "foo-1.txt");
    {
        size_t offset = 4;
        ssize_t nread = zip_entry_noallocreadwithoffset(zip, offset, bufsize, (void *)buf);
        if (nread < 0) {
            // offset out of range or read error
        }
    }

    zip_entry_close(zip);
}
zip_close(zip);

You can delete entries from an archive using zip_entries_delete (by providing an array of names) or zip_entries_deletebyindex (by providing an array of indices). The archive must be opened in delete mode ('d').

char *entries[] = {"unused.txt", "remove.ini", "delete.me"};

struct zip_t *zip = zip_open("foo.zip", 0, 'd');
{
    zip_entries_delete(zip, entries, 3);
    // or: zip_entries_deletebyindex(zip, indices, 3);
}
zip_close(zip);

The following options are available for the unzipcli tool:

Options:
  -d DIR     extract into DIR (default: current directory)
  -p PASS    decrypt with password
  -l         list entries instead of extracting
  -o         overwrite existing files without prompting
  -h         show help
  --         stop processing options