TAR encode/decode-Bibliothek für das iPhone (ideal Kakao)

Kennt jemand eine Bibliothek/code, der mir ermöglicht, zu codieren und zu decodieren .tar formatierte Daten -, dass ich in meinem iPhone-Projekt (vorzugsweise Kakao)

Vielen Dank im Voraus

Craig

UPDATE: ich habe einen Blick auf die vorgeschlagenen Bibliotheken und kommen zu dem Schluss, dass Sie viiiiel zu viel von den problem - also ich bin der Entwicklung der codec selbst ist - es ist nur ein 512byte ASCII-header nach dem all - wie schwer kann es sein 🙂

erste Gefundene Element in google 'tar-Bibliothek c' feep.net/libtar
Craig, haben Sie jemals eine gute Antwort hier... oder Fortschritte auf Ihrem eigenen Implementierung? Es ist ein großes Loch in der API-Platz, so weit ich erzählen kann. Auch: ich habe es geschafft, libtar kompiliert in das iPhone-freundliche statische Bibliotheken, aber es war ein schmerzhafter Prozess, und ich habe in ein paar Abstürze im test-Fälle, die machen mich im Grunde denke ich, aufgeben die ganze Richtung.

InformationsquelleAutor Scotty | 2009-07-30

5

Die beste Bibliothek, die ich gefunden habe, ist libarchive. Es ist gut entwickelt, gut dokumentiert und schnell.

Ich gerade erstellt ein repository auf GitHub, dass die Werkzeuge zu bauen libarchive und libbz2 als statische Bibliotheken, die für iOS 4.2+. (Es sollte möglich sein, es zu verwenden, um Ziel-3.x, zu.)

http://github.com/davepeck/iOS-libarchive/

Andere haben darauf hingewiesen, dass libarchive ist im SDK enthalten. Das ist nicht ganz wahr. Die binäre libarchive.2.dylib enthalten ist, aber die Header nicht. Das gleiche gilt für libbz2 (aber seltsamerweise nicht zu libz.) Dies bedeutet, dass libarchive ist als eine private API -- in anderen Worten, Sie können nicht es verwenden, wenn Sie beabsichtigen, zu Schiff über den App-Store. Daher mein repository.
- Hey Dave, vielen Dank für das teilen deiner Arbeit. Ich Frage mich, ob Sie tatsächlich eingereicht, die ein app-store, mit diesem code. Diese Frage suggeriert, Sie könnten immer noch Probleme haben: stackoverflow.com/questions/3507684/...
- Projekt verknüpft wurde gelöscht von Existenz
InformationsquelleAutor Dave Peck
2

In der Tat, libarchive.dylib ist im iPhone SDK. Sie müssen nur, um es hinzuzufügen. Das problem ist, dass irgendwie Apple nicht include die header-Datei archivieren.h. Aber zuerst, müssen Sie nicht die header-Dateien, wenn Sie sicher sind, dass die Funktionen, die Sie aufrufen möchten existiert (obwohl der compiler jammern), zweitens, wenn Sie nicht möchten, dass der compiler sich beschweren, können Sie die header-Datei für libarchive 2.6 und fügen Sie es in Ihrem Programm ...

Wenn Sie wissen möchten, kennen zu verwenden libarchive, laden Sie die Quelle aus dem Netz und studieren Sie die Beispiel gegeben (vor allem minitar). Es ist wirklich sehr einfach.
- Ich glaube, dass macht ohne Papiere, das heißt, Sie können es nicht verwenden. Aber ich könnte falsch sein.
- Bitte siehe meine Antwort unten. libarchive ist eine private API, die auf ALLEN iOS-Versionen. Eine öffentliche API, (1) die Bibliothek binäre muss in der SDK, und (2) die header-Datei muss in der SDK.
- Ist libarchive öffentlichkeit auf Mac OS?
InformationsquelleAutor amadeoh
1

Könnten Sie versuchen,libxad. Dies ist die Bibliothek,Der Unarchiver, eine Mac-app, verwendet.

InformationsquelleAutor Peter Hosey
1

Sogar besser link: http://code.google.com/p/libarchive/downloads/detail?name=libarchive-2.6.2.tar.gz&can=2&q=

Version 2.6.2 ist im iOS 4.0 und 4.1 SDK. Es ist nicht in 3.2 (oder früher nehme ich an).

Wenn du das runterladen, ausführen ./configure --prefix=$HOME && make && make install und finden Sie die zwei header-Dateien in $HOME/include
- Bitte siehe meine Antwort unten. libarchive ist eine private API, die auf ALLEN iOS-Versionen. Eine öffentliche API, (1) die Bibliothek binäre muss in der SDK, und (2) die header-Datei muss in der SDK.
InformationsquelleAutor Matt Connolly

