// // SSZipArchive.m // SSZipArchive // // Created by Sam Soffes on 7/21/10. // Copyright (c) Sam Soffes 2010-2015. All rights reserved. // #import "SSZipArchive.h" #include "unzip.h" #include "zip.h" #include "minishared.h" #include NSString *const SSZipArchiveErrorDomain = @"SSZipArchiveErrorDomain"; #define CHUNK 16384 int _zipOpenEntry(zipFile entry, NSString *name, const zip_fileinfo *zipfi, int level, NSString *password, BOOL aes); BOOL _fileIsSymbolicLink(const unz_file_info *fileInfo); #ifndef API_AVAILABLE // Xcode 7- compatibility #define API_AVAILABLE(...) #endif @interface NSData(SSZipArchive) - (NSString *)_base64RFC4648 API_AVAILABLE(macos(10.9), ios(7.0), watchos(2.0), tvos(9.0)); - (NSString *)_hexString; @end @interface SSZipArchive () - (instancetype)init NS_DESIGNATED_INITIALIZER; @end @implementation SSZipArchive { /// path for zip file NSString *_path; zipFile _zip; } #pragma mark - Password check + (BOOL)isFilePasswordProtectedAtPath:(NSString *)path { // Begin opening zipFile zip = unzOpen(path.fileSystemRepresentation); if (zip == NULL) { return NO; } int ret = unzGoToFirstFile(zip); if (ret == UNZ_OK) { do { ret = unzOpenCurrentFile(zip); if (ret != UNZ_OK) { return NO; } unz_file_info fileInfo = {}; ret = unzGetCurrentFileInfo(zip, &fileInfo, NULL, 0, NULL, 0, NULL, 0); if (ret != UNZ_OK) { return NO; } else if ((fileInfo.flag & 1) == 1) { return YES; } unzCloseCurrentFile(zip); ret = unzGoToNextFile(zip); } while (ret == UNZ_OK); } return NO; } + (BOOL)isPasswordValidForArchiveAtPath:(NSString *)path password:(NSString *)pw error:(NSError **)error { if (error) { *error = nil; } zipFile zip = unzOpen(path.fileSystemRepresentation); if (zip == NULL) { if (error) { *error = [NSError errorWithDomain:SSZipArchiveErrorDomain code:SSZipArchiveErrorCodeFailedOpenZipFile userInfo:@{NSLocalizedDescriptionKey: @"failed to open zip file"}]; } return NO; } int ret = unzGoToFirstFile(zip); if (ret == UNZ_OK) { do { if (pw.length == 0) { ret = unzOpenCurrentFile(zip); } else { ret = unzOpenCurrentFilePassword(zip, [pw cStringUsingEncoding:NSUTF8StringEncoding]); } if (ret != UNZ_OK) { if (ret != UNZ_BADPASSWORD) { if (error) { *error = [NSError errorWithDomain:SSZipArchiveErrorDomain code:SSZipArchiveErrorCodeFailedOpenFileInZip userInfo:@{NSLocalizedDescriptionKey: @"failed to open first file in zip file"}]; } } return NO; } unz_file_info fileInfo = {}; ret = unzGetCurrentFileInfo(zip, &fileInfo, NULL, 0, NULL, 0, NULL, 0); if (ret != UNZ_OK) { if (error) { *error = [NSError errorWithDomain:SSZipArchiveErrorDomain code:SSZipArchiveErrorCodeFileInfoNotLoadable userInfo:@{NSLocalizedDescriptionKey: @"failed to retrieve info for file"}]; } return NO; } else if ((fileInfo.flag & 1) == 1) { unsigned char buffer[10] = {0}; int readBytes = unzReadCurrentFile(zip, buffer, (unsigned)MIN(10UL,fileInfo.uncompressed_size)); if (readBytes < 0) { // Let's assume error Z_DATA_ERROR is caused by an invalid password // Let's assume other errors are caused by Content Not Readable if (readBytes != Z_DATA_ERROR) { if (error) { *error = [NSError errorWithDomain:SSZipArchiveErrorDomain code:SSZipArchiveErrorCodeFileContentNotReadable userInfo:@{NSLocalizedDescriptionKey: @"failed to read contents of file entry"}]; } } return NO; } return YES; } unzCloseCurrentFile(zip); ret = unzGoToNextFile(zip); } while (ret == UNZ_OK); } // No password required return YES; } #pragma mark - Unzipping + (BOOL)unzipFileAtPath:(NSString *)path toDestination:(NSString *)destination { return [self unzipFileAtPath:path toDestination:destination delegate:nil]; } + (BOOL)unzipFileAtPath:(NSString *)path toDestination:(NSString *)destination overwrite:(BOOL)overwrite password:(nullable NSString *)password error:(NSError **)error { return [self unzipFileAtPath:path toDestination:destination preserveAttributes:YES overwrite:overwrite password:password error:error delegate:nil progressHandler:nil completionHandler:nil]; } + (BOOL)unzipFileAtPath:(NSString *)path toDestination:(NSString *)destination delegate:(nullable id)delegate { return [self unzipFileAtPath:path toDestination:destination preserveAttributes:YES overwrite:YES password:nil error:nil delegate:delegate progressHandler:nil completionHandler:nil]; } + (BOOL)unzipFileAtPath:(NSString *)path toDestination:(NSString *)destination overwrite:(BOOL)overwrite password:(nullable NSString *)password error:(NSError **)error delegate:(nullable id)delegate { return [self unzipFileAtPath:path toDestination:destination preserveAttributes:YES overwrite:overwrite password:password error:error delegate:delegate progressHandler:nil completionHandler:nil]; } + (BOOL)unzipFileAtPath:(NSString *)path toDestination:(NSString *)destination overwrite:(BOOL)overwrite password:(NSString *)password progressHandler:(void (^)(NSString *entry, unz_file_info zipInfo, long entryNumber, long total))progressHandler completionHandler:(void (^)(NSString *path, BOOL succeeded, NSError * _Nullable error))completionHandler { return [self unzipFileAtPath:path toDestination:destination preserveAttributes:YES overwrite:overwrite password:password error:nil delegate:nil progressHandler:progressHandler completionHandler:completionHandler]; } + (BOOL)unzipFileAtPath:(NSString *)path toDestination:(NSString *)destination progressHandler:(void (^_Nullable)(NSString *entry, unz_file_info zipInfo, long entryNumber, long total))progressHandler completionHandler:(void (^_Nullable)(NSString *path, BOOL succeeded, NSError * _Nullable error))completionHandler { return [self unzipFileAtPath:path toDestination:destination preserveAttributes:YES overwrite:YES password:nil error:nil delegate:nil progressHandler:progressHandler completionHandler:completionHandler]; } + (BOOL)unzipFileAtPath:(NSString *)path toDestination:(NSString *)destination preserveAttributes:(BOOL)preserveAttributes overwrite:(BOOL)overwrite password:(nullable NSString *)password error:(NSError * *)error delegate:(nullable id)delegate { return [self unzipFileAtPath:path toDestination:destination preserveAttributes:preserveAttributes overwrite:overwrite password:password error:error delegate:delegate progressHandler:nil completionHandler:nil]; } + (BOOL)unzipFileAtPath:(NSString *)path toDestination:(NSString *)destination preserveAttributes:(BOOL)preserveAttributes overwrite:(BOOL)overwrite password:(nullable NSString *)password error:(NSError **)error delegate:(nullable id)delegate progressHandler:(void (^_Nullable)(NSString *entry, unz_file_info zipInfo, long entryNumber, long total))progressHandler completionHandler:(void (^_Nullable)(NSString *path, BOOL succeeded, NSError * _Nullable error))completionHandler { return [self unzipFileAtPath:path toDestination:destination preserveAttributes:preserveAttributes overwrite:overwrite nestedZipLevel:0 password:password error:error delegate:delegate progressHandler:progressHandler completionHandler:completionHandler]; } + (BOOL)unzipFileAtPath:(NSString *)path toDestination:(NSString *)destination preserveAttributes:(BOOL)preserveAttributes overwrite:(BOOL)overwrite nestedZipLevel:(NSInteger)nestedZipLevel password:(nullable NSString *)password error:(NSError **)error delegate:(nullable id)delegate progressHandler:(void (^_Nullable)(NSString *entry, unz_file_info zipInfo, long entryNumber, long total))progressHandler completionHandler:(void (^_Nullable)(NSString *path, BOOL succeeded, NSError * _Nullable error))completionHandler { // Guard against empty strings if (path.length == 0 || destination.length == 0) { NSDictionary *userInfo = @{NSLocalizedDescriptionKey: @"received invalid argument(s)"}; NSError *err = [NSError errorWithDomain:SSZipArchiveErrorDomain code:SSZipArchiveErrorCodeInvalidArguments userInfo:userInfo]; if (error) { *error = err; } if (completionHandler) { completionHandler(nil, NO, err); } return NO; } // Begin opening zipFile zip = unzOpen(path.fileSystemRepresentation); if (zip == NULL) { NSDictionary *userInfo = @{NSLocalizedDescriptionKey: @"failed to open zip file"}; NSError *err = [NSError errorWithDomain:SSZipArchiveErrorDomain code:SSZipArchiveErrorCodeFailedOpenZipFile userInfo:userInfo]; if (error) { *error = err; } if (completionHandler) { completionHandler(nil, NO, err); } return NO; } NSDictionary * fileAttributes = [[NSFileManager defaultManager] attributesOfItemAtPath:path error:nil]; unsigned long long fileSize = [fileAttributes[NSFileSize] unsignedLongLongValue]; unsigned long long currentPosition = 0; unz_global_info globalInfo = {}; unzGetGlobalInfo(zip, &globalInfo); // Begin unzipping int ret = 0; ret = unzGoToFirstFile(zip); if (ret != UNZ_OK && ret != UNZ_END_OF_LIST_OF_FILE) { NSDictionary *userInfo = @{NSLocalizedDescriptionKey: @"failed to open first file in zip file"}; NSError *err = [NSError errorWithDomain:SSZipArchiveErrorDomain code:SSZipArchiveErrorCodeFailedOpenFileInZip userInfo:userInfo]; if (error) { *error = err; } if (completionHandler) { completionHandler(nil, NO, err); } return NO; } BOOL success = YES; BOOL canceled = NO; int crc_ret = 0; unsigned char buffer[4096] = {0}; NSFileManager *fileManager = [NSFileManager defaultManager]; NSMutableArray *directoriesModificationDates = [[NSMutableArray alloc] init]; // Message delegate if ([delegate respondsToSelector:@selector(zipArchiveWillUnzipArchiveAtPath:zipInfo:)]) { [delegate zipArchiveWillUnzipArchiveAtPath:path zipInfo:globalInfo]; } if ([delegate respondsToSelector:@selector(zipArchiveProgressEvent:total:)]) { [delegate zipArchiveProgressEvent:currentPosition total:fileSize]; } NSInteger currentFileNumber = -1; NSError *unzippingError; do { currentFileNumber++; if (ret == UNZ_END_OF_LIST_OF_FILE) break; @autoreleasepool { if (password.length == 0) { ret = unzOpenCurrentFile(zip); } else { ret = unzOpenCurrentFilePassword(zip, [password cStringUsingEncoding:NSUTF8StringEncoding]); } if (ret != UNZ_OK) { unzippingError = [NSError errorWithDomain:@"SSZipArchiveErrorDomain" code:SSZipArchiveErrorCodeFailedOpenFileInZip userInfo:@{NSLocalizedDescriptionKey: @"failed to open file in zip file"}]; success = NO; break; } // Reading data and write to file unz_file_info fileInfo; memset(&fileInfo, 0, sizeof(unz_file_info)); ret = unzGetCurrentFileInfo(zip, &fileInfo, NULL, 0, NULL, 0, NULL, 0); if (ret != UNZ_OK) { unzippingError = [NSError errorWithDomain:@"SSZipArchiveErrorDomain" code:SSZipArchiveErrorCodeFileInfoNotLoadable userInfo:@{NSLocalizedDescriptionKey: @"failed to retrieve info for file"}]; success = NO; unzCloseCurrentFile(zip); break; } currentPosition += fileInfo.compressed_size; // Message delegate if ([delegate respondsToSelector:@selector(zipArchiveShouldUnzipFileAtIndex:totalFiles:archivePath:fileInfo:)]) { if (![delegate zipArchiveShouldUnzipFileAtIndex:currentFileNumber totalFiles:(NSInteger)globalInfo.number_entry archivePath:path fileInfo:fileInfo]) { success = NO; canceled = YES; break; } } if ([delegate respondsToSelector:@selector(zipArchiveWillUnzipFileAtIndex:totalFiles:archivePath:fileInfo:)]) { [delegate zipArchiveWillUnzipFileAtIndex:currentFileNumber totalFiles:(NSInteger)globalInfo.number_entry archivePath:path fileInfo:fileInfo]; } if ([delegate respondsToSelector:@selector(zipArchiveProgressEvent:total:)]) { [delegate zipArchiveProgressEvent:(NSInteger)currentPosition total:(NSInteger)fileSize]; } char *filename = (char *)malloc(fileInfo.size_filename + 1); if (filename == NULL) { success = NO; break; } unzGetCurrentFileInfo(zip, &fileInfo, filename, fileInfo.size_filename + 1, NULL, 0, NULL, 0); filename[fileInfo.size_filename] = '\0'; BOOL fileIsSymbolicLink = _fileIsSymbolicLink(&fileInfo); NSString * strPath = [SSZipArchive _filenameStringWithCString:filename size:fileInfo.size_filename]; if ([strPath hasPrefix:@"__MACOSX/"]) { // ignoring resource forks: https://superuser.com/questions/104500/what-is-macosx-folder unzCloseCurrentFile(zip); ret = unzGoToNextFile(zip); continue; } if (!strPath.length) { // if filename data is unsalvageable, we default to currentFileNumber strPath = @(currentFileNumber).stringValue; } // Check if it contains directory BOOL isDirectory = NO; if (filename[fileInfo.size_filename-1] == '/' || filename[fileInfo.size_filename-1] == '\\') { isDirectory = YES; } free(filename); // Contains a path if ([strPath rangeOfCharacterFromSet:[NSCharacterSet characterSetWithCharactersInString:@"/\\"]].location != NSNotFound) { strPath = [strPath stringByReplacingOccurrencesOfString:@"\\" withString:@"/"]; } NSString *fullPath = [destination stringByAppendingPathComponent:strPath]; NSError *err = nil; NSDictionary *directoryAttr; if (preserveAttributes) { NSDate *modDate = [[self class] _dateWithMSDOSFormat:(UInt32)fileInfo.dos_date]; directoryAttr = @{NSFileCreationDate: modDate, NSFileModificationDate: modDate}; [directoriesModificationDates addObject: @{@"path": fullPath, @"modDate": modDate}]; } if (isDirectory) { [fileManager createDirectoryAtPath:fullPath withIntermediateDirectories:YES attributes:directoryAttr error:&err]; } else { [fileManager createDirectoryAtPath:fullPath.stringByDeletingLastPathComponent withIntermediateDirectories:YES attributes:directoryAttr error:&err]; } if (nil != err) { if ([err.domain isEqualToString:NSCocoaErrorDomain] && err.code == 640) { unzippingError = err; unzCloseCurrentFile(zip); success = NO; break; } NSLog(@"[SSZipArchive] Error: %@", err.localizedDescription); } if ([fileManager fileExistsAtPath:fullPath] && !isDirectory && !overwrite) { //FIXME: couldBe CRC Check? unzCloseCurrentFile(zip); ret = unzGoToNextFile(zip); continue; } if (!fileIsSymbolicLink) { // ensure we are not creating stale file entries int readBytes = unzReadCurrentFile(zip, buffer, 4096); if (readBytes >= 0) { FILE *fp = fopen(fullPath.fileSystemRepresentation, "wb"); while (fp) { if (readBytes > 0) { if (0 == fwrite(buffer, readBytes, 1, fp)) { if (ferror(fp)) { NSString *message = [NSString stringWithFormat:@"Failed to write file (check your free space)"]; NSLog(@"[SSZipArchive] %@", message); success = NO; unzippingError = [NSError errorWithDomain:@"SSZipArchiveErrorDomain" code:SSZipArchiveErrorCodeFailedToWriteFile userInfo:@{NSLocalizedDescriptionKey: message}]; break; } } } else { break; } readBytes = unzReadCurrentFile(zip, buffer, 4096); if (readBytes < 0) { // Let's assume error Z_DATA_ERROR is caused by an invalid password // Let's assume other errors are caused by Content Not Readable success = NO; } } if (fp) { fclose(fp); if (nestedZipLevel && [fullPath.pathExtension.lowercaseString isEqualToString:@"zip"] && [self unzipFileAtPath:fullPath toDestination:fullPath.stringByDeletingLastPathComponent preserveAttributes:preserveAttributes overwrite:overwrite nestedZipLevel:nestedZipLevel - 1 password:password error:nil delegate:nil progressHandler:nil completionHandler:nil]) { [directoriesModificationDates removeLastObject]; [[NSFileManager defaultManager] removeItemAtPath:fullPath error:nil]; } else if (preserveAttributes) { // Set the original datetime property if (fileInfo.dos_date != 0) { NSDate *orgDate = [[self class] _dateWithMSDOSFormat:(UInt32)fileInfo.dos_date]; NSDictionary *attr = @{NSFileModificationDate: orgDate}; if (attr) { if (![fileManager setAttributes:attr ofItemAtPath:fullPath error:nil]) { // Can't set attributes NSLog(@"[SSZipArchive] Failed to set attributes - whilst setting modification date"); } } } // Set the original permissions on the file (+read/write to solve #293) uLong permissions = fileInfo.external_fa >> 16 | 0b110000000; if (permissions != 0) { // Store it into a NSNumber NSNumber *permissionsValue = @(permissions); // Retrieve any existing attributes NSMutableDictionary *attrs = [[NSMutableDictionary alloc] initWithDictionary:[fileManager attributesOfItemAtPath:fullPath error:nil]]; // Set the value in the attributes dict attrs[NSFilePosixPermissions] = permissionsValue; // Update attributes if (![fileManager setAttributes:attrs ofItemAtPath:fullPath error:nil]) { // Unable to set the permissions attribute NSLog(@"[SSZipArchive] Failed to set attributes - whilst setting permissions"); } } } } else { // if we couldn't open file descriptor we can validate global errno to see the reason if (errno == ENOSPC) { NSError *enospcError = [NSError errorWithDomain:NSPOSIXErrorDomain code:ENOSPC userInfo:nil]; unzippingError = enospcError; unzCloseCurrentFile(zip); success = NO; break; } } } else { // Let's assume error Z_DATA_ERROR is caused by an invalid password // Let's assume other errors are caused by Content Not Readable success = NO; break; } } else { // Assemble the path for the symbolic link NSMutableString *destinationPath = [NSMutableString string]; int bytesRead = 0; while ((bytesRead = unzReadCurrentFile(zip, buffer, 4096)) > 0) { buffer[bytesRead] = 0; [destinationPath appendString:@((const char *)buffer)]; } if (bytesRead < 0) { // Let's assume error Z_DATA_ERROR is caused by an invalid password // Let's assume other errors are caused by Content Not Readable success = NO; break; } // Check if the symlink exists and delete it if we're overwriting if (overwrite) { if ([fileManager fileExistsAtPath:fullPath]) { NSError *error = nil; BOOL removeSuccess = [fileManager removeItemAtPath:fullPath error:&error]; if (!removeSuccess) { NSString *message = [NSString stringWithFormat:@"Failed to delete existing symbolic link at \"%@\"", error.localizedDescription]; NSLog(@"[SSZipArchive] %@", message); success = NO; unzippingError = [NSError errorWithDomain:SSZipArchiveErrorDomain code:error.code userInfo:@{NSLocalizedDescriptionKey: message}]; } } } // Create the symbolic link (making sure it stays relative if it was relative before) int symlinkError = symlink([destinationPath cStringUsingEncoding:NSUTF8StringEncoding], [fullPath cStringUsingEncoding:NSUTF8StringEncoding]); if (symlinkError != 0) { // Bubble the error up to the completion handler NSString *message = [NSString stringWithFormat:@"Failed to create symbolic link at \"%@\" to \"%@\" - symlink() error code: %d", fullPath, destinationPath, errno]; NSLog(@"[SSZipArchive] %@", message); success = NO; unzippingError = [NSError errorWithDomain:NSPOSIXErrorDomain code:symlinkError userInfo:@{NSLocalizedDescriptionKey: message}]; } } crc_ret = unzCloseCurrentFile(zip); if (crc_ret == UNZ_CRCERROR) { // CRC ERROR success = NO; break; } ret = unzGoToNextFile(zip); // Message delegate if ([delegate respondsToSelector:@selector(zipArchiveDidUnzipFileAtIndex:totalFiles:archivePath:fileInfo:)]) { [delegate zipArchiveDidUnzipFileAtIndex:currentFileNumber totalFiles:(NSInteger)globalInfo.number_entry archivePath:path fileInfo:fileInfo]; } else if ([delegate respondsToSelector: @selector(zipArchiveDidUnzipFileAtIndex:totalFiles:archivePath:unzippedFilePath:)]) { [delegate zipArchiveDidUnzipFileAtIndex: currentFileNumber totalFiles: (NSInteger)globalInfo.number_entry archivePath:path unzippedFilePath: fullPath]; } if (progressHandler) { progressHandler(strPath, fileInfo, currentFileNumber, globalInfo.number_entry); } } } while (ret == UNZ_OK && success); // Close unzClose(zip); // The process of decompressing the .zip archive causes the modification times on the folders // to be set to the present time. So, when we are done, they need to be explicitly set. // set the modification date on all of the directories. if (success && preserveAttributes) { NSError * err = nil; for (NSDictionary * d in directoriesModificationDates) { if (![[NSFileManager defaultManager] setAttributes:@{NSFileModificationDate: d[@"modDate"]} ofItemAtPath:d[@"path"] error:&err]) { NSLog(@"[SSZipArchive] Set attributes failed for directory: %@.", d[@"path"]); } if (err) { NSLog(@"[SSZipArchive] Error setting directory file modification date attribute: %@", err.localizedDescription); } } } // Message delegate if (success && [delegate respondsToSelector:@selector(zipArchiveDidUnzipArchiveAtPath:zipInfo:unzippedPath:)]) { [delegate zipArchiveDidUnzipArchiveAtPath:path zipInfo:globalInfo unzippedPath:destination]; } // final progress event = 100% if (!canceled && [delegate respondsToSelector:@selector(zipArchiveProgressEvent:total:)]) { [delegate zipArchiveProgressEvent:fileSize total:fileSize]; } NSError *retErr = nil; if (crc_ret == UNZ_CRCERROR) { NSDictionary *userInfo = @{NSLocalizedDescriptionKey: @"crc check failed for file"}; retErr = [NSError errorWithDomain:SSZipArchiveErrorDomain code:SSZipArchiveErrorCodeFileInfoNotLoadable userInfo:userInfo]; } if (error) { if (unzippingError) { *error = unzippingError; } else { *error = retErr; } } if (completionHandler) { if (unzippingError) { completionHandler(path, success, unzippingError); } else { completionHandler(path, success, retErr); } } return success; } #pragma mark - Zipping + (BOOL)createZipFileAtPath:(NSString *)path withFilesAtPaths:(NSArray *)paths { return [SSZipArchive createZipFileAtPath:path withFilesAtPaths:paths withPassword:nil]; } + (BOOL)createZipFileAtPath:(NSString *)path withContentsOfDirectory:(NSString *)directoryPath { return [SSZipArchive createZipFileAtPath:path withContentsOfDirectory:directoryPath withPassword:nil]; } + (BOOL)createZipFileAtPath:(NSString *)path withContentsOfDirectory:(NSString *)directoryPath keepParentDirectory:(BOOL)keepParentDirectory { return [SSZipArchive createZipFileAtPath:path withContentsOfDirectory:directoryPath keepParentDirectory:keepParentDirectory withPassword:nil]; } + (BOOL)createZipFileAtPath:(NSString *)path withFilesAtPaths:(NSArray *)paths withPassword:(NSString *)password { SSZipArchive *zipArchive = [[SSZipArchive alloc] initWithPath:path]; BOOL success = [zipArchive open]; if (success) { for (NSString *filePath in paths) { success &= [zipArchive writeFile:filePath withPassword:password]; } success &= [zipArchive close]; } return success; } + (BOOL)createZipFileAtPath:(NSString *)path withContentsOfDirectory:(NSString *)directoryPath withPassword:(nullable NSString *)password { return [SSZipArchive createZipFileAtPath:path withContentsOfDirectory:directoryPath keepParentDirectory:NO withPassword:password]; } + (BOOL)createZipFileAtPath:(NSString *)path withContentsOfDirectory:(NSString *)directoryPath keepParentDirectory:(BOOL)keepParentDirectory withPassword:(nullable NSString *)password { return [SSZipArchive createZipFileAtPath:path withContentsOfDirectory:directoryPath keepParentDirectory:keepParentDirectory withPassword:password andProgressHandler:nil ]; } + (BOOL)createZipFileAtPath:(NSString *)path withContentsOfDirectory:(NSString *)directoryPath keepParentDirectory:(BOOL)keepParentDirectory withPassword:(nullable NSString *)password andProgressHandler:(void(^ _Nullable)(NSUInteger entryNumber, NSUInteger total))progressHandler { return [self createZipFileAtPath:path withContentsOfDirectory:directoryPath keepParentDirectory:keepParentDirectory compressionLevel:Z_DEFAULT_COMPRESSION password:password AES:YES progressHandler:progressHandler]; } + (BOOL)createZipFileAtPath:(NSString *)path withContentsOfDirectory:(NSString *)directoryPath keepParentDirectory:(BOOL)keepParentDirectory compressionLevel:(int)compressionLevel password:(nullable NSString *)password AES:(BOOL)aes progressHandler:(void(^ _Nullable)(NSUInteger entryNumber, NSUInteger total))progressHandler { SSZipArchive *zipArchive = [[SSZipArchive alloc] initWithPath:path]; BOOL success = [zipArchive open]; if (success) { // use a local fileManager (queue/thread compatibility) NSFileManager *fileManager = [[NSFileManager alloc] init]; NSDirectoryEnumerator *dirEnumerator = [fileManager enumeratorAtPath:directoryPath]; NSArray *allObjects = dirEnumerator.allObjects; NSUInteger total = allObjects.count, complete = 0; NSString *fileName; for (fileName in allObjects) { BOOL isDir; NSString *fullFilePath = [directoryPath stringByAppendingPathComponent:fileName]; [fileManager fileExistsAtPath:fullFilePath isDirectory:&isDir]; if (keepParentDirectory) { fileName = [directoryPath.lastPathComponent stringByAppendingPathComponent:fileName]; } if (!isDir) { success &= [zipArchive writeFileAtPath:fullFilePath withFileName:fileName compressionLevel:compressionLevel password:password AES:aes]; } else { if ([[NSFileManager defaultManager] subpathsOfDirectoryAtPath:fullFilePath error:nil].count == 0) { success &= [zipArchive writeFolderAtPath:fullFilePath withFolderName:fileName withPassword:password]; } } complete++; if (progressHandler) { progressHandler(complete, total); } } success &= [zipArchive close]; } return success; } // disabling `init` because designated initializer is `initWithPath:` - (instancetype)init { @throw nil; } // designated initializer - (instancetype)initWithPath:(NSString *)path { if ((self = [super init])) { _path = [path copy]; } return self; } - (BOOL)open { NSAssert((_zip == NULL), @"Attempting to open an archive which is already open"); _zip = zipOpen(_path.fileSystemRepresentation, APPEND_STATUS_CREATE); return (NULL != _zip); } - (BOOL)writeFolderAtPath:(NSString *)path withFolderName:(NSString *)folderName withPassword:(nullable NSString *)password { NSAssert((_zip != NULL), @"Attempting to write to an archive which was never opened"); zip_fileinfo zipInfo = {}; [SSZipArchive zipInfo:&zipInfo setAttributesOfItemAtPath:path]; int error = _zipOpenEntry(_zip, [folderName stringByAppendingString:@"/"], &zipInfo, Z_NO_COMPRESSION, password, 0); const void *buffer = NULL; zipWriteInFileInZip(_zip, buffer, 0); zipCloseFileInZip(_zip); return error == ZIP_OK; } - (BOOL)writeFile:(NSString *)path withPassword:(nullable NSString *)password { return [self writeFileAtPath:path withFileName:nil withPassword:password]; } - (BOOL)writeFileAtPath:(NSString *)path withFileName:(nullable NSString *)fileName withPassword:(nullable NSString *)password { return [self writeFileAtPath:path withFileName:fileName compressionLevel:Z_DEFAULT_COMPRESSION password:password AES:YES]; } // supports writing files with logical folder/directory structure // *path* is the absolute path of the file that will be compressed // *fileName* is the relative name of the file how it is stored within the zip e.g. /folder/subfolder/text1.txt - (BOOL)writeFileAtPath:(NSString *)path withFileName:(nullable NSString *)fileName compressionLevel:(int)compressionLevel password:(nullable NSString *)password AES:(BOOL)aes { NSAssert((_zip != NULL), @"Attempting to write to an archive which was never opened"); FILE *input = fopen(path.fileSystemRepresentation, "r"); if (NULL == input) { return NO; } if (!fileName) { fileName = path.lastPathComponent; } zip_fileinfo zipInfo = {}; [SSZipArchive zipInfo:&zipInfo setAttributesOfItemAtPath:path]; void *buffer = malloc(CHUNK); if (buffer == NULL) { fclose(input); return NO; } int error = _zipOpenEntry(_zip, fileName, &zipInfo, compressionLevel, password, aes); while (!feof(input) && !ferror(input)) { unsigned int len = (unsigned int) fread(buffer, 1, CHUNK, input); zipWriteInFileInZip(_zip, buffer, len); } zipCloseFileInZip(_zip); free(buffer); fclose(input); return error == ZIP_OK; } - (BOOL)writeData:(NSData *)data filename:(nullable NSString *)filename withPassword:(nullable NSString *)password { return [self writeData:data filename:filename compressionLevel:Z_DEFAULT_COMPRESSION password:password AES:YES]; } - (BOOL)writeData:(NSData *)data filename:(nullable NSString *)filename compressionLevel:(int)compressionLevel password:(nullable NSString *)password AES:(BOOL)aes { if (!_zip) { return NO; } if (!data) { return NO; } zip_fileinfo zipInfo = {}; [SSZipArchive zipInfo:&zipInfo setDate:[NSDate date]]; int error = _zipOpenEntry(_zip, filename, &zipInfo, compressionLevel, password, aes); zipWriteInFileInZip(_zip, data.bytes, (unsigned int)data.length); zipCloseFileInZip(_zip); return error == ZIP_OK; } - (BOOL)close { NSAssert((_zip != NULL), @"[SSZipArchive] Attempting to close an archive which was never opened"); int error = zipClose(_zip, NULL); _zip = nil; return error == UNZ_OK; } #pragma mark - Private + (NSString *)_filenameStringWithCString:(const char *)filename size:(uint16_t)size_filename { NSString * strPath = @(filename); if (strPath) { return strPath; } // if filename is non-unicode, detect and transform Encoding NSData *data = [NSData dataWithBytes:(const void *)filename length:sizeof(unsigned char) * size_filename]; #ifdef __MAC_10_13 // Xcode 9+ if (@available(macOS 10.10, iOS 8.0, watchOS 2.0, tvOS 9.0, *)) { // supported encodings are in [NSString availableStringEncodings] [NSString stringEncodingForData:data encodingOptions:nil convertedString:&strPath usedLossyConversion:nil]; } #else // Xcode 8- if (floor(NSFoundationVersionNumber) > NSFoundationVersionNumber10_9_2) { // supported encodings are in [NSString availableStringEncodings] [NSString stringEncodingForData:data encodingOptions:nil convertedString:&strPath usedLossyConversion:nil]; } #endif else { // fallback to a simple manual detect for macOS 10.9 or older NSArray *encodings = @[@(kCFStringEncodingGB_18030_2000), @(kCFStringEncodingShiftJIS)]; for (NSNumber *encoding in encodings) { strPath = [NSString stringWithCString:filename encoding:(NSStringEncoding)CFStringConvertEncodingToNSStringEncoding(encoding.unsignedIntValue)]; if (strPath) { break; } } } if (!strPath) { // if filename encoding is non-detected, we default to something based on data // _hexString is more readable than _base64RFC4648 for debugging unknown encodings strPath = [data _hexString]; } return strPath; } + (void)zipInfo:(zip_fileinfo *)zipInfo setAttributesOfItemAtPath:(NSString *)path { NSDictionary *attr = [[NSFileManager defaultManager] attributesOfItemAtPath:path error: nil]; if (attr) { NSDate *fileDate = (NSDate *)attr[NSFileModificationDate]; if (fileDate) { [self zipInfo:zipInfo setDate:fileDate]; } // Write permissions into the external attributes, for details on this see here: http://unix.stackexchange.com/a/14727 // Get the permissions value from the files attributes NSNumber *permissionsValue = (NSNumber *)attr[NSFilePosixPermissions]; if (permissionsValue != nil) { // Get the short value for the permissions short permissionsShort = permissionsValue.shortValue; // Convert this into an octal by adding 010000, 010000 being the flag for a regular file NSInteger permissionsOctal = 0100000 + permissionsShort; // Convert this into a long value uLong permissionsLong = @(permissionsOctal).unsignedLongValue; // Store this into the external file attributes once it has been shifted 16 places left to form part of the second from last byte // Casted back to an unsigned int to match type of external_fa in minizip zipInfo->external_fa = (unsigned int)(permissionsLong << 16L); } } } + (void)zipInfo:(zip_fileinfo *)zipInfo setDate:(NSDate *)date { NSCalendar *currentCalendar = SSZipArchive._gregorian; NSCalendarUnit flags = NSCalendarUnitYear | NSCalendarUnitMonth | NSCalendarUnitDay | NSCalendarUnitHour | NSCalendarUnitMinute | NSCalendarUnitSecond; NSDateComponents *components = [currentCalendar components:flags fromDate:date]; struct tm tmz_date; tmz_date.tm_sec = (unsigned int)components.second; tmz_date.tm_min = (unsigned int)components.minute; tmz_date.tm_hour = (unsigned int)components.hour; tmz_date.tm_mday = (unsigned int)components.day; // ISO/IEC 9899 struct tm is 0-indexed for January but NSDateComponents for gregorianCalendar is 1-indexed for January tmz_date.tm_mon = (unsigned int)components.month - 1; // ISO/IEC 9899 struct tm is 0-indexed for AD 1900 but NSDateComponents for gregorianCalendar is 1-indexed for AD 1 tmz_date.tm_year = (unsigned int)components.year - 1900; zipInfo->dos_date = tm_to_dosdate(&tmz_date); } + (NSCalendar *)_gregorian { static NSCalendar *gregorian; static dispatch_once_t onceToken; dispatch_once(&onceToken, ^{ gregorian = [[NSCalendar alloc] initWithCalendarIdentifier:NSCalendarIdentifierGregorian]; }); return gregorian; } // Format from http://newsgroups.derkeiler.com/Archive/Comp/comp.os.msdos.programmer/2009-04/msg00060.html // Two consecutive words, or a longword, YYYYYYYMMMMDDDDD hhhhhmmmmmmsssss // YYYYYYY is years from 1980 = 0 // sssss is (seconds/2). // // 3658 = 0011 0110 0101 1000 = 0011011 0010 11000 = 27 2 24 = 2007-02-24 // 7423 = 0111 0100 0010 0011 - 01110 100001 00011 = 14 33 3 = 14:33:06 + (NSDate *)_dateWithMSDOSFormat:(UInt32)msdosDateTime { // the whole `_dateWithMSDOSFormat:` method is equivalent but faster than this one line, // essentially because `mktime` is slow: //NSDate *date = [NSDate dateWithTimeIntervalSince1970:dosdate_to_time_t(msdosDateTime)]; static const UInt32 kYearMask = 0xFE000000; static const UInt32 kMonthMask = 0x1E00000; static const UInt32 kDayMask = 0x1F0000; static const UInt32 kHourMask = 0xF800; static const UInt32 kMinuteMask = 0x7E0; static const UInt32 kSecondMask = 0x1F; NSAssert(0xFFFFFFFF == (kYearMask | kMonthMask | kDayMask | kHourMask | kMinuteMask | kSecondMask), @"[SSZipArchive] MSDOS date masks don't add up"); NSDateComponents *components = [[NSDateComponents alloc] init]; components.year = 1980 + ((msdosDateTime & kYearMask) >> 25); components.month = (msdosDateTime & kMonthMask) >> 21; components.day = (msdosDateTime & kDayMask) >> 16; components.hour = (msdosDateTime & kHourMask) >> 11; components.minute = (msdosDateTime & kMinuteMask) >> 5; components.second = (msdosDateTime & kSecondMask) * 2; NSDate *date = [self._gregorian dateFromComponents:components]; return date; } @end int _zipOpenEntry(zipFile entry, NSString *name, const zip_fileinfo *zipfi, int level, NSString *password, BOOL aes) { return zipOpenNewFileInZip5(entry, name.fileSystemRepresentation, zipfi, NULL, 0, NULL, 0, NULL, 0, 0, Z_DEFLATED, level, 0, -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, password.UTF8String, aes); } #pragma mark - Private tools for file info BOOL _fileIsSymbolicLink(const unz_file_info *fileInfo) { // // Determine whether this is a symbolic link: // - File is stored with 'version made by' value of UNIX (3), // as per http://www.pkware.com/documents/casestudies/APPNOTE.TXT // in the upper byte of the version field. // - BSD4.4 st_mode constants are stored in the high 16 bits of the // external file attributes (defacto standard, verified against libarchive) // // The original constants can be found here: // http://minnie.tuhs.org/cgi-bin/utree.pl?file=4.4BSD/usr/include/sys/stat.h // const uLong ZipUNIXVersion = 3; const uLong BSD_SFMT = 0170000; const uLong BSD_IFLNK = 0120000; BOOL fileIsSymbolicLink = ((fileInfo->version >> 8) == ZipUNIXVersion) && BSD_IFLNK == (BSD_SFMT & (fileInfo->external_fa >> 16)); return fileIsSymbolicLink; } #pragma mark - Private tools for unreadable encodings @implementation NSData (SSZipArchive) // `base64EncodedStringWithOptions` uses a base64 alphabet with '+' and '/'. // we got those alternatives to make it compatible with filenames: https://en.wikipedia.org/wiki/Base64 // * modified Base64 encoding for IMAP mailbox names (RFC 3501): uses '+' and ',' // * modified Base64 for URL and filenames (RFC 4648): uses '-' and '_' - (NSString *)_base64RFC4648 { NSString *strName = [self base64EncodedStringWithOptions:0]; strName = [strName stringByReplacingOccurrencesOfString:@"+" withString:@"-"]; strName = [strName stringByReplacingOccurrencesOfString:@"/" withString:@"_"]; return strName; } // initWithBytesNoCopy from NSProgrammer, Jan 25 '12: https://stackoverflow.com/a/9009321/1033581 // hexChars from Peter, Aug 19 '14: https://stackoverflow.com/a/25378464/1033581 // not implemented as too lengthy: a potential mapping improvement from Moose, Nov 3 '15: https://stackoverflow.com/a/33501154/1033581 - (NSString *)_hexString { const char *hexChars = "0123456789ABCDEF"; NSUInteger length = self.length; const unsigned char *bytes = self.bytes; char *chars = malloc(length * 2); char *s = chars; NSUInteger i = length; while (i--) { *s++ = hexChars[*bytes >> 4]; *s++ = hexChars[*bytes & 0xF]; bytes++; } NSString *str = [[NSString alloc] initWithBytesNoCopy:chars length:length * 2 encoding:NSASCIIStringEncoding freeWhenDone:YES]; return str; } @end