I am trying to build a "failsafe" layer on top of libzip but libzip is giving me some trouble here.

First I add a file to my (empty) archive with zip_file_add(...). This has 3 possible user-defined encodings available. Then I try to locate the name with zip_name_locate(...) which also has 3 possible user-defined encodings available.

This mcve checks all possible encoding combinations and all of them fail for the specific filename x%²»Ã-ØÑ–6¨wx.txt. When using a more conventional file.txt filename, zip_name_locate() succeeds every time.

#include <zip.h>
#include <include/libzip.h>//<.pragmas to include the .lib's...
#include <iostream>
#include <vector>
#include <utility>

/*
    'zip_file_add' possible encodings:
        ZIP_FL_ENC_GUESS
        ZIP_FL_ENC_UTF_8
        ZIP_FL_ENC_CP437

    'zip_name_locate' possible encodings:
        ZIP_FL_ENC_RAW
        ZIP_FL_ENC_GUESS
        ZIP_FL_ENC_STRICT
*/

/*
    build encoding pairs (trying all possibilities)
*/
std::vector<std::pair<unsigned, unsigned>>
encoding_pairs{
    { ZIP_FL_ENC_GUESS, ZIP_FL_ENC_RAW },
    { ZIP_FL_ENC_UTF_8, ZIP_FL_ENC_RAW },
    { ZIP_FL_ENC_CP437, ZIP_FL_ENC_RAW },
    { ZIP_FL_ENC_GUESS, ZIP_FL_ENC_GUESS },
    { ZIP_FL_ENC_UTF_8, ZIP_FL_ENC_GUESS },
    { ZIP_FL_ENC_CP437, ZIP_FL_ENC_GUESS },
    { ZIP_FL_ENC_GUESS, ZIP_FL_ENC_STRICT },
    { ZIP_FL_ENC_UTF_8, ZIP_FL_ENC_STRICT },
    { ZIP_FL_ENC_CP437, ZIP_FL_ENC_STRICT },
};

int main(int argc, char** argv) {

    const char* file_buf = "hello world";
#if 0
    const char* file_name = "file.txt";
#else
    const char* file_name = "x%²»Ã-ØÑ–6¨wx.txt";
#endif

    zip_error_t ze;
    zip_error_init(&ze);
    {
        zip_source_t* zs = zip_source_buffer_create(nullptr, 0, 1, &ze);
        if (zs == NULL)
            return -1;

        zip_t* z = zip_open_from_source(zs, ZIP_CHECKCONS, &ze);
        if (z == NULL)
            return -1;
        {
            zip_source_t* s = zip_source_buffer(z, file_buf, strlen(file_buf), 0);//0 = don't let libzip auto-free the const char* buffer on the stack
            if (s == NULL)
                return -1;

            for (size_t ep = 0; ep < encoding_pairs.size(); ep  ) {
                std::cout << "ep = " << ep << std::endl;
                zip_uint64_t index;
                if ((index = zip_file_add(z, file_name, s, encoding_pairs[ep].first)) == -1) {
                    std::cout << "could not zip_file_add() with encoding " << encoding_pairs[ep].first << std::endl;
                    continue;
                }

                if (zip_name_locate(z, file_name, encoding_pairs[ep].second) == -1) {
                    std::cout << "the name '" << file_name << "' could not be located." << std::endl;
                    std::cout << " encoding pair: " << encoding_pairs[ep].first << " <-> " << encoding_pairs[ep].second << std::endl;
                }
                else {
                    std::cout << "the name was located." << std::endl;
                }

                if (zip_delete(z, index) == -1)
                    return -1;
            }
        }
        zip_close(z);
    }
    zip_error_fini(&ze);

    return 0;
}

I don't understand what I might be doing wrong here or if libzip just can't even resolve such a name.

If it can't then what would be the criteria on names to avoid ?

CodePudding user response：

It turns out the problem was the encoding of my source file itself. It was ANSI - So I converted it to UTF8 and it solved the issue.

What I still don't understand is why libzip can't zip_name_locate() a name from an input c-string that is exactly the same as the input c-string used in zip_file_add() (whatever the source file encoding might be). "Lost in translation" perhaps ?

(Special thanks to Thomas Klausner for helping me find the issue).