Für libarchive, es funktioniert out of the box, indem Sie nur "libarchive", um Ihre framework-Liste, aber der header fehlt. Sie können kopieren Sie die Kopfzeilen aus der libarchive-Quelle. Oder wenn Sie wollen, um es einfach zu halten, versuchen Sie dies:

////////////////////////////////////////////////////////////////////////////////////////////////////
// LibArchive "Header" - ios is missing this header.  go figure.
////////////////////////////////////////////////////////////////////////////////////////////////////

//from ftp://ftp8.freebsd.org/pub/FreeBSD/FreeBSD-current/src/lib/libarchive/archive.h.in

#define      ARCHIVE_EOF                1          /* Found end of archive. */
#define      ARCHIVE_OK                 0          /* Operation was successful. */
#define      ARCHIVE_RETRY            (-10)        /* Retry might succeed. */
#define      ARCHIVE_WARN             (-20)        /* Partial success. */
#define      ARCHIVE_FAILED           (-25)        /* Current operation cannot complete. */
#define      ARCHIVE_FATAL            (-30)        /* No more operations are possible. */

struct archive;
struct archive_entry;

int               archive_version_number(void);
const char *      archive_version_string(void);
int               archive_version_stamp(void);
const char *      archive_version(void);
int               archive_api_version(void);
int               archive_api_feature(void);
typedef ssize_t   archive_read_callback(struct archive *, void *_client_data, const void **_buffer);
//typedef ssize_t   archive_skip_callback(struct archive *, void *_client_data, size_t request);
typedef off_t     archive_skip_callback(struct archive *, void *_client_data, off_t request);
typedef ssize_t   archive_write_callback(struct archive *, void *_client_data, const void *_buffer, size_t _length);
typedef int       archive_open_callback(struct archive *, void *_client_data);
typedef int       archive_close_callback(struct archive *, void *_client_data);
struct            archive *archive_read_new(void);
int               archive_read_support_compression_all(struct archive *);
int               archive_read_support_compression_bzip2(struct archive *);
int               archive_read_support_compression_compress(struct archive *);
int               archive_read_support_compression_gzip(struct archive *);
int               archive_read_support_compression_none(struct archive *);
int               archive_read_support_compression_program(struct archive *, const char *command);
int               archive_read_support_format_all(struct archive *);
int               archive_read_support_format_ar(struct archive *);
int               archive_read_support_format_cpio(struct archive *);
int               archive_read_support_format_empty(struct archive *);
int               archive_read_support_format_gnutar(struct archive *);
int               archive_read_support_format_iso9660(struct archive *);
int               archive_read_support_format_mtree(struct archive *);
int               archive_read_support_format_tar(struct archive *);
int               archive_read_support_format_zip(struct archive *);
int               archive_read_open(struct archive *, void *_client_data, archive_open_callback *, archive_read_callback *, archive_close_callback *);
int               archive_read_open2(struct archive *, void *_client_data, archive_open_callback *, archive_read_callback *, archive_skip_callback *, archive_close_callback *);
int               archive_read_open_filename(struct archive *, const char *_filename, size_t _block_size);
int               archive_read_open_file(struct archive *, const char *_filename, size_t _block_size);
int               archive_read_open_memory(struct archive *, void * buff, size_t size);
int               archive_read_open_memory2(struct archive *a, void *buff, size_t size, size_t read_size);
int               archive_read_open_fd(struct archive *, int _fd, size_t _block_size);
int               archive_read_open_FILE(struct archive *, FILE *_file);
int               archive_read_next_header(struct archive *, struct archive_entry **);
int64_t           archive_read_header_position(struct archive *);
ssize_t           archive_read_data(struct archive *, void *, size_t);
int               archive_read_data_block(struct archive *a, const void **buff, size_t *size, off_t *offset);
int               archive_read_data_skip(struct archive *);
int               archive_read_data_into_buffer(struct archive *, void *buffer, ssize_t len);
int               archive_read_data_into_fd(struct archive *, int fd);
int               archive_read_extract(struct archive *, struct archive_entry *, int flags);
void              archive_read_extract_set_progress_callback(struct archive *, void (*_progress_func)(void *), void *_user_data);
void              archive_read_extract_set_skip_file(struct archive *, dev_t, ino_t);
int               archive_read_close(struct archive *);
int               archive_read_finish(struct archive *);
//void              archive_read_finish(struct archive *);
struct            archive *archive_write_new(void);
int               archive_write_set_bytes_per_block(struct archive *, int bytes_per_block);
int               archive_write_get_bytes_per_block(struct archive *);
int               archive_write_set_bytes_in_last_block(struct archive *, int bytes_in_last_block);
int               archive_write_get_bytes_in_last_block(struct archive *);
int               archive_write_set_skip_file(struct archive *, dev_t, ino_t);
int               archive_write_set_compression_bzip2(struct archive *);
int               archive_write_set_compression_compress(struct archive *);
int               archive_write_set_compression_gzip(struct archive *);
int               archive_write_set_compression_none(struct archive *);
int               archive_write_set_compression_program(struct archive *, const char *cmd);
int               archive_write_set_format(struct archive *, int format_code);
int               archive_write_set_format_by_name(struct archive *, const char *name);
int               archive_write_set_format_ar_bsd(struct archive *);
int               archive_write_set_format_ar_svr4(struct archive *);
int               archive_write_set_format_cpio(struct archive *);
int               archive_write_set_format_cpio_newc(struct archive *);
int               archive_write_set_format_pax(struct archive *);
int               archive_write_set_format_pax_restricted(struct archive *);
int               archive_write_set_format_shar(struct archive *);
int               archive_write_set_format_shar_dump(struct archive *);
int               archive_write_set_format_ustar(struct archive *);
int               archive_write_open(struct archive *, void *, archive_open_callback *, archive_write_callback *, archive_close_callback *);
int               archive_write_open_fd(struct archive *, int _fd);
int               archive_write_open_filename(struct archive *, const char *_file);
int               archive_write_open_file(struct archive *, const char *_file);
int               archive_write_open_FILE(struct archive *, FILE *);
int               archive_write_open_memory(struct archive *, void *_buffer, size_t _buffSize, size_t *_used);
int               archive_write_header(struct archive *, struct archive_entry *);
ssize_t           archive_write_data(struct archive *, const void *, size_t);
//int               archive_write_data(struct archive *, const void *, size_t);
ssize_t           archive_write_data_block(struct archive *, const void *, size_t, off_t);
int               archive_write_finish_entry(struct archive *);
int               archive_write_close(struct archive *);
int               archive_write_finish(struct archive *);
//void              archive_write_finish(struct archive *);
struct            archive *archive_write_disk_new(void);
int               archive_write_disk_set_skip_file(struct archive *, dev_t, ino_t);
int               archive_write_disk_set_options(struct archive *, int flags);
int               archive_write_disk_set_standard_lookup(struct archive *);
int               archive_write_disk_set_group_lookup(struct archive *, void *private_data, gid_t (*loookup)(void *, const char *gname, gid_t gid), void (*cleanup)(void *));
int               archive_write_disk_set_user_lookup(struct archive *, void *private_data, uid_t (*)(void *, const char *uname, uid_t uid), void (*cleanup)(void *));
int64_t           archive_position_compressed(struct archive *);
int64_t           archive_position_uncompressed(struct archive *);
const char *      archive_compression_name(struct archive *);
int               archive_compression(struct archive *);
int               archive_errno(struct archive *);
const char *      archive_error_string(struct archive *);
const char *      archive_format_name(struct archive *);
int               archive_format(struct archive *);
void              archive_clear_error(struct archive *);
void              archive_set_error(struct archive *, int _err, const char *fmt, ...);
void              archive_copy_error(struct archive *dest, struct archive *src);

//From ftp://ftp8.freebsd.org/pub/FreeBSD/FreeBSD-current/src/lib/libarchive/archive_entry.h

time_t            archive_entry_atime(struct archive_entry *);
long              archive_entry_atime_nsec(struct archive_entry *);
time_t            archive_entry_ctime(struct archive_entry *);
long              archive_entry_ctime_nsec(struct archive_entry *);
dev_t             archive_entry_dev(struct archive_entry *);
dev_t             archive_entry_devmajor(struct archive_entry *);
dev_t             archive_entry_devminor(struct archive_entry *);
mode_t            archive_entry_filetype(struct archive_entry *);
void              archive_entry_fflags(struct archive_entry *, unsigned long *set, unsigned long *clear);
const char*       archive_entry_fflags_text(struct archive_entry *);
gid_t             archive_entry_gid(struct archive_entry *);
const char*       archive_entry_gname(struct archive_entry *);
const wchar_t*    archive_entry_gname_w(struct archive_entry *);
const char*       archive_entry_hardlink(struct archive_entry *);
const wchar_t*    archive_entry_hardlink_w(struct archive_entry *);
ino_t             archive_entry_ino(struct archive_entry *);
mode_t            archive_entry_mode(struct archive_entry *);
time_t            archive_entry_mtime(struct archive_entry *);
long              archive_entry_mtime_nsec(struct archive_entry *);
unsigned int      archive_entry_nlink(struct archive_entry *);
const char*       archive_entry_pathname(struct archive_entry *);
const wchar_t*    archive_entry_pathname_w(struct archive_entry *);
dev_t             archive_entry_rdev(struct archive_entry *);
dev_t             archive_entry_rdevmajor(struct archive_entry *);
dev_t             archive_entry_rdevminor(struct archive_entry *);
int64_t           archive_entry_size(struct archive_entry *);
const char*       archive_entry_strmode(struct archive_entry *);
const char*       archive_entry_symlink(struct archive_entry *);
const wchar_t*    archive_entry_symlink_w(struct archive_entry *);
uid_t             archive_entry_uid(struct archive_entry *);
const char*       archive_entry_uname(struct archive_entry *);
const wchar_t*    archive_entry_uname_w(struct archive_entry *);

Ich interessierten nur die Lektüre, damit ich nicht die Mühe mit einigen der archive_entry.h-mutation Funktionen. Auch ein paar der Methoden, die auskommentiert sind. Das sind die alternativen für verschiedene Versionen, get #ifdef würde aus. Viel Glück und gute bug-Jagd!

Hier ist ein Beispiel der Verwendung es zu entpacken eines Archivs in ein Verzeichnis auf ios:

+ (void)unpackArchive: (NSData*) archiveData
{
    int r;
    struct archive* a;
    struct archive_entry *entry;
    const char *entry_path;
    NSString *baseDir = [self baseDir];
    NSFileHandle* file;
    NSError* error;
    NSDictionary* result = @{};

    NSLog(@"Unpacking %d byte static assets tarball into %@", [archiveData length], baseDir);

    if (![[NSFileManager defaultManager] createDirectoryAtPath:baseDir
                                   withIntermediateDirectories:YES
                                                    attributes:nil
                                                         error:&error])
    {
        NSLog(@"Create directory error: %@", error);
    }

    a = archive_read_new();
    archive_read_support_format_gnutar(a);
    archive_read_support_format_tar(a);
    archive_read_support_compression_gzip(a);

    r = archive_read_open_memory(a, (void*)[archiveData bytes], [archiveData length]);
    if (r != ARCHIVE_OK) {
        NSLog(@"ERROR[%d] in archive_read_open_file(): %s", r, archive_error_string(a));
        return;
    }
    for (;;) {
        r = archive_read_next_header(a, &entry);
        if (r == ARCHIVE_EOF) {
            break;
        }
        if (r != ARCHIVE_OK) {
            NSLog(@"ERROR[%d] in archive_read_next_header(): %s", r, archive_error_string(a));
            return;
        }
        entry_path = archive_entry_pathname(entry);

        NSString* path = [baseDir stringByAppendingPathComponent: [NSString stringWithUTF8String: entry_path]];
        NSLog(@"Tarball Entry: %s", entry_path);

        //Create the file and blank it out
        [[NSFileManager defaultManager] createFileAtPath: path contents:[[NSMutableData alloc] init] attributes:nil];
        //Actually write the file
        file = [NSFileHandle fileHandleForWritingAtPath:path];
        r = archive_read_data_into_fd(a, [file fileDescriptor]);
        if (r != ARCHIVE_OK) {
            NSLog(@"ERROR[%d] in archive_read_data_into_fd(): %s", r, archive_error_string(a));
            return;
        }
        [file closeFile];
    }
    r = archive_read_close(a);
    if (r != ARCHIVE_OK) {
        NSLog(@"ERROR[%d] in archive_read_close(): %s", r, archive_error_string(a));
        return;
    }
}

--- Dave

InformationsquelleAutor Dave Dopson

0

libarchive kommt vorinstalliert auf iOS.

InformationsquelleAutor Cocoanetics
0

Scheint es zwei weitere moderne Bibliotheken, beide erhältlich als Cocoapods:
- NVHTarGzip: Unterstützt von Fortschrittsberichten, und hat sowohl synchrone als auch asynchrone Methoden. Keine Unterstützung für tar zu schreiben.
- tarkit: Unterstützt tar schreiben, aber nicht die anderen netten features.
Beide von Ihnen sind sehr ähnlich, da Sie beide basieren auf Licht-Entpacken-für-iOS.
- tarkit ist die Herstellung von Dateien, die nicht erweitert werden, durch das Archiv-Dienstprogramm.app, Yosemite, die Datei, die ich tar ' ed ist einer font-Datei.
- Korrektur: [DCTar tarFileAtPath:filePath toPath:tarFilePath error:nil] ist assumming, dass der Dateipfad ist ein Ordner und so, wenn es nur eine Datei, tar, es schlägt fehl ...
- Ich landete mit NVHTarGzip, nach Beitrag .tar und .tar.gz Verpackung es.
InformationsquelleAutor Ricardo Sanchez-Saez

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.