From 4e53cc616af56c4f3c92fbcd0f47d577fe98a071 Mon Sep 17 00:00:00 2001 From: Aaron Jubbal Date: Sat, 10 Sep 2016 01:39:08 -0700 Subject: [PATCH 1/3] iOS version of app unzips and parses GTFS file upon app launch. --- .../GTFSImporter/CSVImporter.h | 31 + .../GTFSImporter/CSVImporter.m | 543 +++++ .../GTFSImporter/GTFSImporter-Prefix.pch | 7 + .../GTFSImporter/GTFSImporter.1 | 79 + .../Libraries/CSVParser/CSVParser.h | 60 + .../Libraries/CSVParser/CSVParser.m | 520 +++++ .../Libraries/SQLite/FMDatabase.h | 155 ++ .../Libraries/SQLite/FMDatabase.m | 1148 ++++++++++ .../Libraries/SQLite/FMDatabaseAdditions.h | 37 + .../Libraries/SQLite/FMDatabaseAdditions.m | 163 ++ .../Libraries/SQLite/FMDatabasePool.h | 75 + .../Libraries/SQLite/FMDatabasePool.m | 244 +++ .../Libraries/SQLite/FMDatabaseQueue.h | 38 + .../Libraries/SQLite/FMDatabaseQueue.m | 176 ++ .../Libraries/SQLite/FMResultSet.h | 105 + .../Libraries/SQLite/FMResultSet.m | 431 ++++ .../GTFSImporter/Model/Agency.h | 25 + .../GTFSImporter/Model/Agency.m | 101 + .../GTFSImporter/Model/Calendar.h | 31 + .../GTFSImporter/Model/Calendar.m | 123 ++ .../GTFSImporter/Model/CalendarDate.h | 22 + .../GTFSImporter/Model/CalendarDate.m | 105 + .../GTFSImporter/Model/FareAttributes.h | 26 + .../GTFSImporter/Model/FareAttributes.m | 101 + .../GTFSImporter/Model/FareRules.h | 25 + .../GTFSImporter/Model/FareRules.m | 99 + .../GTFSImporter/Model/Route.h | 26 + .../GTFSImporter/Model/Route.m | 137 ++ .../GTFSImporter/Model/Shape.h | 25 + .../GTFSImporter/Model/Shape.m | 104 + iOS/GTFSImporteriOS/GTFSImporter/Model/Stop.h | 30 + iOS/GTFSImporteriOS/GTFSImporter/Model/Stop.m | 162 ++ .../GTFSImporter/Model/StopTime.h | 33 + .../GTFSImporter/Model/StopTime.m | 292 +++ .../GTFSImporter/Model/Transformations.h | 16 + .../GTFSImporter/Model/Transformations.m | 71 + iOS/GTFSImporteriOS/GTFSImporter/Model/Trip.h | 28 + iOS/GTFSImporteriOS/GTFSImporter/Model/Trip.m | 152 ++ iOS/GTFSImporteriOS/GTFSImporter/Util.h | 29 + iOS/GTFSImporteriOS/GTFSImporter/Util.m | 181 ++ iOS/GTFSImporteriOS/GTFSImporter/main.m | 101 + .../GTFSImporteriOS.xcodeproj/project.pbxproj | 630 ++++++ .../GTFSImporteriOS/AppDelegate.h | 17 + .../GTFSImporteriOS/AppDelegate.m | 133 ++ .../AppIcon.appiconset/Contents.json | 68 + .../Base.lproj/LaunchScreen.storyboard | 27 + .../Base.lproj/Main.storyboard | 25 + .../SSZipArchive/Info.plist | 26 + .../SSZipArchive/SSZipArchive.h | 93 + .../SSZipArchive/SSZipArchive.m | 816 +++++++ .../SSZipArchive/SSZipCommon.h | 81 + .../SSZipArchive/ZipArchive.h | 19 + .../External Libraries/SSZipArchive/aes/aes.h | 198 ++ .../SSZipArchive/aes/aes_via_ace.h | 541 +++++ .../SSZipArchive/aes/aescrypt.c | 294 +++ .../SSZipArchive/aes/aeskey.c | 548 +++++ .../SSZipArchive/aes/aesopt.h | 739 +++++++ .../SSZipArchive/aes/aestab.c | 391 ++++ .../SSZipArchive/aes/aestab.h | 173 ++ .../SSZipArchive/aes/brg_endian.h | 126 ++ .../SSZipArchive/aes/brg_types.h | 219 ++ .../SSZipArchive/aes/entropy.c | 54 + .../SSZipArchive/aes/entropy.h | 16 + .../SSZipArchive/aes/fileenc.c | 144 ++ .../SSZipArchive/aes/fileenc.h | 121 ++ .../SSZipArchive/aes/hmac.c | 145 ++ .../SSZipArchive/aes/hmac.h | 103 + .../SSZipArchive/aes/prng.c | 155 ++ .../SSZipArchive/aes/prng.h | 82 + .../SSZipArchive/aes/pwd2key.c | 193 ++ .../SSZipArchive/aes/pwd2key.h | 57 + .../SSZipArchive/aes/sha1.c | 258 +++ .../SSZipArchive/aes/sha1.h | 73 + .../SSZipArchive/minizip/crypt.h | 130 ++ .../SSZipArchive/minizip/ioapi.c | 369 ++++ .../SSZipArchive/minizip/ioapi.h | 175 ++ .../SSZipArchive/minizip/mztools.c | 284 +++ .../SSZipArchive/minizip/mztools.h | 31 + .../SSZipArchive/minizip/unzip.c | 1839 ++++++++++++++++ .../SSZipArchive/minizip/unzip.h | 248 +++ .../SSZipArchive/minizip/zip.c | 1915 +++++++++++++++++ .../SSZipArchive/minizip/zip.h | 202 ++ .../GTFSImporteriOS/Info.plist | 47 + .../Resources/GTFS Caltrain Devs.zip | Bin 0 -> 39381 bytes .../GTFSImporteriOS/ViewController.h | 15 + .../GTFSImporteriOS/ViewController.m | 27 + iOS/GTFSImporteriOS/GTFSImporteriOS/main.m | 16 + 87 files changed, 17720 insertions(+) create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/CSVImporter.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/CSVImporter.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/GTFSImporter-Prefix.pch create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/GTFSImporter.1 create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/CSVParser/CSVParser.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/CSVParser/CSVParser.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabase.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabase.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseAdditions.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseAdditions.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabasePool.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabasePool.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseQueue.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseQueue.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMResultSet.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMResultSet.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Agency.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Agency.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Calendar.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Calendar.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/CalendarDate.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/CalendarDate.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/FareAttributes.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/FareAttributes.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/FareRules.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/FareRules.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Route.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Route.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Shape.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Shape.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Stop.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Stop.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/StopTime.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/StopTime.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Transformations.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Transformations.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Trip.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Trip.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Util.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Util.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporter/main.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporteriOS.xcodeproj/project.pbxproj create mode 100644 iOS/GTFSImporteriOS/GTFSImporteriOS/AppDelegate.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporteriOS/AppDelegate.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporteriOS/Assets.xcassets/AppIcon.appiconset/Contents.json create mode 100644 iOS/GTFSImporteriOS/GTFSImporteriOS/Base.lproj/LaunchScreen.storyboard create mode 100644 iOS/GTFSImporteriOS/GTFSImporteriOS/Base.lproj/Main.storyboard create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/Info.plist create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/SSZipArchive.h create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/SSZipArchive.m create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/SSZipCommon.h create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/ZipArchive.h create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aes.h create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aes_via_ace.h create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aescrypt.c create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aeskey.c create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aesopt.h create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aestab.c create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aestab.h create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/brg_endian.h create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/brg_types.h create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/entropy.c create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/entropy.h create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/fileenc.c create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/fileenc.h create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/hmac.c create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/hmac.h create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/prng.c create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/prng.h create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/pwd2key.c create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/pwd2key.h create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/sha1.c create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/sha1.h create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/crypt.h create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/ioapi.c create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/ioapi.h create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/mztools.c create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/mztools.h create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/unzip.c create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/unzip.h create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/zip.c create mode 100755 iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/zip.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporteriOS/Info.plist create mode 100644 iOS/GTFSImporteriOS/GTFSImporteriOS/Resources/GTFS Caltrain Devs.zip create mode 100644 iOS/GTFSImporteriOS/GTFSImporteriOS/ViewController.h create mode 100644 iOS/GTFSImporteriOS/GTFSImporteriOS/ViewController.m create mode 100644 iOS/GTFSImporteriOS/GTFSImporteriOS/main.m diff --git a/iOS/GTFSImporteriOS/GTFSImporter/CSVImporter.h b/iOS/GTFSImporteriOS/GTFSImporter/CSVImporter.h new file mode 100644 index 0000000..2834294 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/CSVImporter.h @@ -0,0 +1,31 @@ +// +// CSVImporter.h +// San Jose Transit GTFS +// +// Created by Vashishtha Jogi on 8/27/11. +// Copyright 2011 Vashishtha Jogi Inc. All rights reserved. +// + +#import + +@interface CSVImporter : NSObject + +- (NSString *)parseForFile:(NSString *)file; +- (int) addAgency; +- (int) addCalendar; +- (int) addCalendarDate; +- (int) addFareAttributes; +- (int) addFareRules; +- (int) addRoute; +- (int) addShape; +- (int) addStop; +- (int) addStopRoutes; +- (int) addStopTime; +- (int) addInterpolatedStopTime; +- (int) addTrip; +- (void) sanitizeData; +- (void) vacuum; +- (void) reindex; + + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/CSVImporter.m b/iOS/GTFSImporteriOS/GTFSImporter/CSVImporter.m new file mode 100644 index 0000000..e745785 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/CSVImporter.m @@ -0,0 +1,543 @@ +// +// CSVImporter.m +// San Jose Transit GTFS +// +// Created by Vashishtha Jogi on 8/27/11. +// Copyright 2011 Vashishtha Jogi Inc. All rights reserved. +// + +#import "CSVImporter.h" +#import "FMDatabase.h" +#import "CSVParser.h" +#import "Agency.h" +#import "FareAttributes.h" +#import "FareRules.h" +#import "Calendar.h" +#import "CalendarDate.h" +#import "Route.h" +#import "Shape.h" +#import "Stop.h" +#import "Trip.h" +#import "StopTime.h" +#import "Transformations.h" +#import "Util.h" + +@implementation CSVImporter + +- (id)init +{ + self = [super init]; + if (self) { + // Initialization code here. + } + + return self; +} + +- (NSString *)parseForFile:(NSString *)file +{ + NSError *error = nil; + NSString *inputPath = [[[Util getTransitFilesBasepath] stringByAppendingPathComponent:file] stringByAppendingPathExtension:@"txt"]; + NSString *csvString = [NSString stringWithContentsOfFile:inputPath encoding:NSUTF8StringEncoding error:&error]; + + if (!csvString) + { + NSLog(@"Couldn't read file at path %s\n. Error: %s", [inputPath UTF8String], [[error localizedDescription] ? [error localizedDescription] : [error description] UTF8String]); + } + return csvString; +} + +- (int) addCalendar +{ + NSDate *startDate = [NSDate date]; + + FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + [db setShouldCacheStatements:YES]; + if (![db open]) { + NSLog(@"Could not open db."); + //[db release]; + return 1; + } + + NSString *csvString = [self parseForFile:@"calendar"]; + + Calendar *cal = [[Calendar alloc] initWithDB:db]; + + CSVParser *parser = + [[CSVParser alloc] + initWithString:csvString + separator:@"," + hasHeader:YES + fieldNames:nil]; + + [cal cleanupAndCreate]; + [db beginTransaction]; + [parser parseRowsForReceiver:cal selector:@selector(receiveRecord:)]; + [db commit]; + + NSDate *endDate = [NSDate date]; + + NSLog(@"Calendar entries successfully imported in %f seconds.", [endDate timeIntervalSinceDate:startDate]); + + [db close]; + + return 0; +} + +- (int) addCalendarDate +{ + NSDate *startDate = [NSDate date]; + + FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + [db setShouldCacheStatements:YES]; + if (![db open]) { + NSLog(@"Could not open db."); + //[db release]; + return 1; + } + + NSString *csvString = [self parseForFile:@"calendar_dates"]; + + CalendarDate *calDate = [[CalendarDate alloc] initWithDB:db]; + + CSVParser *parser = + [[CSVParser alloc] + initWithString:csvString + separator:@"," + hasHeader:YES + fieldNames:nil]; + + [calDate cleanupAndCreate]; + [db beginTransaction]; + [parser parseRowsForReceiver:calDate selector:@selector(receiveRecord:)]; + [db commit]; + + NSDate *endDate = [NSDate date]; + + NSLog(@"Calendar Dates entries successfully imported in %f seconds.", [endDate timeIntervalSinceDate:startDate]); + + [db close]; + + return 0; +} + + +- (int) addAgency +{ + NSDate *startDate = [NSDate date]; + + FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + + [db setShouldCacheStatements:YES]; + if (![db open]) { + NSLog(@"Could not open db."); + //[db release]; + return 1; + } + + NSString *csvString = [self parseForFile:@"agency"]; + + Agency *agency = [[Agency alloc] initWithDB:db]; + + CSVParser *parser = + [[CSVParser alloc] + initWithString:csvString + separator:@"," + hasHeader:YES + fieldNames:nil]; + + [agency cleanupAndCreate]; + [db beginTransaction]; + [parser parseRowsForReceiver:agency selector:@selector(receiveRecord:)]; + [db commit]; + + NSDate *endDate = [NSDate date]; + + NSLog(@"Agency entries successfully imported in %f seconds.", [endDate timeIntervalSinceDate:startDate]); + + [db close]; + + return 0; +} + +- (int) addFareAttributes +{ + NSDate *startDate = [NSDate date]; + + FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + + [db setShouldCacheStatements:YES]; + if (![db open]) { + NSLog(@"Could not open db."); + //[db release]; + return 1; + } + + NSString *csvString = [self parseForFile:@"fare_attributes"]; + + FareAttributes *fareAttributes = [[FareAttributes alloc] initWithDB:db]; + + CSVParser *parser = + [[CSVParser alloc] + initWithString:csvString + separator:@"," + hasHeader:YES + fieldNames:nil]; + + [fareAttributes cleanupAndCreate]; + [db beginTransaction]; + [parser parseRowsForReceiver:fareAttributes selector:@selector(receiveRecord:)]; + [db commit]; + + NSDate *endDate = [NSDate date]; + + NSLog(@"FareAttributes entries successfully imported in %f seconds.", [endDate timeIntervalSinceDate:startDate]); + + [db close]; + return 0; +} + +- (int) addFareRules +{ + NSDate *startDate = [NSDate date]; + + FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + + [db setShouldCacheStatements:YES]; + if (![db open]) { + NSLog(@"Could not open db."); + //[db release]; + return 1; + } + + NSString *csvString = [self parseForFile:@"fare_rules"]; + + FareRules *fareRules = [[FareRules alloc] initWithDB:db]; + + CSVParser *parser = + [[CSVParser alloc] + initWithString:csvString + separator:@"," + hasHeader:YES + fieldNames:nil]; + + [fareRules cleanupAndCreate]; + [db beginTransaction]; + [parser parseRowsForReceiver:fareRules selector:@selector(receiveRecord:)]; + [db commit]; + + NSDate *endDate = [NSDate date]; + + NSLog(@"FareRules entries successfully imported in %f seconds.", [endDate timeIntervalSinceDate:startDate]); + + [db close]; + + return 0; +} + +- (int) addRoute +{ + NSDate *startDate = [NSDate date]; + + FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + + [db setShouldCacheStatements:YES]; + if (![db open]) { + NSLog(@"Could not open db."); + //[db release]; + return 1; + } + + NSString *csvString = [self parseForFile:@"routes"]; + + Route *route = [[Route alloc] initWithDB:db]; + + CSVParser *parser = + [[CSVParser alloc] + initWithString:csvString + separator:@"," + hasHeader:YES + fieldNames:nil]; + + [route cleanupAndCreate]; + [db beginTransaction]; + [parser parseRowsForReceiver:route selector:@selector(receiveRecord:)]; + [db commit]; + + NSDate *endDate = [NSDate date]; + + NSLog(@"Route entries successfully imported in %f seconds.", [endDate timeIntervalSinceDate:startDate]); + + [db close]; + + return 0; +} + +- (int) addShape +{ + NSDate *startDate = [NSDate date]; + + FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + + [db setShouldCacheStatements:YES]; + if (![db open]) { + NSLog(@"Could not open db."); + //[db release]; + return 1; + } + + NSString *csvString = [self parseForFile:@"shapes"]; + + Shape *shape = [[Shape alloc] initWithDB:db]; + + CSVParser *parser = + [[CSVParser alloc] + initWithString:csvString + separator:@"," + hasHeader:YES + fieldNames:nil]; + + [shape cleanupAndCreate]; + [db beginTransaction]; + [parser parseRowsForReceiver:shape selector:@selector(receiveRecord:)]; + [db commit]; + + NSDate *endDate = [NSDate date]; + + NSLog(@"Shape entries successfully imported in %f seconds.", [endDate timeIntervalSinceDate:startDate]); + + [db close]; + + return 0; +} + +- (int) addStop +{ + NSDate *startDate = [NSDate date]; + + FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + + [db setShouldCacheStatements:YES]; + if (![db open]) { + NSLog(@"Could not open db."); + //[db release]; + return 1; + } + + NSString *csvString = [self parseForFile:@"stops"]; + + Stop *stop = [[Stop alloc] initWithDB:db]; + + CSVParser *parser = + [[CSVParser alloc] + initWithString:csvString + separator:@"," + hasHeader:YES + fieldNames:nil]; + + [stop cleanupAndCreate]; + [db beginTransaction]; + [parser parseRowsForReceiver:stop selector:@selector(receiveRecord:)]; + [db commit]; + + NSDate *endDate = [NSDate date]; + + NSLog(@"Stop entries successfully imported in %f seconds.", [endDate timeIntervalSinceDate:startDate]); + + [db close]; + + return 0; +} + +- (int) addStopRoutes +{ + NSDate *startDate = [NSDate date]; + + FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + + [db setShouldCacheStatements:YES]; + if (![db open]) { + NSLog(@"Could not open db."); + //[db release]; + return 1; + } + + Stop *stop = [[Stop alloc] initWithDB:db]; + + [stop updateRoutes]; + + NSDate *endDate = [NSDate date]; + + NSLog(@"Stop entries successfully updated with routes in %f seconds.", [endDate timeIntervalSinceDate:startDate]); + + [db close]; + + return 0; +} + +- (int) addStopTime +{ + NSDate *startDate = [NSDate date]; + + FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + + [db setShouldCacheStatements:YES]; + if (![db open]) { + NSLog(@"Could not open db."); + //[db release]; + return 1; + } + + NSString *csvString = [self parseForFile:@"stop_times"]; + + StopTime *stopTime = [[StopTime alloc] initWithDB:db]; + + CSVParser *parser = + [[CSVParser alloc] + initWithString:csvString + separator:@"," + hasHeader:YES + fieldNames:nil]; + + [stopTime cleanupAndCreate]; + [db beginTransaction]; + [parser parseRowsForReceiver:stopTime selector:@selector(receiveRecord:)]; + [db commit]; + + NSDate *endDate = [NSDate date]; + + NSLog(@"StopTime entries successfully imported in %f seconds.", [endDate timeIntervalSinceDate:startDate]); + + [db close]; + + return 0; +} + +- (int) addInterpolatedStopTime +{ + NSDate *startDate = [NSDate date]; + + FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + + [db setShouldCacheStatements:YES]; + if (![db open]) { + NSLog(@"Could not open db."); + //[db release]; + return 1; + } + + StopTime *stopTime = [[StopTime alloc] initWithDB:db]; + + [stopTime interpolateStopTimes]; + + NSDate *endDate = [NSDate date]; + + NSLog(@"StopTime entries interpolated successfully in %f seconds.", [endDate timeIntervalSinceDate:startDate]); + + [db close]; + + + return 0; +} + +- (int) addTrip +{ + NSDate *startDate = [NSDate date]; + + FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + + [db setShouldCacheStatements:YES]; + if (![db open]) { + NSLog(@"Could not open db."); + //[db release]; + return 1; + } + + NSString *csvString = [self parseForFile:@"trips"]; + + Trip *trip = [[Trip alloc] initWithDB:db]; + + CSVParser *parser = + [[CSVParser alloc] + initWithString:csvString + separator:@"," + hasHeader:YES + fieldNames:nil]; + + [trip cleanupAndCreate]; + [db beginTransaction]; + [parser parseRowsForReceiver:trip selector:@selector(receiveRecord:)]; + [db commit]; + + NSDate *endDate = [NSDate date]; + + NSLog(@"Trip entries successfully imported in %f seconds.", [endDate timeIntervalSinceDate:startDate]); + + [db close]; + + return 0; +} + +- (void) sanitizeData +{ + Transformations *transformations = [[Transformations alloc] init]; + [transformations applyTransformationsFromCSV]; +} + + +- (void) vacuum +{ + NSDate *startDate = [NSDate date]; + + FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + + [db setShouldCacheStatements:YES]; + if (![db open]) { + NSLog(@"Could not open db."); + //[db release]; + } + + [db executeUpdate:@"VACUUM"]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } + + NSDate *endDate = [NSDate date]; + + NSLog(@"Vaccuuming done in %f seconds.", [endDate timeIntervalSinceDate:startDate]); + + + [db close]; +} + +- (void) reindex +{ + NSDate *startDate = [NSDate date]; + + FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + + [db setShouldCacheStatements:YES]; + if (![db open]) { + NSLog(@"Could not open db."); + //[db release]; + } + + [db executeUpdate:@"REINDEX"]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } + + NSDate *endDate = [NSDate date]; + + NSLog(@"Reindexing done in %f seconds.", [endDate timeIntervalSinceDate:startDate]); + + + [db close]; +} + + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/GTFSImporter-Prefix.pch b/iOS/GTFSImporteriOS/GTFSImporter/GTFSImporter-Prefix.pch new file mode 100644 index 0000000..8d9e41d --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/GTFSImporter-Prefix.pch @@ -0,0 +1,7 @@ +// +// Prefix header for all source files of the 'GTFSImporter' target in the 'GTFSImporter' project +// + +#ifdef __OBJC__ + #import +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporter/GTFSImporter.1 b/iOS/GTFSImporteriOS/GTFSImporter/GTFSImporter.1 new file mode 100644 index 0000000..e845743 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/GTFSImporter.1 @@ -0,0 +1,79 @@ +.\"Modified from man(1) of FreeBSD, the NetBSD mdoc.template, and mdoc.samples. +.\"See Also: +.\"man mdoc.samples for a complete listing of options +.\"man mdoc for the short list of editing options +.\"/usr/share/misc/mdoc.template +.Dd 8/27/11 \" DATE +.Dt GTFSImporter 1 \" Program name and manual section number +.Os Darwin +.Sh NAME \" Section Header - required - don't modify +.Nm GTFSImporter, +.\" The following lines are read in generating the apropos(man -k) database. Use only key +.\" words here as the database is built based on the words here and in the .ND line. +.Nm Other_name_for_same_program(), +.Nm Yet another name for the same program. +.\" Use .Nm macro to designate other names for the documented program. +.Nd This line parsed for whatis database. +.Sh SYNOPSIS \" Section Header - required - don't modify +.Nm +.Op Fl abcd \" [-abcd] +.Op Fl a Ar path \" [-a path] +.Op Ar file \" [file] +.Op Ar \" [file ...] +.Ar arg0 \" Underlined argument - use .Ar anywhere to underline +arg2 ... \" Arguments +.Sh DESCRIPTION \" Section Header - required - don't modify +Use the .Nm macro to refer to your program throughout the man page like such: +.Nm +Underlining is accomplished with the .Ar macro like this: +.Ar underlined text . +.Pp \" Inserts a space +A list of items with descriptions: +.Bl -tag -width -indent \" Begins a tagged list +.It item a \" Each item preceded by .It macro +Description of item a +.It item b +Description of item b +.El \" Ends the list +.Pp +A list of flags and their descriptions: +.Bl -tag -width -indent \" Differs from above in tag removed +.It Fl a \"-a flag as a list item +Description of -a flag +.It Fl b +Description of -b flag +.El \" Ends the list +.Pp +.\" .Sh ENVIRONMENT \" May not be needed +.\" .Bl -tag -width "ENV_VAR_1" -indent \" ENV_VAR_1 is width of the string ENV_VAR_1 +.\" .It Ev ENV_VAR_1 +.\" Description of ENV_VAR_1 +.\" .It Ev ENV_VAR_2 +.\" Description of ENV_VAR_2 +.\" .El +.Sh FILES \" File used or created by the topic of the man page +.Bl -tag -width "/Users/joeuser/Library/really_long_file_name" -compact +.It Pa /usr/share/file_name +FILE_1 description +.It Pa /Users/joeuser/Library/really_long_file_name +FILE_2 description +.El \" Ends the list +.\" .Sh DIAGNOSTICS \" May not be needed +.\" .Bl -diag +.\" .It Diagnostic Tag +.\" Diagnostic informtion here. +.\" .It Diagnostic Tag +.\" Diagnostic informtion here. +.\" .El +.Sh SEE ALSO +.\" List links in ascending order by section, alphabetically within a section. +.\" Please do not reference files that do not exist without filing a bug report +.Xr a 1 , +.Xr b 1 , +.Xr c 1 , +.Xr a 2 , +.Xr b 2 , +.Xr a 3 , +.Xr b 3 +.\" .Sh BUGS \" Document known, unremedied bugs +.\" .Sh HISTORY \" Document history if command behaves in a unique manner \ No newline at end of file diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/CSVParser/CSVParser.h b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/CSVParser/CSVParser.h new file mode 100644 index 0000000..8b9e8d1 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/CSVParser/CSVParser.h @@ -0,0 +1,60 @@ +// +// CSVParser.h +// CSVImporter +// +// Created by Matt Gallagher on 2009/11/30. +// Copyright 2009 Matt Gallagher. All rights reserved. +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. Permission is granted to anyone to +// use this software for any purpose, including commercial applications, and to +// alter it and redistribute it freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source +// distribution. +// + +#import + +@interface CSVParser : NSObject +{ + NSString *csvString; + NSString *separator; + NSScanner *scanner; + BOOL hasHeader; + NSMutableArray *fieldNames; + id receiver; + SEL receiverSelector; + NSCharacterSet *endTextCharacterSet; + BOOL separatorIsSingleChar; +} + +- (id)initWithString:(NSString *)aCSVString + separator:(NSString *)aSeparatorString + hasHeader:(BOOL)header + fieldNames:(NSArray *)names; + +- (NSArray *)arrayOfParsedRows; +- (void)parseRowsForReceiver:(id)aReceiver selector:(SEL)aSelector; + +- (NSArray *)parseFile; +- (NSMutableArray *)parseHeader; +- (NSDictionary *)parseRecord; +- (NSString *)parseName; +- (NSString *)parseField; +- (NSString *)parseEscaped; +- (NSString *)parseNonEscaped; +- (NSString *)parseDoubleQuote; +- (NSString *)parseSeparator; +- (NSString *)parseLineSeparator; +- (NSString *)parseTwoDoubleQuotes; +- (NSString *)parseTextData; + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/CSVParser/CSVParser.m b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/CSVParser/CSVParser.m new file mode 100644 index 0000000..ff7397c --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/CSVParser/CSVParser.m @@ -0,0 +1,520 @@ +// +// CSVParser.m +// CSVImporter +// +// Created by Matt Gallagher on 2009/11/30. +// Copyright 2009 Matt Gallagher. All rights reserved. +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. Permission is granted to anyone to +// use this software for any purpose, including commercial applications, and to +// alter it and redistribute it freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source +// distribution. +// + +#import "CSVParser.h" + + +@implementation CSVParser + +// +// initWithString:separator:hasHeader:fieldNames: +// +// Parameters: +// aCSVString - the string that will be parsed +// aSeparatorString - the separator (normally "," or "\t") +// header - if YES, treats the first row as a list of field names +// names - a list of field names (will have no effect if header is YES) +// +// returns the initialized object (nil on failure) +// +- (id)initWithString:(NSString *)aCSVString + separator:(NSString *)aSeparatorString + hasHeader:(BOOL)header + fieldNames:(NSArray *)names +{ + self = [super init]; + if (self) + { + csvString = [aCSVString retain]; + separator = [aSeparatorString retain]; + + NSAssert([separator length] > 0 && + [separator rangeOfString:@"\""].location == NSNotFound && + [separator rangeOfCharacterFromSet:[NSCharacterSet newlineCharacterSet]].location == NSNotFound, + @"CSV separator string must not be empty and must not contain the double quote character or newline characters."); + + NSMutableCharacterSet *endTextMutableCharacterSet = + [[NSCharacterSet newlineCharacterSet] mutableCopy]; + [endTextMutableCharacterSet addCharactersInString:@"\""]; + [endTextMutableCharacterSet addCharactersInString:[separator substringToIndex:1]]; + endTextCharacterSet = endTextMutableCharacterSet; + + if ([separator length] == 1) + { + separatorIsSingleChar = YES; + } + + hasHeader = header; + fieldNames = [names mutableCopy]; + } + + return self; +} + +// +// dealloc +// +// Releases instance memory. +// +- (void)dealloc +{ + [csvString release]; + [separator release]; + [fieldNames release]; + [endTextCharacterSet release]; + [super dealloc]; +} + + +// +// arrayOfParsedRows +// +// Performs a parsing of the csvString, returning the entire result. +// +// returns the array of all parsed row records +// +- (NSArray *)arrayOfParsedRows +{ + scanner = [[NSScanner alloc] initWithString:csvString]; + [scanner setCharactersToBeSkipped:[[[NSCharacterSet alloc] init] autorelease]]; + + NSArray *result = [self parseFile]; + [scanner release]; + scanner = nil; + + return result; +} + +// +// parseRowsForReceiver:selector: +// +// Performs a parsing of the csvString, sending the entries, 1 row at a time, +// to the receiver. +// +// Parameters: +// aReceiver - the target that will receive each row as it is parsed +// aSelector - the selector that will receive each row as it is parsed +// (should be a method that takes a single NSDictionary argument) +// +- (void)parseRowsForReceiver:(id)aReceiver selector:(SEL)aSelector +{ + scanner = [[NSScanner alloc] initWithString:csvString]; + [scanner setCharactersToBeSkipped:[[[NSCharacterSet alloc] init] autorelease]]; + receiver = [aReceiver retain]; + receiverSelector = aSelector; + + [self parseFile]; + + [scanner release]; + scanner = nil; + [receiver release]; + receiver = nil; +} + +// +// parseFile +// +// Attempts to parse a file from the current scan location. +// +// returns the parsed results if successful and receiver is nil, otherwise +// returns nil when done or on failure. +// +- (NSArray *)parseFile +{ + if (hasHeader) + { + if (fieldNames) + { + [fieldNames release]; + } + + fieldNames = [[self parseHeader] retain]; + if (!fieldNames || ![self parseLineSeparator]) + { + return nil; + } + } + + NSMutableArray *records = nil; + if (!receiver) + { + records = [NSMutableArray array]; + } + + NSDictionary *record = [[self parseRecord] retain]; + if (!record) + { + return nil; + } + + while (record) + { + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if (receiver) + { + [receiver performSelector:receiverSelector withObject:record]; + } + else + { + [records addObject:record]; + } + [record release]; + + if (![self parseLineSeparator]) + { + break; + } + + record = [[self parseRecord] retain]; + + [pool drain]; + } + + return records; +} + +// +// parseHeader +// +// Attempts to parse a header row from the current scan location. +// +// returns the array of parsed field names or nil on parse failure. +// +- (NSMutableArray *)parseHeader +{ + NSString *name = [self parseName]; + if (!name) + { + return nil; + } + + NSMutableArray *names = [NSMutableArray array]; + while (name) + { + [names addObject:name]; + + if (![self parseSeparator]) + { + break; + } + + name = [self parseName]; + } + return names; +} + +// +// parseRecord +// +// Attempts to parse a record from the current scan location. The record +// dictionary will use the fieldNames as keys, or FIELD_X for each column +// X-1 if no fieldName exists for a given column. +// +// returns the parsed record as a dictionary, or nil on failure. +// +- (NSDictionary *)parseRecord +{ + // + // Special case: return nil if the line is blank. Without this special case, + // it would parse as a single blank field. + // + if ([self parseLineSeparator] || [scanner isAtEnd]) + { + return nil; + } + + NSString *field = [self parseField]; + if (!field) + { + return nil; + } + + NSInteger fieldNamesCount = [fieldNames count]; + NSInteger fieldCount = 0; + + NSMutableDictionary *record = + [NSMutableDictionary dictionaryWithCapacity:[fieldNames count]]; + while (field) + { + NSString *fieldName; + if (fieldNamesCount > fieldCount) + { + fieldName = [fieldNames objectAtIndex:fieldCount]; + } + else + { + fieldName = [NSString stringWithFormat:@"FIELD_%ld", fieldCount + 1]; + [fieldNames addObject:fieldName]; + fieldNamesCount++; + } + + [record setObject:field forKey:fieldName]; + fieldCount++; + + if (![self parseSeparator]) + { + break; + } + + field = [self parseField]; + } + + return record; +} + +// +// parseName +// +// Attempts to parse a name from the current scan location. +// +// returns the name or nil. +// +- (NSString *)parseName +{ + return [self parseField]; +} + +// +// parseField +// +// Attempts to parse a field from the current scan location. +// +// returns the field or nil +// +- (NSString *)parseField +{ + NSString *escapedString = [self parseEscaped]; + if (escapedString) + { + return escapedString; + } + + NSString *nonEscapedString = [self parseNonEscaped]; + if (nonEscapedString) + { + return nonEscapedString; + } + + // + // Special case: if the current location is immediately + // followed by a separator, then the field is a valid, empty string. + // + NSInteger currentLocation = [scanner scanLocation]; + if ([self parseSeparator] || [self parseLineSeparator] || [scanner isAtEnd]) + { + [scanner setScanLocation:currentLocation]; + return @""; + } + + return nil; +} + +// +// parseEscaped +// +// Attempts to parse an escaped field value from the current scan location. +// +// returns the field value or nil. +// +- (NSString *)parseEscaped +{ + if (![self parseDoubleQuote]) + { + return nil; + } + + NSString *accumulatedData = [NSString string]; + while (YES) + { + NSString *fragment = [self parseTextData]; + if (!fragment) + { + fragment = [self parseSeparator]; + if (!fragment) + { + fragment = [self parseLineSeparator]; + if (!fragment) + { + if ([self parseTwoDoubleQuotes]) + { + fragment = @"\""; + } + else + { + break; + } + } + } + } + + accumulatedData = [accumulatedData stringByAppendingString:fragment]; + } + + if (![self parseDoubleQuote]) + { + return nil; + } + + return accumulatedData; +} + +// +// parseNonEscaped +// +// Attempts to parse a non-escaped field value from the current scan location. +// +// returns the field value or nil. +// +- (NSString *)parseNonEscaped +{ + return [self parseTextData]; +} + +// +// parseTwoDoubleQuotes +// +// Attempts to parse two double quotes from the current scan location. +// +// returns a string containing two double quotes or nil. +// +- (NSString *)parseTwoDoubleQuotes +{ + if ([scanner scanString:@"\"\"" intoString:NULL]) + { + return @"\"\""; + } + return nil; +} + +// +// parseDoubleQuote +// +// Attempts to parse a double quote from the current scan location. +// +// returns @"\"" or nil. +// +- (NSString *)parseDoubleQuote +{ + if ([scanner scanString:@"\"" intoString:NULL]) + { + return @"\""; + } + return nil; +} + +// +// parseSeparator +// +// Attempts to parse the separator string from the current scan location. +// +// returns the separator string or nil. +// +- (NSString *)parseSeparator +{ + if ([scanner scanString:separator intoString:NULL]) + { + return separator; + } + return nil; +} + +// +// parseLineSeparator +// +// Attempts to parse newline characters from the current scan location. +// +// returns a string containing one or more newline characters or nil. +// +- (NSString *)parseLineSeparator +{ + NSString *matchedNewlines = nil; + [scanner + scanCharactersFromSet:[NSCharacterSet newlineCharacterSet] + intoString:&matchedNewlines]; + return matchedNewlines; +} + +// +// parseTextData +// +// Attempts to parse text data from the current scan location. +// +// returns a non-zero length string or nil. +// +- (NSString *)parseTextData +{ + NSString *accumulatedData = [NSString string]; + while (YES) + { + NSString *fragment; + if ([scanner scanUpToCharactersFromSet:endTextCharacterSet intoString:&fragment]) + { + accumulatedData = [accumulatedData stringByAppendingString:fragment]; + } + + // + // If the separator is just a single character (common case) then + // we know we've reached the end of parseable text + // + if (separatorIsSingleChar) + { + break; + } + + // + // Otherwise, we need to consider the case where the first character + // of the separator is matched but we don't have the full separator. + // + NSUInteger location = [scanner scanLocation]; + NSString *firstCharOfSeparator; + if ([scanner scanString:[separator substringToIndex:1] intoString:&firstCharOfSeparator]) + { + if ([scanner scanString:[separator substringFromIndex:1] intoString:NULL]) + { + [scanner setScanLocation:location]; + break; + } + + // + // We have the first char of the separator but not the whole + // separator, so just append the char and continue + // + accumulatedData = [accumulatedData stringByAppendingString:firstCharOfSeparator]; + continue; + } + else + { + break; + } + } + + if ([accumulatedData length] > 0) + { + return accumulatedData; + } + + return nil; +} + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabase.h b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabase.h new file mode 100644 index 0000000..843e5ae --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabase.h @@ -0,0 +1,155 @@ +#import +#import "sqlite3.h" +#import "FMResultSet.h" +#import "FMDatabasePool.h" + + +#if ! __has_feature(objc_arc) + #define FMDBAutorelease(__v) ([__v autorelease]); + #define FMDBReturnAutoreleased FMDBAutorelease + + #define FMDBRetain(__v) ([__v retain]); + #define FMDBReturnRetained FMDBRetain + + #define FMDBRelease(__v) ([__v release]); + + #define FMDBDispatchQueueRelease(__v) (dispatch_release(__v)); +#else + // -fobjc-arc + #define FMDBAutorelease(__v) + #define FMDBReturnAutoreleased(__v) (__v) + + #define FMDBRetain(__v) + #define FMDBReturnRetained(__v) (__v) + + #define FMDBRelease(__v) + + #if TARGET_OS_IPHONE + // Compiling for iOS + #if __IPHONE_OS_VERSION_MIN_REQUIRED >= 60000 + // iOS 6.0 or later + #define FMDBDispatchQueueRelease(__v) + #else + // iOS 5.X or earlier + #define FMDBDispatchQueueRelease(__v) (dispatch_release(__v)); + #endif + #else + // Compiling for Mac OS X + #if MAC_OS_X_VERSION_MIN_REQUIRED >= 1080 + // Mac OS X 10.8 or later + #define FMDBDispatchQueueRelease(__v) + #else + // Mac OS X 10.7 or earlier + #define FMDBDispatchQueueRelease(__v) (dispatch_release(__v)); + #endif + #endif +#endif + + +@interface FMDatabase : NSObject { + + sqlite3* _db; + NSString* _databasePath; + BOOL _logsErrors; + BOOL _crashOnErrors; + BOOL _traceExecution; + BOOL _checkedOut; + BOOL _shouldCacheStatements; + BOOL _isExecutingStatement; + BOOL _inTransaction; + int _busyRetryTimeout; + + NSMutableDictionary *_cachedStatements; + NSMutableSet *_openResultSets; + NSMutableSet *_openFunctions; + +} + + +@property (atomic, assign) BOOL traceExecution; +@property (atomic, assign) BOOL checkedOut; +@property (atomic, assign) int busyRetryTimeout; +@property (atomic, assign) BOOL crashOnErrors; +@property (atomic, assign) BOOL logsErrors; +@property (atomic, retain) NSMutableDictionary *cachedStatements; + + ++ (id)databaseWithPath:(NSString*)inPath; +- (id)initWithPath:(NSString*)inPath; + +- (BOOL)open; +#if SQLITE_VERSION_NUMBER >= 3005000 +- (BOOL)openWithFlags:(int)flags; +#endif +- (BOOL)close; +- (BOOL)goodConnection; +- (void)clearCachedStatements; +- (void)closeOpenResultSets; +- (BOOL)hasOpenResultSets; + +// encryption methods. You need to have purchased the sqlite encryption extensions for these to work. +- (BOOL)setKey:(NSString*)key; +- (BOOL)rekey:(NSString*)key; + +- (NSString *)databasePath; + +- (NSString*)lastErrorMessage; + +- (int)lastErrorCode; +- (BOOL)hadError; +- (NSError*)lastError; + +- (sqlite_int64)lastInsertRowId; + +- (sqlite3*)sqliteHandle; + +- (BOOL)update:(NSString*)sql withErrorAndBindings:(NSError**)outErr, ...; +- (BOOL)executeUpdate:(NSString*)sql, ...; +- (BOOL)executeUpdateWithFormat:(NSString *)format, ...; +- (BOOL)executeUpdate:(NSString*)sql withArgumentsInArray:(NSArray *)arguments; +- (BOOL)executeUpdate:(NSString*)sql withParameterDictionary:(NSDictionary *)arguments; + +- (FMResultSet *)executeQuery:(NSString*)sql, ...; +- (FMResultSet *)executeQueryWithFormat:(NSString*)format, ...; +- (FMResultSet *)executeQuery:(NSString *)sql withArgumentsInArray:(NSArray *)arguments; +- (FMResultSet *)executeQuery:(NSString *)sql withParameterDictionary:(NSDictionary *)arguments; + +- (BOOL)rollback; +- (BOOL)commit; +- (BOOL)beginTransaction; +- (BOOL)beginDeferredTransaction; +- (BOOL)inTransaction; +- (BOOL)shouldCacheStatements; +- (void)setShouldCacheStatements:(BOOL)value; + +#if SQLITE_VERSION_NUMBER >= 3007000 +- (BOOL)startSavePointWithName:(NSString*)name error:(NSError**)outErr; +- (BOOL)releaseSavePointWithName:(NSString*)name error:(NSError**)outErr; +- (BOOL)rollbackToSavePointWithName:(NSString*)name error:(NSError**)outErr; +- (NSError*)inSavePoint:(void (^)(BOOL *rollback))block; +#endif + ++ (BOOL)isSQLiteThreadSafe; ++ (NSString*)sqliteLibVersion; + +- (int)changes; + +- (void)makeFunctionNamed:(NSString*)name maximumArguments:(int)count withBlock:(void (^)(sqlite3_context *context, int argc, sqlite3_value **argv))block; + +@end + +@interface FMStatement : NSObject { + sqlite3_stmt *_statement; + NSString *_query; + long _useCount; +} + +@property (atomic, assign) long useCount; +@property (atomic, retain) NSString *query; +@property (atomic, assign) sqlite3_stmt *statement; + +- (void)close; +- (void)reset; + +@end + diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabase.m b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabase.m new file mode 100644 index 0000000..d4841af --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabase.m @@ -0,0 +1,1148 @@ +#import "FMDatabase.h" +#import "unistd.h" +#import + +@interface FMDatabase () + +- (FMResultSet *)executeQuery:(NSString *)sql withArgumentsInArray:(NSArray*)arrayArgs orDictionary:(NSDictionary *)dictionaryArgs orVAList:(va_list)args; +- (BOOL)executeUpdate:(NSString*)sql error:(NSError**)outErr withArgumentsInArray:(NSArray*)arrayArgs orDictionary:(NSDictionary *)dictionaryArgs orVAList:(va_list)args; +@end + +@implementation FMDatabase +@synthesize cachedStatements=_cachedStatements; +@synthesize logsErrors=_logsErrors; +@synthesize crashOnErrors=_crashOnErrors; +@synthesize busyRetryTimeout=_busyRetryTimeout; +@synthesize checkedOut=_checkedOut; +@synthesize traceExecution=_traceExecution; + ++ (id)databaseWithPath:(NSString*)aPath { + return FMDBReturnAutoreleased([[self alloc] initWithPath:aPath]); +} + ++ (NSString*)sqliteLibVersion { + return [NSString stringWithFormat:@"%s", sqlite3_libversion()]; +} + ++ (BOOL)isSQLiteThreadSafe { + // make sure to read the sqlite headers on this guy! + return sqlite3_threadsafe() != 0; +} + +- (id)initWithPath:(NSString*)aPath { + + assert(sqlite3_threadsafe()); // whoa there big boy- gotta make sure sqlite it happy with what we're going to do. + + self = [super init]; + + if (self) { + _databasePath = [aPath copy]; + _openResultSets = [[NSMutableSet alloc] init]; + _db = 0x00; + _logsErrors = 0x00; + _crashOnErrors = 0x00; + _busyRetryTimeout = 0x00; + } + + return self; +} + +- (void)finalize { + [self close]; + [super finalize]; +} + +- (void)dealloc { + [self close]; + FMDBRelease(_openResultSets); + FMDBRelease(_cachedStatements); + FMDBRelease(_databasePath); + FMDBRelease(_openFunctions); + +#if ! __has_feature(objc_arc) + [super dealloc]; +#endif +} + +- (NSString *)databasePath { + return _databasePath; +} + +- (sqlite3*)sqliteHandle { + return _db; +} + +- (BOOL)open { + if (_db) { + return YES; + } + + int err = sqlite3_open((_databasePath ? [_databasePath fileSystemRepresentation] : ":memory:"), &_db ); + if(err != SQLITE_OK) { + NSLog(@"error opening!: %d", err); + return NO; + } + + return YES; +} + +#if SQLITE_VERSION_NUMBER >= 3005000 +- (BOOL)openWithFlags:(int)flags { + int err = sqlite3_open_v2((_databasePath ? [_databasePath fileSystemRepresentation] : ":memory:"), &_db, flags, NULL /* Name of VFS module to use */); + if(err != SQLITE_OK) { + NSLog(@"error opening!: %d", err); + return NO; + } + return YES; +} +#endif + + +- (BOOL)close { + + [self clearCachedStatements]; + [self closeOpenResultSets]; + + if (!_db) { + return YES; + } + + int rc; + BOOL retry; + int numberOfRetries = 0; + BOOL triedFinalizingOpenStatements = NO; + + do { + retry = NO; + rc = sqlite3_close(_db); + + if (SQLITE_BUSY == rc || SQLITE_LOCKED == rc) { + + retry = YES; + usleep(20); + + if (_busyRetryTimeout && (numberOfRetries++ > _busyRetryTimeout)) { + NSLog(@"%s:%d", __FUNCTION__, __LINE__); + NSLog(@"Database busy, unable to close"); + return NO; + } + + if (!triedFinalizingOpenStatements) { + triedFinalizingOpenStatements = YES; + sqlite3_stmt *pStmt; + while ((pStmt = sqlite3_next_stmt(_db, 0x00)) !=0) { + NSLog(@"Closing leaked statement"); + sqlite3_finalize(pStmt); + } + } + } + else if (SQLITE_OK != rc) { + NSLog(@"error closing!: %d", rc); + } + } + while (retry); + + _db = nil; + return YES; +} + +- (void)clearCachedStatements { + + for (FMStatement *cachedStmt in [_cachedStatements objectEnumerator]) { + [cachedStmt close]; + } + + [_cachedStatements removeAllObjects]; +} + +- (BOOL)hasOpenResultSets { + return [_openResultSets count] > 0; +} + +- (void)closeOpenResultSets { + + //Copy the set so we don't get mutation errors + NSMutableSet *openSetCopy = FMDBReturnAutoreleased([_openResultSets copy]); + for (NSValue *rsInWrappedInATastyValueMeal in openSetCopy) { + FMResultSet *rs = (FMResultSet *)[rsInWrappedInATastyValueMeal pointerValue]; + + [rs setParentDB:nil]; + [rs close]; + + [_openResultSets removeObject:rsInWrappedInATastyValueMeal]; + } +} + +- (void)resultSetDidClose:(FMResultSet *)resultSet { + NSValue *setValue = [NSValue valueWithNonretainedObject:resultSet]; + + [_openResultSets removeObject:setValue]; +} + +- (FMStatement*)cachedStatementForQuery:(NSString*)query { + return [_cachedStatements objectForKey:query]; +} + +- (void)setCachedStatement:(FMStatement*)statement forQuery:(NSString*)query { + + query = [query copy]; // in case we got handed in a mutable string... + + [statement setQuery:query]; + + [_cachedStatements setObject:statement forKey:query]; + + FMDBRelease(query); +} + + +- (BOOL)rekey:(NSString*)key { +#ifdef SQLITE_HAS_CODEC + if (!key) { + return NO; + } + + int rc = sqlite3_rekey(_db, [key UTF8String], (int)strlen([key UTF8String])); + + if (rc != SQLITE_OK) { + NSLog(@"error on rekey: %d", rc); + NSLog(@"%@", [self lastErrorMessage]); + } + + return (rc == SQLITE_OK); +#else + return NO; +#endif +} + +- (BOOL)setKey:(NSString*)key { +#ifdef SQLITE_HAS_CODEC + if (!key) { + return NO; + } + + int rc = sqlite3_key(_db, [key UTF8String], (int)strlen([key UTF8String])); + + return (rc == SQLITE_OK); +#else + return NO; +#endif +} + +- (BOOL)goodConnection { + + if (!_db) { + return NO; + } + + FMResultSet *rs = [self executeQuery:@"select name from sqlite_master where type='table'"]; + + if (rs) { + [rs close]; + return YES; + } + + return NO; +} + +- (void)warnInUse { + NSLog(@"The FMDatabase %@ is currently in use.", self); + +#ifndef NS_BLOCK_ASSERTIONS + if (_crashOnErrors) { + abort(); + NSAssert1(false, @"The FMDatabase %@ is currently in use.", self); + } +#endif +} + +- (BOOL)databaseExists { + + if (!_db) { + + NSLog(@"The FMDatabase %@ is not open.", self); + + #ifndef NS_BLOCK_ASSERTIONS + if (_crashOnErrors) { + abort(); + NSAssert1(false, @"The FMDatabase %@ is not open.", self); + } + #endif + + return NO; + } + + return YES; +} + +- (NSString*)lastErrorMessage { + return [NSString stringWithUTF8String:sqlite3_errmsg(_db)]; +} + +- (BOOL)hadError { + int lastErrCode = [self lastErrorCode]; + + return (lastErrCode > SQLITE_OK && lastErrCode < SQLITE_ROW); +} + +- (int)lastErrorCode { + return sqlite3_errcode(_db); +} + + +- (NSError*)errorWithMessage:(NSString*)message { + NSDictionary* errorMessage = [NSDictionary dictionaryWithObject:message forKey:NSLocalizedDescriptionKey]; + + return [NSError errorWithDomain:@"FMDatabase" code:sqlite3_errcode(_db) userInfo:errorMessage]; +} + +- (NSError*)lastError { + return [self errorWithMessage:[self lastErrorMessage]]; +} + +- (sqlite_int64)lastInsertRowId { + + if (_isExecutingStatement) { + [self warnInUse]; + return NO; + } + + _isExecutingStatement = YES; + + sqlite_int64 ret = sqlite3_last_insert_rowid(_db); + + _isExecutingStatement = NO; + + return ret; +} + +- (int)changes { + if (_isExecutingStatement) { + [self warnInUse]; + return 0; + } + + _isExecutingStatement = YES; + + int ret = sqlite3_changes(_db); + + _isExecutingStatement = NO; + + return ret; +} + +- (void)bindObject:(id)obj toColumn:(int)idx inStatement:(sqlite3_stmt*)pStmt { + + if ((!obj) || ((NSNull *)obj == [NSNull null])) { + sqlite3_bind_null(pStmt, idx); + } + + // FIXME - someday check the return codes on these binds. + else if ([obj isKindOfClass:[NSData class]]) { + const void *bytes = [obj bytes]; + if (!bytes) { + // it's an empty NSData object, aka [NSData data]. + // Don't pass a NULL pointer, or sqlite will bind a SQL null instead of a blob. + bytes = ""; + } + sqlite3_bind_blob(pStmt, idx, bytes, (int)[obj length], SQLITE_STATIC); + } + else if ([obj isKindOfClass:[NSDate class]]) { + sqlite3_bind_double(pStmt, idx, [obj timeIntervalSince1970]); + } + else if ([obj isKindOfClass:[NSNumber class]]) { + + if (strcmp([obj objCType], @encode(BOOL)) == 0) { + sqlite3_bind_int(pStmt, idx, ([obj boolValue] ? 1 : 0)); + } + else if (strcmp([obj objCType], @encode(int)) == 0) { + sqlite3_bind_int64(pStmt, idx, [obj longValue]); + } + else if (strcmp([obj objCType], @encode(long)) == 0) { + sqlite3_bind_int64(pStmt, idx, [obj longValue]); + } + else if (strcmp([obj objCType], @encode(long long)) == 0) { + sqlite3_bind_int64(pStmt, idx, [obj longLongValue]); + } + else if (strcmp([obj objCType], @encode(unsigned long long)) == 0) { + sqlite3_bind_int64(pStmt, idx, (long long)[obj unsignedLongLongValue]); + } + else if (strcmp([obj objCType], @encode(float)) == 0) { + sqlite3_bind_double(pStmt, idx, [obj floatValue]); + } + else if (strcmp([obj objCType], @encode(double)) == 0) { + sqlite3_bind_double(pStmt, idx, [obj doubleValue]); + } + else { + sqlite3_bind_text(pStmt, idx, [[obj description] UTF8String], -1, SQLITE_STATIC); + } + } + else { + sqlite3_bind_text(pStmt, idx, [[obj description] UTF8String], -1, SQLITE_STATIC); + } +} + +- (void)extractSQL:(NSString *)sql argumentsList:(va_list)args intoString:(NSMutableString *)cleanedSQL arguments:(NSMutableArray *)arguments { + + NSUInteger length = [sql length]; + unichar last = '\0'; + for (NSUInteger i = 0; i < length; ++i) { + id arg = nil; + unichar current = [sql characterAtIndex:i]; + unichar add = current; + if (last == '%') { + switch (current) { + case '@': + arg = va_arg(args, id); + break; + case 'c': + // warning: second argument to 'va_arg' is of promotable type 'char'; this va_arg has undefined behavior because arguments will be promoted to 'int' + arg = [NSString stringWithFormat:@"%c", va_arg(args, int)]; + break; + case 's': + arg = [NSString stringWithUTF8String:va_arg(args, char*)]; + break; + case 'd': + case 'D': + case 'i': + arg = [NSNumber numberWithInt:va_arg(args, int)]; + break; + case 'u': + case 'U': + arg = [NSNumber numberWithUnsignedInt:va_arg(args, unsigned int)]; + break; + case 'h': + i++; + if (i < length && [sql characterAtIndex:i] == 'i') { + // warning: second argument to 'va_arg' is of promotable type 'short'; this va_arg has undefined behavior because arguments will be promoted to 'int' + arg = [NSNumber numberWithShort:(short)(va_arg(args, int))]; + } + else if (i < length && [sql characterAtIndex:i] == 'u') { + // warning: second argument to 'va_arg' is of promotable type 'unsigned short'; this va_arg has undefined behavior because arguments will be promoted to 'int' + arg = [NSNumber numberWithUnsignedShort:(unsigned short)(va_arg(args, uint))]; + } + else { + i--; + } + break; + case 'q': + i++; + if (i < length && [sql characterAtIndex:i] == 'i') { + arg = [NSNumber numberWithLongLong:va_arg(args, long long)]; + } + else if (i < length && [sql characterAtIndex:i] == 'u') { + arg = [NSNumber numberWithUnsignedLongLong:va_arg(args, unsigned long long)]; + } + else { + i--; + } + break; + case 'f': + arg = [NSNumber numberWithDouble:va_arg(args, double)]; + break; + case 'g': + // warning: second argument to 'va_arg' is of promotable type 'float'; this va_arg has undefined behavior because arguments will be promoted to 'double' + arg = [NSNumber numberWithFloat:(float)(va_arg(args, double))]; + break; + case 'l': + i++; + if (i < length) { + unichar next = [sql characterAtIndex:i]; + if (next == 'l') { + i++; + if (i < length && [sql characterAtIndex:i] == 'd') { + //%lld + arg = [NSNumber numberWithLongLong:va_arg(args, long long)]; + } + else if (i < length && [sql characterAtIndex:i] == 'u') { + //%llu + arg = [NSNumber numberWithUnsignedLongLong:va_arg(args, unsigned long long)]; + } + else { + i--; + } + } + else if (next == 'd') { + //%ld + arg = [NSNumber numberWithLong:va_arg(args, long)]; + } + else if (next == 'u') { + //%lu + arg = [NSNumber numberWithUnsignedLong:va_arg(args, unsigned long)]; + } + else { + i--; + } + } + else { + i--; + } + break; + default: + // something else that we can't interpret. just pass it on through like normal + break; + } + } + else if (current == '%') { + // percent sign; skip this character + add = '\0'; + } + + if (arg != nil) { + [cleanedSQL appendString:@"?"]; + [arguments addObject:arg]; + } + else if (add != '\0') { + [cleanedSQL appendFormat:@"%C", add]; + } + last = current; + } +} + +- (FMResultSet *)executeQuery:(NSString *)sql withParameterDictionary:(NSDictionary *)arguments { + return [self executeQuery:sql withArgumentsInArray:nil orDictionary:arguments orVAList:nil]; +} + +- (FMResultSet *)executeQuery:(NSString *)sql withArgumentsInArray:(NSArray*)arrayArgs orDictionary:(NSDictionary *)dictionaryArgs orVAList:(va_list)args { + + if (![self databaseExists]) { + return 0x00; + } + + if (_isExecutingStatement) { + [self warnInUse]; + return 0x00; + } + + _isExecutingStatement = YES; + + int rc = 0x00; + sqlite3_stmt *pStmt = 0x00; + FMStatement *statement = 0x00; + FMResultSet *rs = 0x00; + + if (_traceExecution && sql) { + NSLog(@"%@ executeQuery: %@", self, sql); + } + + if (_shouldCacheStatements) { + statement = [self cachedStatementForQuery:sql]; + pStmt = statement ? [statement statement] : 0x00; + [statement reset]; + } + + int numberOfRetries = 0; + BOOL retry = NO; + + if (!pStmt) { + do { + retry = NO; + rc = sqlite3_prepare_v2(_db, [sql UTF8String], -1, &pStmt, 0); + + if (SQLITE_BUSY == rc || SQLITE_LOCKED == rc) { + retry = YES; + usleep(20); + + if (_busyRetryTimeout && (numberOfRetries++ > _busyRetryTimeout)) { + NSLog(@"%s:%d Database busy (%@)", __FUNCTION__, __LINE__, [self databasePath]); + NSLog(@"Database busy"); + sqlite3_finalize(pStmt); + _isExecutingStatement = NO; + return nil; + } + } + else if (SQLITE_OK != rc) { + + if (_logsErrors) { + NSLog(@"DB Error: %d \"%@\"", [self lastErrorCode], [self lastErrorMessage]); + NSLog(@"DB Query: %@", sql); + NSLog(@"DB Path: %@", _databasePath); +#ifndef NS_BLOCK_ASSERTIONS + if (_crashOnErrors) { + abort(); + NSAssert2(false, @"DB Error: %d \"%@\"", [self lastErrorCode], [self lastErrorMessage]); + } +#endif + } + + sqlite3_finalize(pStmt); + _isExecutingStatement = NO; + return nil; + } + } + while (retry); + } + + id obj; + int idx = 0; + int queryCount = sqlite3_bind_parameter_count(pStmt); // pointed out by Dominic Yu (thanks!) + + // If dictionaryArgs is passed in, that means we are using sqlite's named parameter support + if (dictionaryArgs) { + + for (NSString *dictionaryKey in [dictionaryArgs allKeys]) { + + // Prefix the key with a colon. + NSString *parameterName = [[NSString alloc] initWithFormat:@":%@", dictionaryKey]; + + // Get the index for the parameter name. + int namedIdx = sqlite3_bind_parameter_index(pStmt, [parameterName UTF8String]); + + FMDBRelease(parameterName); + + if (namedIdx > 0) { + // Standard binding from here. + [self bindObject:[dictionaryArgs objectForKey:dictionaryKey] toColumn:namedIdx inStatement:pStmt]; + // increment the binding count, so our check below works out + idx++; + } + else { + NSLog(@"Could not find index for %@", dictionaryKey); + } + } + } + else { + + while (idx < queryCount) { + + if (arrayArgs) { + obj = [arrayArgs objectAtIndex:(NSUInteger)idx]; + } + else { + obj = va_arg(args, id); + } + + if (_traceExecution) { + NSLog(@"obj: %@", obj); + } + + idx++; + + [self bindObject:obj toColumn:idx inStatement:pStmt]; + } + } + + if (idx != queryCount) { + NSLog(@"Error: the bind count is not correct for the # of variables (executeQuery)"); + sqlite3_finalize(pStmt); + _isExecutingStatement = NO; + return nil; + } + + FMDBRetain(statement); // to balance the release below + + if (!statement) { + statement = [[FMStatement alloc] init]; + [statement setStatement:pStmt]; + + if (_shouldCacheStatements) { + [self setCachedStatement:statement forQuery:sql]; + } + } + + // the statement gets closed in rs's dealloc or [rs close]; + rs = [FMResultSet resultSetWithStatement:statement usingParentDatabase:self]; + [rs setQuery:sql]; + + NSValue *openResultSet = [NSValue valueWithNonretainedObject:rs]; + [_openResultSets addObject:openResultSet]; + + [statement setUseCount:[statement useCount] + 1]; + + FMDBRelease(statement); + + _isExecutingStatement = NO; + + return rs; +} + +- (FMResultSet *)executeQuery:(NSString*)sql, ... { + va_list args; + va_start(args, sql); + + id result = [self executeQuery:sql withArgumentsInArray:nil orDictionary:nil orVAList:args]; + + va_end(args); + return result; +} + +- (FMResultSet *)executeQueryWithFormat:(NSString*)format, ... { + va_list args; + va_start(args, format); + + NSMutableString *sql = [NSMutableString stringWithCapacity:[format length]]; + NSMutableArray *arguments = [NSMutableArray array]; + [self extractSQL:format argumentsList:args intoString:sql arguments:arguments]; + + va_end(args); + + return [self executeQuery:sql withArgumentsInArray:arguments]; +} + +- (FMResultSet *)executeQuery:(NSString *)sql withArgumentsInArray:(NSArray *)arguments { + return [self executeQuery:sql withArgumentsInArray:arguments orDictionary:nil orVAList:nil]; +} + +- (BOOL)executeUpdate:(NSString*)sql error:(NSError**)outErr withArgumentsInArray:(NSArray*)arrayArgs orDictionary:(NSDictionary *)dictionaryArgs orVAList:(va_list)args { + + if (![self databaseExists]) { + return NO; + } + + if (_isExecutingStatement) { + [self warnInUse]; + return NO; + } + + _isExecutingStatement = YES; + + int rc = 0x00; + sqlite3_stmt *pStmt = 0x00; + FMStatement *cachedStmt = 0x00; + + if (_traceExecution && sql) { + NSLog(@"%@ executeUpdate: %@", self, sql); + } + + if (_shouldCacheStatements) { + cachedStmt = [self cachedStatementForQuery:sql]; + pStmt = cachedStmt ? [cachedStmt statement] : 0x00; + [cachedStmt reset]; + } + + int numberOfRetries = 0; + BOOL retry = NO; + + if (!pStmt) { + + do { + retry = NO; + rc = sqlite3_prepare_v2(_db, [sql UTF8String], -1, &pStmt, 0); + if (SQLITE_BUSY == rc || SQLITE_LOCKED == rc) { + retry = YES; + usleep(20); + + if (_busyRetryTimeout && (numberOfRetries++ > _busyRetryTimeout)) { + NSLog(@"%s:%d Database busy (%@)", __FUNCTION__, __LINE__, [self databasePath]); + NSLog(@"Database busy"); + sqlite3_finalize(pStmt); + _isExecutingStatement = NO; + return NO; + } + } + else if (SQLITE_OK != rc) { + + if (_logsErrors) { + NSLog(@"DB Error: %d \"%@\"", [self lastErrorCode], [self lastErrorMessage]); + NSLog(@"DB Query: %@", sql); + NSLog(@"DB Path: %@", _databasePath); +#ifndef NS_BLOCK_ASSERTIONS + if (_crashOnErrors) { + abort(); + NSAssert2(false, @"DB Error: %d \"%@\"", [self lastErrorCode], [self lastErrorMessage]); + } +#endif + } + + sqlite3_finalize(pStmt); + + if (outErr) { + *outErr = [self errorWithMessage:[NSString stringWithUTF8String:sqlite3_errmsg(_db)]]; + } + + _isExecutingStatement = NO; + return NO; + } + } + while (retry); + } + + id obj; + int idx = 0; + int queryCount = sqlite3_bind_parameter_count(pStmt); + + // If dictionaryArgs is passed in, that means we are using sqlite's named parameter support + if (dictionaryArgs) { + + for (NSString *dictionaryKey in [dictionaryArgs allKeys]) { + + // Prefix the key with a colon. + NSString *parameterName = [[NSString alloc] initWithFormat:@":%@", dictionaryKey]; + + // Get the index for the parameter name. + int namedIdx = sqlite3_bind_parameter_index(pStmt, [parameterName UTF8String]); + + FMDBRelease(parameterName); + + if (namedIdx > 0) { + // Standard binding from here. + [self bindObject:[dictionaryArgs objectForKey:dictionaryKey] toColumn:namedIdx inStatement:pStmt]; + + // increment the binding count, so our check below works out + idx++; + } + else { + NSLog(@"Could not find index for %@", dictionaryKey); + } + } + } + else { + + while (idx < queryCount) { + + if (arrayArgs) { + obj = [arrayArgs objectAtIndex:(NSUInteger)idx]; + } + else { + obj = va_arg(args, id); + } + + if (_traceExecution) { + NSLog(@"obj: %@", obj); + } + + idx++; + + [self bindObject:obj toColumn:idx inStatement:pStmt]; + } + } + + + if (idx != queryCount) { + NSLog(@"Error: the bind count (%d) is not correct for the # of variables in the query (%d) (%@) (executeUpdate)", idx, queryCount, sql); + sqlite3_finalize(pStmt); + _isExecutingStatement = NO; + return NO; + } + + /* Call sqlite3_step() to run the virtual machine. Since the SQL being + ** executed is not a SELECT statement, we assume no data will be returned. + */ + numberOfRetries = 0; + + do { + rc = sqlite3_step(pStmt); + retry = NO; + + if (SQLITE_BUSY == rc || SQLITE_LOCKED == rc) { + // this will happen if the db is locked, like if we are doing an update or insert. + // in that case, retry the step... and maybe wait just 10 milliseconds. + retry = YES; + if (SQLITE_LOCKED == rc) { + rc = sqlite3_reset(pStmt); + if (rc != SQLITE_LOCKED) { + NSLog(@"Unexpected result from sqlite3_reset (%d) eu", rc); + } + } + usleep(20); + + if (_busyRetryTimeout && (numberOfRetries++ > _busyRetryTimeout)) { + NSLog(@"%s:%d Database busy (%@)", __FUNCTION__, __LINE__, [self databasePath]); + NSLog(@"Database busy"); + retry = NO; + } + } + else if (SQLITE_DONE == rc) { + // all is well, let's return. + } + else if (SQLITE_ERROR == rc) { + NSLog(@"Error calling sqlite3_step (%d: %s) SQLITE_ERROR", rc, sqlite3_errmsg(_db)); + NSLog(@"DB Query: %@", sql); + } + else if (SQLITE_MISUSE == rc) { + // uh oh. + NSLog(@"Error calling sqlite3_step (%d: %s) SQLITE_MISUSE", rc, sqlite3_errmsg(_db)); + NSLog(@"DB Query: %@", sql); + } + else { + // wtf? + NSLog(@"Unknown error calling sqlite3_step (%d: %s) eu", rc, sqlite3_errmsg(_db)); + NSLog(@"DB Query: %@", sql); + } + + } while (retry); + + if (rc == SQLITE_ROW) { + NSAssert1(NO, @"A executeUpdate is being called with a query string '%@'", sql); + } + + if (_shouldCacheStatements && !cachedStmt) { + cachedStmt = [[FMStatement alloc] init]; + + [cachedStmt setStatement:pStmt]; + + [self setCachedStatement:cachedStmt forQuery:sql]; + + FMDBRelease(cachedStmt); + } + + int closeErrorCode; + + if (cachedStmt) { + [cachedStmt setUseCount:[cachedStmt useCount] + 1]; + closeErrorCode = sqlite3_reset(pStmt); + } + else { + /* Finalize the virtual machine. This releases all memory and other + ** resources allocated by the sqlite3_prepare() call above. + */ + closeErrorCode = sqlite3_finalize(pStmt); + } + + if (closeErrorCode != SQLITE_OK) { + NSLog(@"Unknown error finalizing or resetting statement (%d: %s)", closeErrorCode, sqlite3_errmsg(_db)); + NSLog(@"DB Query: %@", sql); + } + + _isExecutingStatement = NO; + return (rc == SQLITE_DONE || rc == SQLITE_OK); +} + + +- (BOOL)executeUpdate:(NSString*)sql, ... { + va_list args; + va_start(args, sql); + + BOOL result = [self executeUpdate:sql error:nil withArgumentsInArray:nil orDictionary:nil orVAList:args]; + + va_end(args); + return result; +} + +- (BOOL)executeUpdate:(NSString*)sql withArgumentsInArray:(NSArray *)arguments { + return [self executeUpdate:sql error:nil withArgumentsInArray:arguments orDictionary:nil orVAList:nil]; +} + +- (BOOL)executeUpdate:(NSString*)sql withParameterDictionary:(NSDictionary *)arguments { + return [self executeUpdate:sql error:nil withArgumentsInArray:nil orDictionary:arguments orVAList:nil]; +} + +- (BOOL)executeUpdateWithFormat:(NSString*)format, ... { + va_list args; + va_start(args, format); + + NSMutableString *sql = [NSMutableString stringWithCapacity:[format length]]; + NSMutableArray *arguments = [NSMutableArray array]; + + [self extractSQL:format argumentsList:args intoString:sql arguments:arguments]; + + va_end(args); + + return [self executeUpdate:sql withArgumentsInArray:arguments]; +} + +- (BOOL)update:(NSString*)sql withErrorAndBindings:(NSError**)outErr, ... { + va_list args; + va_start(args, outErr); + + BOOL result = [self executeUpdate:sql error:outErr withArgumentsInArray:nil orDictionary:nil orVAList:args]; + + va_end(args); + return result; +} + +- (BOOL)rollback { + BOOL b = [self executeUpdate:@"rollback transaction"]; + + if (b) { + _inTransaction = NO; + } + + return b; +} + +- (BOOL)commit { + BOOL b = [self executeUpdate:@"commit transaction"]; + + if (b) { + _inTransaction = NO; + } + + return b; +} + +- (BOOL)beginDeferredTransaction { + + BOOL b = [self executeUpdate:@"begin deferred transaction"]; + if (b) { + _inTransaction = YES; + } + + return b; +} + +- (BOOL)beginTransaction { + + BOOL b = [self executeUpdate:@"begin exclusive transaction"]; + if (b) { + _inTransaction = YES; + } + + return b; +} + +- (BOOL)inTransaction { + return _inTransaction; +} + +#if SQLITE_VERSION_NUMBER >= 3007000 + +- (BOOL)startSavePointWithName:(NSString*)name error:(NSError**)outErr { + + // FIXME: make sure the savepoint name doesn't have a ' in it. + + NSParameterAssert(name); + + if (![self executeUpdate:[NSString stringWithFormat:@"savepoint '%@';", name]]) { + + if (*outErr) { + *outErr = [self lastError]; + } + + return NO; + } + + return YES; +} + +- (BOOL)releaseSavePointWithName:(NSString*)name error:(NSError**)outErr { + + NSParameterAssert(name); + + BOOL worked = [self executeUpdate:[NSString stringWithFormat:@"release savepoint '%@';", name]]; + + if (!worked && *outErr) { + *outErr = [self lastError]; + } + + return worked; +} + +- (BOOL)rollbackToSavePointWithName:(NSString*)name error:(NSError**)outErr { + + NSParameterAssert(name); + + BOOL worked = [self executeUpdate:[NSString stringWithFormat:@"rollback transaction to savepoint '%@';", name]]; + + if (!worked && *outErr) { + *outErr = [self lastError]; + } + + return worked; +} + +- (NSError*)inSavePoint:(void (^)(BOOL *rollback))block { + static unsigned long savePointIdx = 0; + + NSString *name = [NSString stringWithFormat:@"dbSavePoint%ld", savePointIdx++]; + + BOOL shouldRollback = NO; + + NSError *err = 0x00; + + if (![self startSavePointWithName:name error:&err]) { + return err; + } + + block(&shouldRollback); + + if (shouldRollback) { + [self rollbackToSavePointWithName:name error:&err]; + } + else { + [self releaseSavePointWithName:name error:&err]; + } + + return err; +} + +#endif + + +- (BOOL)shouldCacheStatements { + return _shouldCacheStatements; +} + +- (void)setShouldCacheStatements:(BOOL)value { + + _shouldCacheStatements = value; + + if (_shouldCacheStatements && !_cachedStatements) { + [self setCachedStatements:[NSMutableDictionary dictionary]]; + } + + if (!_shouldCacheStatements) { + [self setCachedStatements:nil]; + } +} + +void FMDBBlockSQLiteCallBackFunction(sqlite3_context *context, int argc, sqlite3_value **argv); +void FMDBBlockSQLiteCallBackFunction(sqlite3_context *context, int argc, sqlite3_value **argv) { +#if ! __has_feature(objc_arc) + void (^block)(sqlite3_context *context, int argc, sqlite3_value **argv) = (id)sqlite3_user_data(context); +#else + void (^block)(sqlite3_context *context, int argc, sqlite3_value **argv) = (__bridge id)sqlite3_user_data(context); +#endif + block(context, argc, argv); +} + + +- (void)makeFunctionNamed:(NSString*)name maximumArguments:(int)count withBlock:(void (^)(sqlite3_context *context, int argc, sqlite3_value **argv))block { + + if (!_openFunctions) { + _openFunctions = [NSMutableSet new]; + } + + id b = FMDBReturnAutoreleased([block copy]); + + [_openFunctions addObject:b]; + + /* I tried adding custom functions to release the block when the connection is destroyed- but they seemed to never be called, so we use _openFunctions to store the values instead. */ +#if ! __has_feature(objc_arc) + sqlite3_create_function([self sqliteHandle], [name UTF8String], count, SQLITE_UTF8, (void*)b, &FMDBBlockSQLiteCallBackFunction, 0x00, 0x00); +#else + sqlite3_create_function([self sqliteHandle], [name UTF8String], count, SQLITE_UTF8, (__bridge void*)b, &FMDBBlockSQLiteCallBackFunction, 0x00, 0x00); +#endif +} + +@end + + + +@implementation FMStatement +@synthesize statement=_statement; +@synthesize query=_query; +@synthesize useCount=_useCount; + +- (void)finalize { + [self close]; + [super finalize]; +} + +- (void)dealloc { + [self close]; + FMDBRelease(_query); +#if ! __has_feature(objc_arc) + [super dealloc]; +#endif +} + +- (void)close { + if (_statement) { + sqlite3_finalize(_statement); + _statement = 0x00; + } +} + +- (void)reset { + if (_statement) { + sqlite3_reset(_statement); + } +} + +- (NSString*)description { + return [NSString stringWithFormat:@"%@ %ld hit(s) for query %@", [super description], _useCount, _query]; +} + + +@end + diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseAdditions.h b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseAdditions.h new file mode 100644 index 0000000..3b5264f --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseAdditions.h @@ -0,0 +1,37 @@ +// +// FMDatabaseAdditions.h +// fmkit +// +// Created by August Mueller on 10/30/05. +// Copyright 2005 Flying Meat Inc.. All rights reserved. +// + +#import +@interface FMDatabase (FMDatabaseAdditions) + + +- (int)intForQuery:(NSString*)objs, ...; +- (long)longForQuery:(NSString*)objs, ...; +- (BOOL)boolForQuery:(NSString*)objs, ...; +- (double)doubleForQuery:(NSString*)objs, ...; +- (NSString*)stringForQuery:(NSString*)objs, ...; +- (NSData*)dataForQuery:(NSString*)objs, ...; +- (NSDate*)dateForQuery:(NSString*)objs, ...; + +// Notice that there's no dataNoCopyForQuery:. +// That would be a bad idea, because we close out the result set, and then what +// happens to the data that we just didn't copy? Who knows, not I. + + +- (BOOL)tableExists:(NSString*)tableName; +- (FMResultSet*)getSchema; +- (FMResultSet*)getTableSchema:(NSString*)tableName; + +- (BOOL)columnExists:(NSString*)columnName inTableWithName:(NSString*)tableName; + +- (BOOL)validateSQL:(NSString*)sql error:(NSError**)error; + +// deprecated - use columnExists:inTableWithName: instead. +- (BOOL)columnExists:(NSString*)tableName columnName:(NSString*)columnName __attribute__ ((deprecated)); + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseAdditions.m b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseAdditions.m new file mode 100644 index 0000000..60c94ac --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseAdditions.m @@ -0,0 +1,163 @@ +// +// FMDatabaseAdditions.m +// fmkit +// +// Created by August Mueller on 10/30/05. +// Copyright 2005 Flying Meat Inc.. All rights reserved. +// + +#import "FMDatabase.h" +#import "FMDatabaseAdditions.h" + +@interface FMDatabase (PrivateStuff) +- (FMResultSet *)executeQuery:(NSString *)sql withArgumentsInArray:(NSArray*)arrayArgs orDictionary:(NSDictionary *)dictionaryArgs orVAList:(va_list)args; +@end + +@implementation FMDatabase (FMDatabaseAdditions) + +#define RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(type, sel) \ +va_list args; \ +va_start(args, query); \ +FMResultSet *resultSet = [self executeQuery:query withArgumentsInArray:0x00 orDictionary:0x00 orVAList:args]; \ +va_end(args); \ +if (![resultSet next]) { return (type)0; } \ +type ret = [resultSet sel:0]; \ +[resultSet close]; \ +[resultSet setParentDB:nil]; \ +return ret; + + +- (NSString*)stringForQuery:(NSString*)query, ... { + RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(NSString *, stringForColumnIndex); +} + +- (int)intForQuery:(NSString*)query, ... { + RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(int, intForColumnIndex); +} + +- (long)longForQuery:(NSString*)query, ... { + RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(long, longForColumnIndex); +} + +- (BOOL)boolForQuery:(NSString*)query, ... { + RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(BOOL, boolForColumnIndex); +} + +- (double)doubleForQuery:(NSString*)query, ... { + RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(double, doubleForColumnIndex); +} + +- (NSData*)dataForQuery:(NSString*)query, ... { + RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(NSData *, dataForColumnIndex); +} + +- (NSDate*)dateForQuery:(NSString*)query, ... { + RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(NSDate *, dateForColumnIndex); +} + + +- (BOOL)tableExists:(NSString*)tableName { + + tableName = [tableName lowercaseString]; + + FMResultSet *rs = [self executeQuery:@"select [sql] from sqlite_master where [type] = 'table' and lower(name) = ?", tableName]; + + //if at least one next exists, table exists + BOOL returnBool = [rs next]; + + //close and free object + [rs close]; + + return returnBool; +} + +/* + get table with list of tables: result colums: type[STRING], name[STRING],tbl_name[STRING],rootpage[INTEGER],sql[STRING] + check if table exist in database (patch from OZLB) +*/ +- (FMResultSet*)getSchema { + + //result colums: type[STRING], name[STRING],tbl_name[STRING],rootpage[INTEGER],sql[STRING] + FMResultSet *rs = [self executeQuery:@"SELECT type, name, tbl_name, rootpage, sql FROM (SELECT * FROM sqlite_master UNION ALL SELECT * FROM sqlite_temp_master) WHERE type != 'meta' AND name NOT LIKE 'sqlite_%' ORDER BY tbl_name, type DESC, name"]; + + return rs; +} + +/* + get table schema: result colums: cid[INTEGER], name,type [STRING], notnull[INTEGER], dflt_value[],pk[INTEGER] +*/ +- (FMResultSet*)getTableSchema:(NSString*)tableName { + + //result colums: cid[INTEGER], name,type [STRING], notnull[INTEGER], dflt_value[],pk[INTEGER] + FMResultSet *rs = [self executeQuery:[NSString stringWithFormat: @"PRAGMA table_info('%@')", tableName]]; + + return rs; +} + +- (BOOL)columnExists:(NSString*)columnName inTableWithName:(NSString*)tableName { + + BOOL returnBool = NO; + + tableName = [tableName lowercaseString]; + columnName = [columnName lowercaseString]; + + FMResultSet *rs = [self getTableSchema:tableName]; + + //check if column is present in table schema + while ([rs next]) { + if ([[[rs stringForColumn:@"name"] lowercaseString] isEqualToString:columnName]) { + returnBool = YES; + break; + } + } + + //If this is not done FMDatabase instance stays out of pool + [rs close]; + + return returnBool; +} + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-implementations" + +- (BOOL)columnExists:(NSString*)tableName columnName:(NSString*)columnName __attribute__ ((deprecated)) { + return [self columnExists:columnName inTableWithName:tableName]; +} + +#pragma clang diagnostic pop + +- (BOOL)validateSQL:(NSString*)sql error:(NSError**)error { + sqlite3_stmt *pStmt = NULL; + BOOL validationSucceeded = YES; + BOOL keepTrying = YES; + int numberOfRetries = 0; + + while (keepTrying == YES) { + keepTrying = NO; + int rc = sqlite3_prepare_v2(_db, [sql UTF8String], -1, &pStmt, 0); + if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED) { + keepTrying = YES; + usleep(20); + + if (_busyRetryTimeout && (numberOfRetries++ > _busyRetryTimeout)) { + NSLog(@"%s:%d Database busy (%@)", __FUNCTION__, __LINE__, [self databasePath]); + NSLog(@"Database busy"); + } + } + else if (rc != SQLITE_OK) { + validationSucceeded = NO; + if (error) { + *error = [NSError errorWithDomain:NSCocoaErrorDomain + code:[self lastErrorCode] + userInfo:[NSDictionary dictionaryWithObject:[self lastErrorMessage] + forKey:NSLocalizedDescriptionKey]]; + } + } + } + + sqlite3_finalize(pStmt); + + return validationSucceeded; +} + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabasePool.h b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabasePool.h new file mode 100644 index 0000000..8fe0c3e --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabasePool.h @@ -0,0 +1,75 @@ +// +// FMDatabasePool.h +// fmdb +// +// Created by August Mueller on 6/22/11. +// Copyright 2011 Flying Meat Inc. All rights reserved. +// + +#import +#import "sqlite3.h" + +/* + + ***README OR SUFFER*** +Before using FMDatabasePool, please consider using FMDatabaseQueue instead. + +If you really really really know what you're doing and FMDatabasePool is what +you really really need (ie, you're using a read only database), OK you can use +it. But just be careful not to deadlock! + +For an example on deadlocking, search for: +ONLY_USE_THE_POOL_IF_YOU_ARE_DOING_READS_OTHERWISE_YOULL_DEADLOCK_USE_FMDATABASEQUEUE_INSTEAD +in the main.m file. + +*/ + + + +@class FMDatabase; + +@interface FMDatabasePool : NSObject { + NSString *_path; + + dispatch_queue_t _lockQueue; + + NSMutableArray *_databaseInPool; + NSMutableArray *_databaseOutPool; + + __unsafe_unretained id _delegate; + + NSUInteger _maximumNumberOfDatabasesToCreate; +} + +@property (atomic, retain) NSString *path; +@property (atomic, assign) id delegate; +@property (atomic, assign) NSUInteger maximumNumberOfDatabasesToCreate; + ++ (id)databasePoolWithPath:(NSString*)aPath; +- (id)initWithPath:(NSString*)aPath; + +- (NSUInteger)countOfCheckedInDatabases; +- (NSUInteger)countOfCheckedOutDatabases; +- (NSUInteger)countOfOpenDatabases; +- (void)releaseAllDatabases; + +- (void)inDatabase:(void (^)(FMDatabase *db))block; + +- (void)inTransaction:(void (^)(FMDatabase *db, BOOL *rollback))block; +- (void)inDeferredTransaction:(void (^)(FMDatabase *db, BOOL *rollback))block; + +#if SQLITE_VERSION_NUMBER >= 3007000 +// NOTE: you can not nest these, since calling it will pull another database out of the pool and you'll get a deadlock. +// If you need to nest, use FMDatabase's startSavePointWithName:error: instead. +- (NSError*)inSavePoint:(void (^)(FMDatabase *db, BOOL *rollback))block; +#endif + +@end + + +@interface NSObject (FMDatabasePoolDelegate) + +- (BOOL)databasePool:(FMDatabasePool*)pool shouldAddDatabaseToPool:(FMDatabase*)database; + +@end + diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabasePool.m b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabasePool.m new file mode 100644 index 0000000..4cad6cb --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabasePool.m @@ -0,0 +1,244 @@ +// +// FMDatabasePool.m +// fmdb +// +// Created by August Mueller on 6/22/11. +// Copyright 2011 Flying Meat Inc. All rights reserved. +// + +#import "FMDatabasePool.h" +#import "FMDatabase.h" + +@interface FMDatabasePool() + +- (void)pushDatabaseBackInPool:(FMDatabase*)db; +- (FMDatabase*)db; + +@end + + +@implementation FMDatabasePool +@synthesize path=_path; +@synthesize delegate=_delegate; +@synthesize maximumNumberOfDatabasesToCreate=_maximumNumberOfDatabasesToCreate; + + ++ (id)databasePoolWithPath:(NSString*)aPath { + return FMDBReturnAutoreleased([[self alloc] initWithPath:aPath]); +} + +- (id)initWithPath:(NSString*)aPath { + + self = [super init]; + + if (self != nil) { + _path = [aPath copy]; + _lockQueue = dispatch_queue_create([[NSString stringWithFormat:@"fmdb.%@", self] UTF8String], NULL); + _databaseInPool = FMDBReturnRetained([NSMutableArray array]); + _databaseOutPool = FMDBReturnRetained([NSMutableArray array]); + } + + return self; +} + +- (void)dealloc { + + _delegate = 0x00; + FMDBRelease(_path); + FMDBRelease(_databaseInPool); + FMDBRelease(_databaseOutPool); + + if (_lockQueue) { + FMDBDispatchQueueRelease(_lockQueue); + _lockQueue = 0x00; + } +#if ! __has_feature(objc_arc) + [super dealloc]; +#endif +} + + +- (void)executeLocked:(void (^)(void))aBlock { + dispatch_sync(_lockQueue, aBlock); +} + +- (void)pushDatabaseBackInPool:(FMDatabase*)db { + + if (!db) { // db can be null if we set an upper bound on the # of databases to create. + return; + } + + [self executeLocked:^() { + + if ([_databaseInPool containsObject:db]) { + [[NSException exceptionWithName:@"Database already in pool" reason:@"The FMDatabase being put back into the pool is already present in the pool" userInfo:nil] raise]; + } + + [_databaseInPool addObject:db]; + [_databaseOutPool removeObject:db]; + + }]; +} + +- (FMDatabase*)db { + + __block FMDatabase *db; + + [self executeLocked:^() { + db = [_databaseInPool lastObject]; + + if (db) { + [_databaseOutPool addObject:db]; + [_databaseInPool removeLastObject]; + } + else { + + if (_maximumNumberOfDatabasesToCreate) { + NSUInteger currentCount = [_databaseOutPool count] + [_databaseInPool count]; + + if (currentCount >= _maximumNumberOfDatabasesToCreate) { + NSLog(@"Maximum number of databases (%ld) has already been reached!", (long)currentCount); + return; + } + } + + db = [FMDatabase databaseWithPath:_path]; + } + + //This ensures that the db is opened before returning + if ([db open]) { + if ([_delegate respondsToSelector:@selector(databasePool:shouldAddDatabaseToPool:)] && ![_delegate databasePool:self shouldAddDatabaseToPool:db]) { + [db close]; + db = 0x00; + } + else { + //It should not get added in the pool twice if lastObject was found + if (![_databaseOutPool containsObject:db]) { + [_databaseOutPool addObject:db]; + } + } + } + else { + NSLog(@"Could not open up the database at path %@", _path); + db = 0x00; + } + }]; + + return db; +} + +- (NSUInteger)countOfCheckedInDatabases { + + __block NSUInteger count; + + [self executeLocked:^() { + count = [_databaseInPool count]; + }]; + + return count; +} + +- (NSUInteger)countOfCheckedOutDatabases { + + __block NSUInteger count; + + [self executeLocked:^() { + count = [_databaseOutPool count]; + }]; + + return count; +} + +- (NSUInteger)countOfOpenDatabases { + __block NSUInteger count; + + [self executeLocked:^() { + count = [_databaseOutPool count] + [_databaseInPool count]; + }]; + + return count; +} + +- (void)releaseAllDatabases { + [self executeLocked:^() { + [_databaseOutPool removeAllObjects]; + [_databaseInPool removeAllObjects]; + }]; +} + +- (void)inDatabase:(void (^)(FMDatabase *db))block { + + FMDatabase *db = [self db]; + + block(db); + + [self pushDatabaseBackInPool:db]; +} + +- (void)beginTransaction:(BOOL)useDeferred withBlock:(void (^)(FMDatabase *db, BOOL *rollback))block { + + BOOL shouldRollback = NO; + + FMDatabase *db = [self db]; + + if (useDeferred) { + [db beginDeferredTransaction]; + } + else { + [db beginTransaction]; + } + + + block(db, &shouldRollback); + + if (shouldRollback) { + [db rollback]; + } + else { + [db commit]; + } + + [self pushDatabaseBackInPool:db]; +} + +- (void)inDeferredTransaction:(void (^)(FMDatabase *db, BOOL *rollback))block { + [self beginTransaction:YES withBlock:block]; +} + +- (void)inTransaction:(void (^)(FMDatabase *db, BOOL *rollback))block { + [self beginTransaction:NO withBlock:block]; +} +#if SQLITE_VERSION_NUMBER >= 3007000 +- (NSError*)inSavePoint:(void (^)(FMDatabase *db, BOOL *rollback))block { + + static unsigned long savePointIdx = 0; + + NSString *name = [NSString stringWithFormat:@"savePoint%ld", savePointIdx++]; + + BOOL shouldRollback = NO; + + FMDatabase *db = [self db]; + + NSError *err = 0x00; + + if (![db startSavePointWithName:name error:&err]) { + [self pushDatabaseBackInPool:db]; + return err; + } + + block(db, &shouldRollback); + + if (shouldRollback) { + [db rollbackToSavePointWithName:name error:&err]; + } + else { + [db releaseSavePointWithName:name error:&err]; + } + + [self pushDatabaseBackInPool:db]; + + return err; +} +#endif + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseQueue.h b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseQueue.h new file mode 100644 index 0000000..bbf9c66 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseQueue.h @@ -0,0 +1,38 @@ +// +// FMDatabasePool.h +// fmdb +// +// Created by August Mueller on 6/22/11. +// Copyright 2011 Flying Meat Inc. All rights reserved. +// + +#import +#import "sqlite3.h" + +@class FMDatabase; + +@interface FMDatabaseQueue : NSObject { + NSString *_path; + dispatch_queue_t _queue; + FMDatabase *_db; +} + +@property (atomic, retain) NSString *path; + ++ (id)databaseQueueWithPath:(NSString*)aPath; +- (id)initWithPath:(NSString*)aPath; +- (void)close; + +- (void)inDatabase:(void (^)(FMDatabase *db))block; + +- (void)inTransaction:(void (^)(FMDatabase *db, BOOL *rollback))block; +- (void)inDeferredTransaction:(void (^)(FMDatabase *db, BOOL *rollback))block; + +#if SQLITE_VERSION_NUMBER >= 3007000 +// NOTE: you can not nest these, since calling it will pull another database out of the pool and you'll get a deadlock. +// If you need to nest, use FMDatabase's startSavePointWithName:error: instead. +- (NSError*)inSavePoint:(void (^)(FMDatabase *db, BOOL *rollback))block; +#endif + +@end + diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseQueue.m b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseQueue.m new file mode 100644 index 0000000..98fac81 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseQueue.m @@ -0,0 +1,176 @@ +// +// FMDatabasePool.m +// fmdb +// +// Created by August Mueller on 6/22/11. +// Copyright 2011 Flying Meat Inc. All rights reserved. +// + +#import "FMDatabaseQueue.h" +#import "FMDatabase.h" + +/* + + Note: we call [self retain]; before using dispatch_sync, just incase + FMDatabaseQueue is released on another thread and we're in the middle of doing + something in dispatch_sync + + */ + +@implementation FMDatabaseQueue + +@synthesize path = _path; + ++ (id)databaseQueueWithPath:(NSString*)aPath { + + FMDatabaseQueue *q = [[self alloc] initWithPath:aPath]; + + FMDBAutorelease(q); + + return q; +} + +- (id)initWithPath:(NSString*)aPath { + + self = [super init]; + + if (self != nil) { + + _db = [FMDatabase databaseWithPath:aPath]; + FMDBRetain(_db); + + if (![_db open]) { + NSLog(@"Could not create database queue for path %@", aPath); + FMDBRelease(self); + return 0x00; + } + + _path = FMDBReturnRetained(aPath); + + _queue = dispatch_queue_create([[NSString stringWithFormat:@"fmdb.%@", self] UTF8String], NULL); + } + + return self; +} + +- (void)dealloc { + + FMDBRelease(_db); + FMDBRelease(_path); + + if (_queue) { + FMDBDispatchQueueRelease(_queue); + _queue = 0x00; + } +#if ! __has_feature(objc_arc) + [super dealloc]; +#endif +} + +- (void)close { + FMDBRetain(self); + dispatch_sync(_queue, ^() { + [_db close]; + FMDBRelease(_db); + _db = 0x00; + }); + FMDBRelease(self); +} + +- (FMDatabase*)database { + if (!_db) { + _db = FMDBReturnRetained([FMDatabase databaseWithPath:_path]); + + if (![_db open]) { + NSLog(@"FMDatabaseQueue could not reopen database for path %@", _path); + FMDBRelease(_db); + _db = 0x00; + return 0x00; + } + } + + return _db; +} + +- (void)inDatabase:(void (^)(FMDatabase *db))block { + FMDBRetain(self); + + dispatch_sync(_queue, ^() { + + FMDatabase *db = [self database]; + block(db); + + if ([db hasOpenResultSets]) { + NSLog(@"Warning: there is at least one open result set around after performing [FMDatabaseQueue inDatabase:]"); + } + }); + + FMDBRelease(self); +} + + +- (void)beginTransaction:(BOOL)useDeferred withBlock:(void (^)(FMDatabase *db, BOOL *rollback))block { + FMDBRetain(self); + dispatch_sync(_queue, ^() { + + BOOL shouldRollback = NO; + + if (useDeferred) { + [[self database] beginDeferredTransaction]; + } + else { + [[self database] beginTransaction]; + } + + block([self database], &shouldRollback); + + if (shouldRollback) { + [[self database] rollback]; + } + else { + [[self database] commit]; + } + }); + + FMDBRelease(self); +} + +- (void)inDeferredTransaction:(void (^)(FMDatabase *db, BOOL *rollback))block { + [self beginTransaction:YES withBlock:block]; +} + +- (void)inTransaction:(void (^)(FMDatabase *db, BOOL *rollback))block { + [self beginTransaction:NO withBlock:block]; +} + +#if SQLITE_VERSION_NUMBER >= 3007000 +- (NSError*)inSavePoint:(void (^)(FMDatabase *db, BOOL *rollback))block { + + static unsigned long savePointIdx = 0; + __block NSError *err = 0x00; + FMDBRetain(self); + dispatch_sync(_queue, ^() { + + NSString *name = [NSString stringWithFormat:@"savePoint%ld", savePointIdx++]; + + BOOL shouldRollback = NO; + + if ([[self database] startSavePointWithName:name error:&err]) { + + block([self database], &shouldRollback); + + if (shouldRollback) { + [[self database] rollbackToSavePointWithName:name error:&err]; + } + else { + [[self database] releaseSavePointWithName:name error:&err]; + } + + } + }); + FMDBRelease(self); + return err; +} +#endif + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMResultSet.h b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMResultSet.h new file mode 100644 index 0000000..b3dd6f6 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMResultSet.h @@ -0,0 +1,105 @@ +#import +#import "sqlite3.h" + +#ifndef __has_feature // Optional. +#define __has_feature(x) 0 // Compatibility with non-clang compilers. +#endif + +#ifndef NS_RETURNS_NOT_RETAINED +#if __has_feature(attribute_ns_returns_not_retained) +#define NS_RETURNS_NOT_RETAINED __attribute__((ns_returns_not_retained)) +#else +#define NS_RETURNS_NOT_RETAINED +#endif +#endif + +@class FMDatabase; +@class FMStatement; + +@interface FMResultSet : NSObject { + FMDatabase *_parentDB; + FMStatement *_statement; + + NSString *_query; + NSMutableDictionary *_columnNameToIndexMap; + BOOL _columnNamesSetup; +} + +@property (atomic, retain) NSString *query; +@property (atomic, retain) NSMutableDictionary *columnNameToIndexMap; +@property (atomic, retain) FMStatement *statement; + ++ (id)resultSetWithStatement:(FMStatement *)statement usingParentDatabase:(FMDatabase*)aDB; + +- (void)close; + +- (void)setParentDB:(FMDatabase *)newDb; + +- (BOOL)next; +- (BOOL)hasAnotherRow; + +- (int)columnCount; + +- (int)columnIndexForName:(NSString*)columnName; +- (NSString*)columnNameForIndex:(int)columnIdx; + +- (int)intForColumn:(NSString*)columnName; +- (int)intForColumnIndex:(int)columnIdx; + +- (long)longForColumn:(NSString*)columnName; +- (long)longForColumnIndex:(int)columnIdx; + +- (long long int)longLongIntForColumn:(NSString*)columnName; +- (long long int)longLongIntForColumnIndex:(int)columnIdx; + +- (unsigned long long int)unsignedLongLongIntForColumn:(NSString*)columnName; +- (unsigned long long int)unsignedLongLongIntForColumnIndex:(int)columnIdx; + +- (BOOL)boolForColumn:(NSString*)columnName; +- (BOOL)boolForColumnIndex:(int)columnIdx; + +- (double)doubleForColumn:(NSString*)columnName; +- (double)doubleForColumnIndex:(int)columnIdx; + +- (NSString*)stringForColumn:(NSString*)columnName; +- (NSString*)stringForColumnIndex:(int)columnIdx; + +- (NSDate*)dateForColumn:(NSString*)columnName; +- (NSDate*)dateForColumnIndex:(int)columnIdx; + +- (NSData*)dataForColumn:(NSString*)columnName; +- (NSData*)dataForColumnIndex:(int)columnIdx; + +- (const unsigned char *)UTF8StringForColumnIndex:(int)columnIdx; +- (const unsigned char *)UTF8StringForColumnName:(NSString*)columnName; + +// returns one of NSNumber, NSString, NSData, or NSNull +- (id)objectForColumnName:(NSString*)columnName; +- (id)objectForColumnIndex:(int)columnIdx; + +- (id)objectForKeyedSubscript:(NSString *)columnName; +- (id)objectAtIndexedSubscript:(int)columnIdx; + +/* +If you are going to use this data after you iterate over the next row, or after you close the +result set, make sure to make a copy of the data first (or just use dataForColumn:/dataForColumnIndex:) +If you don't, you're going to be in a world of hurt when you try and use the data. +*/ +- (NSData*)dataNoCopyForColumn:(NSString*)columnName NS_RETURNS_NOT_RETAINED; +- (NSData*)dataNoCopyForColumnIndex:(int)columnIdx NS_RETURNS_NOT_RETAINED; + +- (BOOL)columnIndexIsNull:(int)columnIdx; +- (BOOL)columnIsNull:(NSString*)columnName; + + +/* Returns a dictionary of the row results mapped to case sensitive keys of the column names. */ +- (NSDictionary*)resultDictionary; + +/* Please use resultDictionary instead. Also, beware that resultDictionary is case sensitive! */ +- (NSDictionary*)resultDict __attribute__ ((deprecated)); + +- (void)kvcMagic:(id)object; + + +@end + diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMResultSet.m b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMResultSet.m new file mode 100644 index 0000000..1414f40 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMResultSet.m @@ -0,0 +1,431 @@ +#import "FMResultSet.h" +#import "FMDatabase.h" +#import "unistd.h" + +@interface FMDatabase () +- (void)resultSetDidClose:(FMResultSet *)resultSet; +@end + + +@interface FMResultSet (Private) +- (NSMutableDictionary *)columnNameToIndexMap; +- (void)setColumnNameToIndexMap:(NSMutableDictionary *)value; +@end + +@implementation FMResultSet +@synthesize query=_query; +@synthesize columnNameToIndexMap=_columnNameToIndexMap; +@synthesize statement=_statement; + ++ (id)resultSetWithStatement:(FMStatement *)statement usingParentDatabase:(FMDatabase*)aDB { + + FMResultSet *rs = [[FMResultSet alloc] init]; + + [rs setStatement:statement]; + [rs setParentDB:aDB]; + + return FMDBReturnAutoreleased(rs); +} + +- (void)finalize { + [self close]; + [super finalize]; +} + +- (void)dealloc { + [self close]; + + FMDBRelease(_query); + _query = nil; + + FMDBRelease(_columnNameToIndexMap); + _columnNameToIndexMap = nil; + +#if ! __has_feature(objc_arc) + [super dealloc]; +#endif +} + +- (void)close { + [_statement reset]; + FMDBRelease(_statement); + _statement = nil; + + // we don't need this anymore... (i think) + //[_parentDB setInUse:NO]; + [_parentDB resultSetDidClose:self]; + _parentDB = nil; +} + +- (int)columnCount { + return sqlite3_column_count([_statement statement]); +} + +- (void)setupColumnNames { + + if (!_columnNameToIndexMap) { + [self setColumnNameToIndexMap:[NSMutableDictionary dictionary]]; + } + + int columnCount = sqlite3_column_count([_statement statement]); + + int columnIdx = 0; + for (columnIdx = 0; columnIdx < columnCount; columnIdx++) { + [_columnNameToIndexMap setObject:[NSNumber numberWithInt:columnIdx] + forKey:[[NSString stringWithUTF8String:sqlite3_column_name([_statement statement], columnIdx)] lowercaseString]]; + } + _columnNamesSetup = YES; +} + +- (void)kvcMagic:(id)object { + + int columnCount = sqlite3_column_count([_statement statement]); + + int columnIdx = 0; + for (columnIdx = 0; columnIdx < columnCount; columnIdx++) { + + const char *c = (const char *)sqlite3_column_text([_statement statement], columnIdx); + + // check for a null row + if (c) { + NSString *s = [NSString stringWithUTF8String:c]; + + [object setValue:s forKey:[NSString stringWithUTF8String:sqlite3_column_name([_statement statement], columnIdx)]]; + } + } +} + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-implementations" + +- (NSDictionary*)resultDict { + + NSUInteger num_cols = (NSUInteger)sqlite3_data_count([_statement statement]); + + if (num_cols > 0) { + NSMutableDictionary *dict = [NSMutableDictionary dictionaryWithCapacity:num_cols]; + + if (!_columnNamesSetup) { + [self setupColumnNames]; + } + + NSEnumerator *columnNames = [_columnNameToIndexMap keyEnumerator]; + NSString *columnName = nil; + while ((columnName = [columnNames nextObject])) { + id objectValue = [self objectForColumnName:columnName]; + [dict setObject:objectValue forKey:columnName]; + } + + return FMDBReturnAutoreleased([dict copy]); + } + else { + NSLog(@"Warning: There seem to be no columns in this set."); + } + + return nil; +} + +#pragma clang diagnostic pop + +- (NSDictionary*)resultDictionary { + + NSUInteger num_cols = (NSUInteger)sqlite3_data_count([_statement statement]); + + if (num_cols > 0) { + NSMutableDictionary *dict = [NSMutableDictionary dictionaryWithCapacity:num_cols]; + + int columnCount = sqlite3_column_count([_statement statement]); + + int columnIdx = 0; + for (columnIdx = 0; columnIdx < columnCount; columnIdx++) { + + NSString *columnName = [NSString stringWithUTF8String:sqlite3_column_name([_statement statement], columnIdx)]; + id objectValue = [self objectForColumnIndex:columnIdx]; + [dict setObject:objectValue forKey:columnName]; + } + + return dict; + } + else { + NSLog(@"Warning: There seem to be no columns in this set."); + } + + return nil; +} + + + + + +- (BOOL)next { + + int rc; + BOOL retry; + int numberOfRetries = 0; + do { + retry = NO; + + rc = sqlite3_step([_statement statement]); + + if (SQLITE_BUSY == rc || SQLITE_LOCKED == rc) { + // this will happen if the db is locked, like if we are doing an update or insert. + // in that case, retry the step... and maybe wait just 10 milliseconds. + retry = YES; + if (SQLITE_LOCKED == rc) { + rc = sqlite3_reset([_statement statement]); + if (rc != SQLITE_LOCKED) { + NSLog(@"Unexpected result from sqlite3_reset (%d) rs", rc); + } + } + usleep(20); + + if ([_parentDB busyRetryTimeout] && (numberOfRetries++ > [_parentDB busyRetryTimeout])) { + + NSLog(@"%s:%d Database busy (%@)", __FUNCTION__, __LINE__, [_parentDB databasePath]); + NSLog(@"Database busy"); + break; + } + } + else if (SQLITE_DONE == rc || SQLITE_ROW == rc) { + // all is well, let's return. + } + else if (SQLITE_ERROR == rc) { + NSLog(@"Error calling sqlite3_step (%d: %s) rs", rc, sqlite3_errmsg([_parentDB sqliteHandle])); + break; + } + else if (SQLITE_MISUSE == rc) { + // uh oh. + NSLog(@"Error calling sqlite3_step (%d: %s) rs", rc, sqlite3_errmsg([_parentDB sqliteHandle])); + break; + } + else { + // wtf? + NSLog(@"Unknown error calling sqlite3_step (%d: %s) rs", rc, sqlite3_errmsg([_parentDB sqliteHandle])); + break; + } + + } while (retry); + + + if (rc != SQLITE_ROW) { + [self close]; + } + + return (rc == SQLITE_ROW); +} + +- (BOOL)hasAnotherRow { + return sqlite3_errcode([_parentDB sqliteHandle]) == SQLITE_ROW; +} + +- (int)columnIndexForName:(NSString*)columnName { + + if (!_columnNamesSetup) { + [self setupColumnNames]; + } + + columnName = [columnName lowercaseString]; + + NSNumber *n = [_columnNameToIndexMap objectForKey:columnName]; + + if (n) { + return [n intValue]; + } + + NSLog(@"Warning: I could not find the column named '%@'.", columnName); + + return -1; +} + + + +- (int)intForColumn:(NSString*)columnName { + return [self intForColumnIndex:[self columnIndexForName:columnName]]; +} + +- (int)intForColumnIndex:(int)columnIdx { + return sqlite3_column_int([_statement statement], columnIdx); +} + +- (long)longForColumn:(NSString*)columnName { + return [self longForColumnIndex:[self columnIndexForName:columnName]]; +} + +- (long)longForColumnIndex:(int)columnIdx { + return (long)sqlite3_column_int64([_statement statement], columnIdx); +} + +- (long long int)longLongIntForColumn:(NSString*)columnName { + return [self longLongIntForColumnIndex:[self columnIndexForName:columnName]]; +} + +- (long long int)longLongIntForColumnIndex:(int)columnIdx { + return sqlite3_column_int64([_statement statement], columnIdx); +} + +- (unsigned long long int)unsignedLongLongIntForColumn:(NSString*)columnName { + return [self unsignedLongLongIntForColumnIndex:[self columnIndexForName:columnName]]; +} + +- (unsigned long long int)unsignedLongLongIntForColumnIndex:(int)columnIdx { + return (unsigned long long int)[self longLongIntForColumnIndex:columnIdx]; +} + +- (BOOL)boolForColumn:(NSString*)columnName { + return [self boolForColumnIndex:[self columnIndexForName:columnName]]; +} + +- (BOOL)boolForColumnIndex:(int)columnIdx { + return ([self intForColumnIndex:columnIdx] != 0); +} + +- (double)doubleForColumn:(NSString*)columnName { + return [self doubleForColumnIndex:[self columnIndexForName:columnName]]; +} + +- (double)doubleForColumnIndex:(int)columnIdx { + return sqlite3_column_double([_statement statement], columnIdx); +} + +- (NSString*)stringForColumnIndex:(int)columnIdx { + + if (sqlite3_column_type([_statement statement], columnIdx) == SQLITE_NULL || (columnIdx < 0)) { + return nil; + } + + const char *c = (const char *)sqlite3_column_text([_statement statement], columnIdx); + + if (!c) { + // null row. + return nil; + } + + return [NSString stringWithUTF8String:c]; +} + +- (NSString*)stringForColumn:(NSString*)columnName { + return [self stringForColumnIndex:[self columnIndexForName:columnName]]; +} + +- (NSDate*)dateForColumn:(NSString*)columnName { + return [self dateForColumnIndex:[self columnIndexForName:columnName]]; +} + +- (NSDate*)dateForColumnIndex:(int)columnIdx { + + if (sqlite3_column_type([_statement statement], columnIdx) == SQLITE_NULL || (columnIdx < 0)) { + return nil; + } + + return [NSDate dateWithTimeIntervalSince1970:[self doubleForColumnIndex:columnIdx]]; +} + + +- (NSData*)dataForColumn:(NSString*)columnName { + return [self dataForColumnIndex:[self columnIndexForName:columnName]]; +} + +- (NSData*)dataForColumnIndex:(int)columnIdx { + + if (sqlite3_column_type([_statement statement], columnIdx) == SQLITE_NULL || (columnIdx < 0)) { + return nil; + } + + int dataSize = sqlite3_column_bytes([_statement statement], columnIdx); + + NSMutableData *data = [NSMutableData dataWithLength:(NSUInteger)dataSize]; + + memcpy([data mutableBytes], sqlite3_column_blob([_statement statement], columnIdx), dataSize); + + return data; +} + + +- (NSData*)dataNoCopyForColumn:(NSString*)columnName { + return [self dataNoCopyForColumnIndex:[self columnIndexForName:columnName]]; +} + +- (NSData*)dataNoCopyForColumnIndex:(int)columnIdx { + + if (sqlite3_column_type([_statement statement], columnIdx) == SQLITE_NULL || (columnIdx < 0)) { + return nil; + } + + int dataSize = sqlite3_column_bytes([_statement statement], columnIdx); + + NSData *data = [NSData dataWithBytesNoCopy:(void *)sqlite3_column_blob([_statement statement], columnIdx) length:(NSUInteger)dataSize freeWhenDone:NO]; + + return data; +} + + +- (BOOL)columnIndexIsNull:(int)columnIdx { + return sqlite3_column_type([_statement statement], columnIdx) == SQLITE_NULL; +} + +- (BOOL)columnIsNull:(NSString*)columnName { + return [self columnIndexIsNull:[self columnIndexForName:columnName]]; +} + +- (const unsigned char *)UTF8StringForColumnIndex:(int)columnIdx { + + if (sqlite3_column_type([_statement statement], columnIdx) == SQLITE_NULL || (columnIdx < 0)) { + return nil; + } + + return sqlite3_column_text([_statement statement], columnIdx); +} + +- (const unsigned char *)UTF8StringForColumnName:(NSString*)columnName { + return [self UTF8StringForColumnIndex:[self columnIndexForName:columnName]]; +} + +- (id)objectForColumnIndex:(int)columnIdx { + int columnType = sqlite3_column_type([_statement statement], columnIdx); + + id returnValue = nil; + + if (columnType == SQLITE_INTEGER) { + returnValue = [NSNumber numberWithLongLong:[self longLongIntForColumnIndex:columnIdx]]; + } + else if (columnType == SQLITE_FLOAT) { + returnValue = [NSNumber numberWithDouble:[self doubleForColumnIndex:columnIdx]]; + } + else if (columnType == SQLITE_BLOB) { + returnValue = [self dataForColumnIndex:columnIdx]; + } + else { + //default to a string for everything else + returnValue = [self stringForColumnIndex:columnIdx]; + } + + if (returnValue == nil) { + returnValue = [NSNull null]; + } + + return returnValue; +} + +- (id)objectForColumnName:(NSString*)columnName { + return [self objectForColumnIndex:[self columnIndexForName:columnName]]; +} + +// returns autoreleased NSString containing the name of the column in the result set +- (NSString*)columnNameForIndex:(int)columnIdx { + return [NSString stringWithUTF8String: sqlite3_column_name([_statement statement], columnIdx)]; +} + +- (void)setParentDB:(FMDatabase *)newDb { + _parentDB = newDb; +} + +- (id)objectAtIndexedSubscript:(int)columnIdx { + return [self objectForColumnIndex:columnIdx]; +} + +- (id)objectForKeyedSubscript:(NSString *)columnName { + return [self objectForColumnName:columnName]; +} + + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Agency.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/Agency.h new file mode 100644 index 0000000..887d582 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/Agency.h @@ -0,0 +1,25 @@ +// +// Agency.h +// GTFS-VTA +// +// Created by Vashishtha Jogi on 7/31/11. +// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. +// + +#import +#import "FMDatabase.h" + + +@interface Agency : NSObject + +@property (nonatomic, strong) NSString * agencyId; +@property (nonatomic, strong) NSString * agencyName; +@property (nonatomic, strong) NSString * agencyTimezone; +@property (nonatomic, strong) NSString * agencyUrl; + +- (void)addAgency:(Agency *)agency; +- (id)initWithDB:(FMDatabase *)fmdb; +- (void)cleanupAndCreate; +- (void)receiveRecord:(NSDictionary *)aRecord; + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Agency.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/Agency.m new file mode 100644 index 0000000..f7a0858 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/Agency.m @@ -0,0 +1,101 @@ +// +// Agency.m +// GTFS-VTA +// +// Created by Vashishtha Jogi on 7/31/11. +// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. +// + +#import "Agency.h" +#import "CSVParser.h" +#import "FMDatabase.h" +#import "Util.h" + +@interface Agency () +{ + FMDatabase *db; +} + +@end + +@implementation Agency + +- (id)initWithDB:(FMDatabase *)fmdb +{ + self = [super init]; + if (self) + { + db = fmdb; + } + return self; +} + +- (void)addAgency:(Agency *)agency +{ + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + [db executeUpdate:@"INSERT into agency(agency_id, agency_name, agency_timezone, agency_url) values(?, ?, ?, ?)", + agency.agencyId, + agency.agencyName, + agency.agencyTimezone, + agency.agencyUrl]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } + +} + +- (void)cleanupAndCreate +{ + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + //Drop table if it exists + NSString *dropAgency = @"DROP TABLE IF EXISTS agency"; + + [db executeUpdate:dropAgency]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } + + //Create table + NSString *createAgency = @"CREATE TABLE 'agency' ('agency_url' TEXT DEFAULT NULL, 'agency_name' TEXT DEFAULT NULL, 'agency_timezone' TEXT DEFAULT NULL, 'agency_id' TEXT NOT NULL, PRIMARY KEY ('agency_id'))"; + + [db executeUpdate:createAgency]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } +} + +- (void)receiveRecord:(NSDictionary *)aRecord +{ + + Agency *agencyRecord = [[Agency alloc] init]; + agencyRecord.agencyId = aRecord[@"agency_id"]; + agencyRecord.agencyName = aRecord[@"agency_name"]; + agencyRecord.agencyTimezone = aRecord[@"agency_timezone"]; + agencyRecord.agencyUrl = aRecord[@"agency_url"]; + + [self addAgency:agencyRecord]; +} + + + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Calendar.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/Calendar.h new file mode 100644 index 0000000..3650483 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/Calendar.h @@ -0,0 +1,31 @@ +// +// Calendar.h +// GTFS-VTA +// +// Created by Vashishtha Jogi on 7/31/11. +// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. +// + +#import +#import "FMDatabase.h" + + +@interface Calendar : NSObject + +@property (nonatomic, strong) NSString * endDate; +@property (nonatomic, strong) NSString * friday; +@property (nonatomic, strong) NSString * monday; +@property (nonatomic, strong) NSString * saturday; +@property (nonatomic, strong) NSString * serviceId; +@property (nonatomic, strong) NSString * startDate; +@property (nonatomic, strong) NSString * sunday; +@property (nonatomic, strong) NSString * thursday; +@property (nonatomic, strong) NSString * tuesday; +@property (nonatomic, strong) NSString * wednesday; + +- (id)initWithDB:(FMDatabase *)fmdb; +- (void)addCalendar:(Calendar *)calendar; +- (void)cleanupAndCreate; +- (void)receiveRecord:(NSDictionary *)aRecord; + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Calendar.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/Calendar.m new file mode 100644 index 0000000..bf910b8 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/Calendar.m @@ -0,0 +1,123 @@ +// +// Calendar.m +// GTFS-VTA +// +// Created by Vashishtha Jogi on 7/31/11. +// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. +// + +#import "Calendar.h" +#import "FMDatabase.h" +#import "CSVParser.h" +#import "Util.h" + +@interface Calendar () +{ + FMDatabase *db; + NSDateFormatter *dateFormat, *dateFormat2; +} + +@end + +@implementation Calendar + +- (id)initWithDB:(FMDatabase *)fmdb +{ + self = [super init]; + if (self) + { + db = fmdb; + dateFormat = [[NSDateFormatter alloc] init]; + [dateFormat setDateFormat:@"yyyyMMdd"]; + dateFormat2 = [[NSDateFormatter alloc] init]; + [dateFormat2 setDateFormat:@"yyyy-MM-dd"]; + } + return self; +} + +- (void)addCalendar:(Calendar *)calendar +{ +// NSLog(@"Calendar %@, %@", calendar.start_date, calendar.end_date); + + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + [db executeUpdate:@"INSERT into calendar(end_date, friday, monday, saturday, service_id, start_date, sunday, thursday, tuesday, wednesday) values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + calendar.endDate, + calendar.friday, + calendar.monday, + calendar.saturday, + calendar.serviceId, + calendar.startDate, + calendar.sunday, + calendar.thursday, + calendar.tuesday, + calendar.wednesday]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } +} + + + +- (void)cleanupAndCreate +{ + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + //Drop table if it exists + NSString *drop = @"DROP TABLE IF EXISTS calendar"; + + [db executeUpdate:drop]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } + + //Create table + NSString *create = @"CREATE TABLE 'calendar' ('service_id' TEXT DEFAULT NULL,'start_date' date DEFAULT NULL,'end_date' date DEFAULT NULL,'monday' tinyint(1) DEFAULT NULL,'tuesday' tinyint(1) DEFAULT NULL,'wednesday' tinyint(1) DEFAULT NULL,'thursday' tinyint(1) DEFAULT NULL,'friday' tinyint(1) DEFAULT NULL,'saturday' tinyint(1) DEFAULT NULL,'sunday' tinyint(1) DEFAULT NULL)"; + NSString *createIndex = @"CREATE INDEX service_id_calendar ON calendar(service_id)"; + + [db executeUpdate:create]; + [db executeUpdate:createIndex]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } +} + +- (void)receiveRecord:(NSDictionary *)aRecord +{ + + Calendar *calendarRecord = [[Calendar alloc] init]; + calendarRecord.serviceId = aRecord[@"service_id"]; + calendarRecord.sunday = aRecord[@"sunday"]; + calendarRecord.monday = aRecord[@"monday"]; + calendarRecord.tuesday = aRecord[@"tuesday"]; + calendarRecord.wednesday = aRecord[@"wednesday"]; + calendarRecord.thursday = aRecord[@"thursday"]; + calendarRecord.friday = aRecord[@"friday"]; + calendarRecord.saturday = aRecord[@"saturday"]; + //Date format is wrong, so correct it now + calendarRecord.startDate = [dateFormat2 stringFromDate:[dateFormat dateFromString:aRecord[@"start_date"]]]; + calendarRecord.endDate = [dateFormat2 stringFromDate:[dateFormat dateFromString:aRecord[@"end_date"]]]; + + [self addCalendar:calendarRecord]; +} + + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/CalendarDate.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/CalendarDate.h new file mode 100644 index 0000000..b03c0b0 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/CalendarDate.h @@ -0,0 +1,22 @@ +// +// CalendarDate.h +// +// Created by Kevin Conley on 6/25/2013. +// + +#import +#import "FMDatabase.h" + + +@interface CalendarDate : NSObject + +@property (nonatomic, strong) NSString * serviceId; +@property (nonatomic, strong) NSString * date; +@property (nonatomic, strong) NSString * exceptionType; + +- (id)initWithDB:(FMDatabase *)fmdb; +- (void)addCalendarDate:(CalendarDate *)calendarDate; +- (void)cleanupAndCreate; +- (void)receiveRecord:(NSDictionary *)aRecord; + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/CalendarDate.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/CalendarDate.m new file mode 100644 index 0000000..fcc9955 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/CalendarDate.m @@ -0,0 +1,105 @@ +// +// CalendarDate.m +// +// Created by Kevin Conley on 6/25/2013. +// + +#import "CalendarDate.h" +#import "FMDatabase.h" +#import "CSVParser.h" +#import "Util.h" + +@interface CalendarDate () +{ + FMDatabase *db; + NSDateFormatter *dateFormat, *dateFormat2; +} + +@end + +@implementation CalendarDate + +- (id)initWithDB:(FMDatabase *)fmdb +{ + self = [super init]; + if (self) + { + db = fmdb; + dateFormat = [[NSDateFormatter alloc] init]; + [dateFormat setDateFormat:@"yyyyMMdd"]; + dateFormat2 = [[NSDateFormatter alloc] init]; + [dateFormat2 setDateFormat:@"yyyy-MM-dd"]; + } + return self; +} + +- (void)addCalendarDate:(CalendarDate *)calendarDate +{ + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + [db executeUpdate:@"INSERT into calendar_dates(service_id,date,exception_type) values(?, ?, ?)", + calendarDate.serviceId, + calendarDate.date, + calendarDate.exceptionType]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } +} + + + +- (void)cleanupAndCreate +{ + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + //Drop table if it exists + NSString *drop = @"DROP TABLE IF EXISTS calendar_dates"; + + [db executeUpdate:drop]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } + + //Create table + NSString *create = @"CREATE TABLE 'calendar_dates' ('service_id' TEXT NOT NULL,'date' date NOT NULL,'exception_type' tinyint(2) NOT NULL)"; + NSString *createIndex = @"CREATE INDEX service_id_calendar_dates ON calendar_dates(service_id)"; + + [db executeUpdate:create]; + [db executeUpdate:createIndex]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } +} + +- (void)receiveRecord:(NSDictionary *)aRecord +{ + + CalendarDate *calendarDateRecord = [[CalendarDate alloc] init]; + calendarDateRecord.serviceId = aRecord[@"service_id"]; + calendarDateRecord.exceptionType = aRecord[@"exception_type"]; + //Date format is wrong, so correct it now + calendarDateRecord.date = [dateFormat2 stringFromDate:[dateFormat dateFromString:aRecord[@"date"]]]; + + [self addCalendarDate:calendarDateRecord]; +} + + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/FareAttributes.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/FareAttributes.h new file mode 100644 index 0000000..ba4f995 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/FareAttributes.h @@ -0,0 +1,26 @@ +// +// FareAttributes.h +// GTFS-VTA +// +// Created by Vashishtha Jogi on 7/31/11. +// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. +// + +#import +#import "FMDatabase.h" + +@interface FareAttributes : NSObject + +@property (nonatomic, strong) NSString * currencyType; +@property (nonatomic, strong) NSString * fareId; +@property (nonatomic, strong) NSNumber * paymentMethod; +@property (nonatomic, strong) NSNumber * price; +@property (nonatomic, strong) NSNumber * transferDuration; +@property (nonatomic, strong) NSNumber * transfers; + +- (void)addFareAttributesObject:(FareAttributes *)value; +- (id)initWithDB:(FMDatabase *)fmdb; +- (void)cleanupAndCreate; +- (void)receiveRecord:(NSDictionary *)aRecord; + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/FareAttributes.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/FareAttributes.m new file mode 100644 index 0000000..1a3e6fb --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/FareAttributes.m @@ -0,0 +1,101 @@ +// +// FareAttributes.m +// GTFS-VTA +// +// Created by Vashishtha Jogi on 7/31/11. +// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. +// + +#import "FareAttributes.h" +#import "CSVParser.h" +#import "FMDatabase.h" +#import "Util.h" + +@interface FareAttributes () +{ + FMDatabase *db; +} + +@end + +@implementation FareAttributes + +- (id)initWithDB:(FMDatabase *)fmdb +{ + self = [super init]; + if (self) + { + db = fmdb; + } + return self; +} + +- (void)addFareAttributesObject:(FareAttributes *)value { + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + [db executeUpdate:@"INSERT into fare_attributes(fare_id,price,currency_type,payment_method,transfers,transfer_duration) values(?, ?, ?, ?, ?, ?)", + value.fareId, + value.price, + value.currencyType, + value.paymentMethod, + value.transfers, + value.transferDuration]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } +} + +- (void)cleanupAndCreate +{ + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + //Drop table if it exists + NSString *drop = @"DROP TABLE IF EXISTS fare_attributes"; + + [db executeUpdate:drop]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } + + //Create table + NSString *create = @"CREATE TABLE 'fare_attributes' ('fare_id' TEXT NOT NULL, 'price' FLOAT DEFAULT 0.0, 'currency_type' TEXT DEFAULT NULL, 'payment_method' INT(2), 'transfers' INT(11), 'transfer_duration' INT(11), PRIMARY KEY ('fare_id'))"; + + [db executeUpdate:create]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } +} + +- (void)receiveRecord:(NSDictionary *)aRecord +{ + FareAttributes *fareAttributesRecord = [[FareAttributes alloc] init]; + fareAttributesRecord.fareId = aRecord[@"fare_id"]; + fareAttributesRecord.price = aRecord[@"price"]; + fareAttributesRecord.currencyType = aRecord[@"currency_type"]; + fareAttributesRecord.paymentMethod = aRecord[@"payment_type"]; + fareAttributesRecord.transfers = aRecord[@"transfers"]; + fareAttributesRecord.transferDuration = aRecord[@"transfer_duration"]; + + [self addFareAttributesObject:fareAttributesRecord]; +} + + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/FareRules.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/FareRules.h new file mode 100644 index 0000000..a11810d --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/FareRules.h @@ -0,0 +1,25 @@ +// +// FareRules.h +// GTFS-VTA +// +// Created by Vashishtha Jogi on 7/31/11. +// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. +// + +#import +#import "FMDatabase.h" + +@interface FareRules : NSObject + +@property (nonatomic, strong) NSString *fareId; +@property (nonatomic, strong) NSString *routeId; +@property (nonatomic, strong) NSString *originId; +@property (nonatomic, strong) NSString *destinationId; +@property (nonatomic, strong) NSString *containsId; + +- (void)addFareRules:(FareRules *)value; +- (id)initWithDB:(FMDatabase *)fmdb; +- (void)cleanupAndCreate; +- (void)receiveRecord:(NSDictionary *)aRecord; + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/FareRules.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/FareRules.m new file mode 100644 index 0000000..eb4af82 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/FareRules.m @@ -0,0 +1,99 @@ +// +// FareRules.m +// GTFS-VTA +// +// Created by Vashishtha Jogi on 7/31/11. +// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. +// + +#import "FareRules.h" +#import "CSVParser.h" +#import "FMDatabase.h" +#import "Util.h" + +@interface FareRules () +{ + FMDatabase *db; +} + +@end + +@implementation FareRules + +- (id) initWithDB:(FMDatabase *)fmdb +{ + self = [super init]; + if (self) + { + db = fmdb; + } + return self; +} + +- (void)addFareRules:(FareRules *)value { + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + [db executeUpdate:@"INSERT into fare_rules(fare_id,route_id,origin_id,destination_id,contains_id) values(?, ?, ?, ?, ?)", + value.fareId, + value.routeId, + value.originId, + value.destinationId, + value.containsId]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } +} + +- (void)cleanupAndCreate +{ + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + //Drop table if it exists + NSString *drop = @"DROP TABLE IF EXISTS fare_rules"; + + [db executeUpdate:drop]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } + + //Create table + NSString *create = @"CREATE TABLE 'fare_rules' ('fare_id' TEXT NOT NULL, 'route_id' TEXT NOT NULL, 'origin_id' TEXT NOT NULL, 'destination_id' TEXT NOT NULL, 'contains_id' TEXT NOT NULL)"; + + [db executeUpdate:create]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } +} + +- (void)receiveRecord:(NSDictionary *)aRecord +{ + FareRules *fareRulesRecord = [[FareRules alloc] init]; + fareRulesRecord.fareId = aRecord[@"fare_id"]; + fareRulesRecord.routeId = aRecord[@"route_id"]; + fareRulesRecord.originId = aRecord[@"origin_id"]; + fareRulesRecord.destinationId = aRecord[@"destination_id"]; + fareRulesRecord.containsId = aRecord[@"contains_id"]; + + [self addFareRules:fareRulesRecord]; +} + + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Route.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/Route.h new file mode 100644 index 0000000..8128086 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/Route.h @@ -0,0 +1,26 @@ +// +// Route.h +// GTFS-VTA +// +// Created by Vashishtha Jogi on 7/31/11. +// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. +// + +#import +#import "FMDatabase.h" + +@interface Route : NSObject + +@property (nonatomic, strong) NSString * routeLongName; +@property (nonatomic, strong) NSNumber * routeType; +@property (nonatomic, strong) NSString * routeId; +@property (nonatomic, strong) NSString * routeShortName; +@property (nonatomic, strong) NSString * agencyId; + +- (void)addRoute:(Route *)route; +- (id)initWithDB:(FMDatabase *)fmdb; +- (void)cleanupAndCreate; +- (void)receiveRecord:(NSDictionary *)aRecord; +- (NSArray *)getAllRoutes; + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Route.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/Route.m new file mode 100644 index 0000000..0177dde --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/Route.m @@ -0,0 +1,137 @@ +// +// Route.m +// GTFS-VTA +// +// Created by Vashishtha Jogi on 7/31/11. +// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. +// + +#import "Route.h" +#import "CSVParser.h" +#import "FMDatabase.h" +#import "Util.h" + +@interface Route () +{ + FMDatabase *db; +} + +@end + +@implementation Route + +- (id) initWithDB:(FMDatabase *)fmdb +{ + self = [super init]; + if (self) + { + db = fmdb; + } + return self; +} + +- (void)addRoute:(Route *)route +{ + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + [db executeUpdate:@"INSERT into routes(route_long_name,route_type,agency_id,route_id,route_short_name) values(?, ?, ?, ?, ?)", + route.routeLongName, + route.routeType, + route.agencyId, + route.routeId, + route.routeShortName]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } +} + +- (void)cleanupAndCreate +{ + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + //Drop table if it exists + NSString *drop = @"DROP TABLE IF EXISTS routes"; + + [db executeUpdate:drop]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } + + //Create table + NSString *create = @"CREATE TABLE 'routes' ('route_long_name' TEXT DEFAULT NULL,'route_type' int(2) DEFAULT NULL, 'agency_id' TEXT DEFAULT NULL, 'route_id' TEXT NOT NULL, 'route_short_name' TEXT DEFAULT NULL, PRIMARY KEY ('route_id'))"; + + [db executeUpdate:create]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } +} + +- (void)receiveRecord:(NSDictionary *)aRecord +{ + Route *routeRecord = [[Route alloc] init]; + routeRecord.routeId = aRecord[@"route_id"]; + routeRecord.routeLongName = [aRecord[@"route_long_name"] localizedCapitalizedString]; + routeRecord.routeShortName = [aRecord[@"route_short_name"] localizedCapitalizedString]; + routeRecord.routeType = aRecord[@"route_type"]; + routeRecord.agencyId = aRecord[@"agency_id"]; + + [self addRoute:routeRecord]; +} + +- (NSArray *)getAllRoutes +{ + + NSMutableArray *routes = [[NSMutableArray alloc] init]; + + FMDatabase *localdb = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + + [localdb setShouldCacheStatements:YES]; + if (![localdb open]) { + NSLog(@"Could not open db."); + //[db release]; + return nil; + } + + NSString *query = @"select routes.route_short_name, trips.route_id, trips.trip_headsign, trips.trip_id FROM routes, trips WHERE trips.route_id=routes.route_id"; + + FMResultSet *rs = [localdb executeQuery:query]; + while ([rs next]) { + // just print out what we've got in a number of formats. + NSMutableDictionary *route = [[NSMutableDictionary alloc] init]; + route[@"route_id"] = [rs objectForColumnName:@"route_id"]; + route[@"trip_headsign"] = [rs objectForColumnName:@"trip_headsign"]; + route[@"trip_id"] = [rs objectForColumnName:@"trip_id"]; + route[@"route_short_name"] = [rs objectForColumnName:@"route_short_name"]; + + + [routes addObject:route]; + + } + // close the result set. + [rs close]; + [localdb close]; + + return routes; + +} + + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Shape.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/Shape.h new file mode 100644 index 0000000..976a3b4 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/Shape.h @@ -0,0 +1,25 @@ +// +// Shape.h +// +// Created by Kevin Conley on 6/25/2013. +// + +#import +#import "FMDatabase.h" + + +@interface Shape : NSObject + +@property (nonatomic, strong) NSString * shapeId; +@property (nonatomic, strong) NSString * shapePtLat; +@property (nonatomic, strong) NSString * shapePtLon; +@property (nonatomic, strong) NSNumber * shapePtSequence; +@property (nonatomic, strong) NSNumber * shapeDistTraveled; + + +- (void)addShape:(Shape *)shape; +- (id)initWithDB:(FMDatabase *)fmdb; +- (void)cleanupAndCreate; +- (void)receiveRecord:(NSDictionary *)aRecord; + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Shape.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/Shape.m new file mode 100644 index 0000000..79612e7 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/Shape.m @@ -0,0 +1,104 @@ +// +// Shape.m +// +// Created by Kevin Conley on 6/25/2013. +// + +#import "Shape.h" +#import "CSVParser.h" +#import "FMDatabase.h" +#import "Util.h" + +@interface Shape () +{ + FMDatabase *db; +} + +@end + +@implementation Shape + +- (id)initWithDB:(FMDatabase *)fmdb +{ + self = [super init]; + if (self) + { + db = fmdb; + } + return self; +} + +- (void)addShape:(Shape *)shape +{ + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + [db executeUpdate:@"INSERT into shapes(shape_id,shape_pt_lat,shape_pt_lon,shape_pt_sequence,shape_dist_traveled) values(?, ?, ?, ?, ?)", + shape.shapeId, + shape.shapePtLat, + shape.shapePtLon, + shape.shapePtSequence, + shape.shapeDistTraveled]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } + +} + +- (void)cleanupAndCreate +{ + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + //Drop table if it exists + NSString *dropShape = @"DROP TABLE IF EXISTS shapes"; + + [db executeUpdate:dropShape]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } + + //Create table + NSString *createShape = @"CREATE TABLE 'shapes' ('shape_id' TEXT NOT NULL, 'shape_pt_lat' decimal(9,6) DEFAULT NULL, 'shape_pt_lon' decimal(9,6) DEFAULT NULL, 'shape_pt_sequence' INTEGER NOT NULL, 'shape_dist_traveled' decimal(9,6) DEFAULT NULL)"; + + NSString *createIndex = @"CREATE INDEX shape_id_shape ON shapes(shape_id)"; + + [db executeUpdate:createShape]; + [db executeUpdate:createIndex]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } +} + +- (void)receiveRecord:(NSDictionary *)aRecord +{ + + Shape *shapeRecord = [[Shape alloc] init]; + shapeRecord.shapeId = aRecord[@"shape_id"]; + shapeRecord.shapePtLat = aRecord[@"shape_pt_lat"]; + shapeRecord.shapePtLon = aRecord[@"shape_pt_lon"]; + shapeRecord.shapePtSequence = aRecord[@"shape_pt_sequence"]; + shapeRecord.shapeDistTraveled = aRecord[@"shape_dist_traveled"]; + + [self addShape:shapeRecord]; +} + + + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Stop.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/Stop.h new file mode 100644 index 0000000..b8423bc --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/Stop.h @@ -0,0 +1,30 @@ +// +// Stop.h +// GTFS-VTA +// +// Created by Vashishtha Jogi on 7/31/11. +// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. +// + +#import +#import "FMDatabase.h" + +@interface Stop : NSObject + +@property (nonatomic, strong) NSNumber * stopLat; +@property (nonatomic, strong) NSNumber * stopLon; +@property (nonatomic, strong) NSString * stopId; +@property (nonatomic, strong) NSString * stopName; +@property (nonatomic, strong) NSString * stopDesc; +@property (nonatomic, strong) NSNumber * locationType; +@property (nonatomic, strong) NSString * zoneId; +@property (nonatomic, strong) NSArray * routes; + +- (void)addStop:(Stop *)stop; +- (id)initWithDB:(FMDatabase *)fmdb; +- (void)cleanupAndCreate; +- (void)receiveRecord:(NSDictionary *)aRecord; +- (void)updateStopWithRoutes:(NSArray *)routes withStopId:(NSString *)stopId; +- (void)updateRoutes; + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Stop.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/Stop.m new file mode 100644 index 0000000..0d60c2a --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/Stop.m @@ -0,0 +1,162 @@ +// +// Stop.m +// GTFS-VTA +// +// Created by Vashishtha Jogi on 7/31/11. +// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. +// + +#import "Stop.h" +#import "FMDatabase.h" +#import "CSVParser.h" +#import "Route.h" +#import "StopTime.h" +#import "Util.h" + +@interface Stop () +{ + FMDatabase *db; +} + +@end + +@implementation Stop + +- (id)initWithDB:(FMDatabase *)fmdb +{ + self = [super init]; + if (self) + { + db = fmdb; + } + return self; +} + +- (void)addStop:(Stop *)stop +{ + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + [db executeUpdate:@"INSERT into stops(stop_lat,zone_id,stop_lon,stop_id,stop_desc,stop_name,location_type) values(?, ?, ?, ?, ?, ?, ?)", + stop.stopLat, + stop.zoneId, + stop.stopLon, + stop.stopId, + stop.stopDesc, + stop.stopName, + stop.locationType]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } +} + +- (void)cleanupAndCreate +{ + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + //Drop table if it exists + NSString *drop = @"DROP TABLE IF EXISTS stops"; + + [db executeUpdate:drop]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } + + //Create table + NSString *create = @"CREATE TABLE 'stops' ('stop_lat' decimal(8,6) DEFAULT NULL, 'zone_id' TEXT DEFAULT NULL, 'stop_lon' decimal(9,6) DEFAULT NULL, 'stop_id' TEXT NOT NULL, 'stop_desc' TEXT DEFAULT NULL, 'stop_name' TEXT DEFAULT NULL, 'location_type' int(2) DEFAULT NULL, 'routes' TEXT DEFAULT NULL, PRIMARY KEY ('stop_id'))"; + + NSString *createIndex = @"CREATE INDEX stop_lat_lon_stops ON stops(stop_lat, stop_lon)"; + + [db executeUpdate:create]; + [db executeUpdate:createIndex]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } +} + +- (void)receiveRecord:(NSDictionary *)aRecord +{ + Stop *stopRecord = [[Stop alloc] init]; + stopRecord.stopId = aRecord[@"stop_id"]; + stopRecord.stopLat = aRecord[@"stop_lat"]; + stopRecord.stopLon = aRecord[@"stop_lon"]; + stopRecord.stopName = [aRecord[@"stop_name"] localizedCapitalizedString]; + stopRecord.stopDesc = aRecord[@"stop_desc"]; + stopRecord.zoneId = aRecord[@"zone_id"]; + stopRecord.locationType = aRecord[@"location_type"]; + + [self addStop:stopRecord]; +} + +- (void)updateStopWithRoutes:(NSArray *)route withStopId:(NSString *)stopId +{ + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + NSString *routeString = [route componentsJoinedByString:@", "]; + + [db executeUpdate:@"UPDATE stops SET routes=? where stop_id=?", + routeString, + stopId]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } +} + +- (void)updateRoutes +{ + @autoreleasepool { + NSMutableDictionary *stopWithRoutes = [[NSMutableDictionary alloc] init]; + //First get all unique route trips + Route *route = [[Route alloc] init]; + NSArray *routeArray = [route getAllRoutes]; + StopTime *stopTime = [[StopTime alloc] init]; + + for (NSDictionary *route in routeArray) { + NSArray *stops = [stopTime getStopsForTripId:route[@"trip_id"]]; + for (NSString *stopId in stops) { + if (stopWithRoutes[stopId]==nil) { + [stopWithRoutes setValue:[[NSMutableArray alloc] init] forKey:stopId]; + } + if ([stopWithRoutes[stopId] containsObject:route[@"route_short_name"]] == NO) { + [stopWithRoutes[stopId] addObject:route[@"route_short_name"]]; + } + } + } + + + // NSLog(@"%@, %lu", stopWithRoutes, [stopWithRoutes count]); + + for (NSString *key in [stopWithRoutes allKeys]) { +// NSLog(@"%@ - %@", key, [[stopWithRoutes objectForKey:key] componentsJoinedByString:@","]); + [self updateStopWithRoutes:stopWithRoutes[key] withStopId:key]; + } + } +} + + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/StopTime.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/StopTime.h new file mode 100644 index 0000000..25ef6d7 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/StopTime.h @@ -0,0 +1,33 @@ +// +// StopTime.h +// GTFS-VTA +// +// Created by Vashishtha Jogi on 7/31/11. +// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. +// + +#import +#import "FMDatabase.h" + +@interface StopTime : NSObject + +@property (nonatomic, strong) NSString *arrivalTime; +@property (nonatomic, strong) NSString *departureTime; +@property (nonatomic, strong) NSNumber *stopSequence; +@property (nonatomic, strong) NSString *tripId; +@property (nonatomic, strong) NSString *stopId; +@property (nonatomic, strong) NSNumber *isTimepoint; +@property (nonatomic, strong) NSNumber *isLastStop; + +- (void)addStopTime:(StopTime *)stopTime; +- (id)initWithDB:(FMDatabase *)fmdb; +- (void)cleanupAndCreate; +- (void)receiveRecord:(NSDictionary *)aRecord; +- (NSArray *)getStopsForTripId:(NSString *)tripId; +- (void)interpolateStopTimes; +- (NSArray *)getTimeInterpolatedStopTimesByTripId:(NSString *)tripId; +- (NSArray *)getStopTimesByTripId:(NSString *)tripId; +- (void)updateStopTimes:(NSArray *)interpolatedStopTimes; + + +@end \ No newline at end of file diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/StopTime.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/StopTime.m new file mode 100644 index 0000000..dfc0e94 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/StopTime.m @@ -0,0 +1,292 @@ +// +// StopTime.m +// GTFS-VTA +// +// Created by Vashishtha Jogi on 7/31/11. +// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. +// + +#import "StopTime.h" +#import "Trip.h" +#import "FMDatabase.h" +#import "CSVParser.h" +#import "Util.h" + +@interface StopTime () +{ + FMDatabase *db; +} + +@end + +@implementation StopTime + +- (id)initWithDB:(FMDatabase *)fmdb +{ + self = [super init]; + if (self) + { + db = fmdb; + } + return self; +} + +- (NSSet *)getStopTimeObjects:(NSNumber *)stop_id { + return nil; +} + +- (void)addStopTime:(StopTime *)stopTime +{ + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + [db executeUpdate:@"INSERT into stop_times(trip_id,arrival_time,departure_time,stop_id,stop_sequence) values(?, ?, ?, ?, ?)", + stopTime.tripId, + stopTime.arrivalTime, + stopTime.departureTime, + stopTime.stopId, + stopTime.stopSequence]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } +} + +- (void)cleanupAndCreate +{ + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + //Drop table if it exists + NSString *drop = @"DROP TABLE IF EXISTS stop_times"; + + [db executeUpdate:drop]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } + + //Create table + NSString *create = @"CREATE TABLE 'stop_times' ('trip_id' TEXT DEFAULT NULL, 'arrival_time' time DEFAULT NULL, 'departure_time' time DEFAULT NULL, 'stop_id' TEXT DEFAULT NULL, 'stop_sequence' int(11) DEFAULT NULL, 'is_timepoint' tinyint(1) DEFAULT NULL, 'is_laststop' tinyint(1) DEFAULT NULL )"; + + NSString *createIndex = @"CREATE INDEX stop_id_stop_times ON stop_times(stop_id)"; + NSString *createIndex1 = @"CREATE INDEX trip_id_stop_times ON stop_times(trip_id)"; + + [db executeUpdate:create]; + [db executeUpdate:createIndex]; + [db executeUpdate:createIndex1]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } +} + +- (void)receiveRecord:(NSDictionary *)aRecord +{ + StopTime *stopTimeRecord = [[StopTime alloc] init]; + stopTimeRecord.tripId = aRecord[@"trip_id"]; + stopTimeRecord.departureTime = aRecord[@"departure_time"]; + stopTimeRecord.arrivalTime = aRecord[@"arrival_time"]; + stopTimeRecord.stopId = aRecord[@"stop_id"]; + stopTimeRecord.stopSequence = aRecord[@"stop_sequence"]; + + [self addStopTime:stopTimeRecord]; +} + +- (NSArray *)getStopsForTripId:(NSString *)tripId +{ + NSMutableArray *stops = [[NSMutableArray alloc] init]; + + FMDatabase *localdb = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + + [localdb setShouldCacheStatements:YES]; + if (![localdb open]) { + NSLog(@"Could not open db."); + //[db release]; + return nil; + } + + NSString *query = @"SELECT stop_id FROM stop_times WHERE trip_id=?"; + + FMResultSet *rs = [localdb executeQuery:query, tripId]; + while ([rs next]) { + [stops addObject:[rs stringForColumn:@"stop_id"]]; + } + // close the result set. + [rs close]; + [localdb close]; + + // NSLog(@"getStopTimesByTripId %d", [stop_times count]); + return stops; +} + +- (void)interpolateStopTimes +{ + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + //First get all trip ids + Trip *trip = [[Trip alloc] init]; + NSArray *tripIds = [trip getAllTripIds]; + + //for each trip id interpolate stop times and update database + for (NSString *tripId in tripIds) { + [self updateStopTimes:[self getTimeInterpolatedStopTimesByTripId:tripId]]; + } +} + +- (NSArray *)getTimeInterpolatedStopTimesByTripId:(NSString *)tripId +{ + NSMutableArray *stop_times_i = [[NSMutableArray alloc] init]; + + NSArray *stop_times = [self getStopTimesByTripId:tripId]; + // If there are no stoptimes [] is the correct return value but if the start + // or end are missing times there is no correct return value. + if (stop_times==nil || [stop_times count]==0) + return nil; + + NSMutableDictionary *cur_timepoint=nil; + NSMutableDictionary *next_timepoint = nil; + double distance_between_timepoints = 0; + double distance_traveled_between_timepoints = 0; + + for (int i=0; i < [stop_times count]; i++) + { + NSMutableDictionary *st = stop_times[i]; + if (st[@"arrival_time"] != nil && ![st[@"arrival_time"] isEqualToString:@""]) + { + cur_timepoint = st; + distance_between_timepoints = 0; + distance_traveled_between_timepoints = 0; + if (i + 1 < [stop_times count]) + { + int k = i + 1; + distance_between_timepoints += [Util ApproximateDistanceWithLat1:[stop_times[k-1][@"stop_lat"] doubleValue] + withLon1:[stop_times[k-1][@"stop_lon"] doubleValue] + withLat2:[stop_times[k][@"stop_lat"] doubleValue] + withLon2:[stop_times[k][@"stop_lon"] doubleValue]]; + while (stop_times[k][@"arrival_time"] == nil || [stop_times[k][@"arrival_time"] isEqualToString:@""]) + { + k += 1; + distance_between_timepoints += [Util ApproximateDistanceWithLat1:[stop_times[k-1][@"stop_lat"] doubleValue] + withLon1:[stop_times[k-1][@"stop_lon"] doubleValue] + withLat2:[stop_times[k][@"stop_lat"] doubleValue] + withLon2:[stop_times[k][@"stop_lon"] doubleValue]]; + } + next_timepoint = stop_times[k]; + } + NSMutableDictionary *temp_dict = [[NSMutableDictionary alloc] init]; + temp_dict[@"arrival_time"] = [Util TimeToSecondsSinceMidnight:st[@"arrival_time"]]; + temp_dict[@"stop_id"] = st[@"stop_id"]; + temp_dict[@"trip_id"] = st[@"trip_id"]; + temp_dict[@"stop_sequence"] = st[@"stop_sequence"]; + temp_dict[@"is_timepoint"] = @YES; + temp_dict[@"is_laststop"] = @NO; + [stop_times_i addObject:temp_dict]; + } + else + { + distance_traveled_between_timepoints += [Util ApproximateDistanceWithLat1:[stop_times[i-1][@"stop_lat"] doubleValue] + withLon1:[stop_times[i-1][@"stop_lon"] doubleValue] + withLat2:[st[@"stop_lat"] doubleValue] + withLon2:[st[@"stop_lon"] doubleValue]]; + float distance_percent = distance_traveled_between_timepoints / distance_between_timepoints; + int next_time = [[Util TimeToSecondsSinceMidnight:next_timepoint[@"arrival_time"]] intValue]; + int cur_time = [[Util TimeToSecondsSinceMidnight:cur_timepoint[@"arrival_time"]] intValue]; + int total_time = next_time - cur_time; +// NSLog(@"next- %d, cur - %d, total - %d, cur_timepoint- %@, D: %f, %f", next_time, cur_time, total_time, [cur_timepoint objectForKey:@"arrival_time"], distance_between_timepoints, distance_traveled_between_timepoints); + float time_estimate = distance_percent * total_time + [[Util TimeToSecondsSinceMidnight:cur_timepoint[@"arrival_time"]] intValue]; + NSMutableDictionary *temp_dict = [[NSMutableDictionary alloc] init]; + temp_dict[@"arrival_time"] = @((int)round(time_estimate)); + temp_dict[@"stop_id"] = st[@"stop_id"]; + temp_dict[@"trip_id"] = st[@"trip_id"]; + temp_dict[@"stop_sequence"] = st[@"stop_sequence"]; + temp_dict[@"is_timepoint"] = @NO; + temp_dict[@"is_laststop"] = @NO; + [stop_times_i addObject:temp_dict]; + } + } + + // update the last one + [stop_times_i lastObject][@"is_laststop"] = @YES; + + // NSLog(@"getTimeInterpolatedStopTimesByTripId %d", [stop_times_i count]); + return stop_times_i; +} + +- (NSArray *)getStopTimesByTripId:(NSString *)tripId +{ + NSMutableArray *stop_times = [[NSMutableArray alloc] init]; + + NSString *query = @"SELECT stops.stop_lat, stops.stop_lon, stop_times.trip_id, stop_times.arrival_time, stop_times.stop_id, stop_times.stop_sequence FROM stop_times, stops WHERE stop_times.trip_id=? AND stops.stop_id=stop_times.stop_id ORDER BY stop_times.stop_sequence"; + + FMResultSet *rs = [db executeQuery:query, tripId]; + while ([rs next]) { + // just print out what we've got in a number of formats. + NSMutableDictionary *stop_time = [[NSMutableDictionary alloc] init]; + + stop_time[@"stop_lat"] = [rs objectForColumnName:@"stop_lat"]; + stop_time[@"stop_lon"] = [rs objectForColumnName:@"stop_lon"]; + stop_time[@"stop_id"] = [rs objectForColumnName:@"stop_id"]; + stop_time[@"trip_id"] = [rs objectForColumnName:@"trip_id"]; + stop_time[@"arrival_time"] = [rs objectForColumnName:@"arrival_time"]; + stop_time[@"stop_sequence"] = [rs objectForColumnName:@"stop_sequence"]; + + [stop_times addObject:stop_time]; + } + // close the result set. + [rs close]; + // NSLog(@"getStopTimesByTripId %d", [stop_times count]); + return stop_times; +} + +- (void)updateStopTimes:(NSArray *)interpolatedStopTimes +{ + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + [db beginTransaction]; + + for (NSDictionary *stopTime in interpolatedStopTimes) { + [db executeUpdate:@"UPDATE stop_times SET arrival_time=?, is_timepoint=?, is_laststop=? WHERE trip_id=? AND stop_id=? AND stop_sequence=?", + [Util FormatSecondsSinceMidnight:stopTime[@"arrival_time"]], + stopTime[@"is_timepoint"], + stopTime[@"is_laststop"], + stopTime[@"trip_id"], + stopTime[@"stop_id"], + stopTime[@"stop_sequence"]]; + } + + [db commit]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } +} + + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Transformations.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/Transformations.h new file mode 100644 index 0000000..0534fd3 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/Transformations.h @@ -0,0 +1,16 @@ +// +// Transformations.h +// San Jose Transit GTFS +// +// Created by Vashishtha Jogi on 8/26/11. +// Copyright 2011 Vashishtha Jogi Inc. All rights reserved. +// + +#import +#import "FMDatabase.h" + +@interface Transformations : NSObject + +-(void) applyTransformationsFromCSV; + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Transformations.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/Transformations.m new file mode 100644 index 0000000..8154289 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/Transformations.m @@ -0,0 +1,71 @@ +// +// Transformations.m +// San Jose Transit GTFS +// +// Created by Vashishtha Jogi on 8/26/11. +// Copyright 2011 Vashishtha Jogi Inc. All rights reserved. +// + +#import "Transformations.h" +#import "FMDatabase.h" +#import "CSVParser.h" +#import "Util.h" + +@interface Transformations () +{ + FMDatabase *db; +} + +@end + +@implementation Transformations + +-(void) applyTransformationsFromCSV +{ + //Open db connection first + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + + NSError *error = nil; + + NSString *inputPath = [Util getTransformationsFilePath]; + NSString *csvString = [NSString stringWithContentsOfFile:inputPath encoding:NSUTF8StringEncoding error:&error]; + + if (!csvString) + { + NSLog(@"Couldn't read file at path %s\n. Error: %s", [inputPath UTF8String], [[error localizedDescription] ? [error localizedDescription] : [error description] UTF8String]); + exit(1); + } + + NSDate *startDate = [NSDate date]; + + CSVParser *parser =[[CSVParser alloc] initWithString:csvString separator:@";" hasHeader:NO fieldNames:nil]; + NSArray *parsed = [parser arrayOfParsedRows]; + + + + for (NSDictionary *record in parsed) + { + for(int i=0;i<[record count];i++) + { + [db beginTransaction]; + [db executeUpdate:[record valueForKey:[NSString stringWithFormat:@"FIELD_%d", i+1]]]; + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + } + [db commit]; + } + } + + NSDate *endDate = [NSDate date]; + + NSLog(@"Transformations successfully done in %f seconds.", [endDate timeIntervalSinceDate:startDate]); + + [db close]; +} + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Trip.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/Trip.h new file mode 100644 index 0000000..83eb432 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/Trip.h @@ -0,0 +1,28 @@ +// +// Trip.h +// GTFS-VTA +// +// Created by Vashishtha Jogi on 7/31/11. +// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. +// + +#import +#import "FMDatabase.h" + +@interface Trip : NSObject + +@property (nonatomic, strong) NSString *tripHeadsign; +@property (nonatomic, strong) NSString *tripId; +@property (nonatomic, strong) NSString *routeId; +@property (nonatomic, strong) NSString *serviceId; +@property (nonatomic, strong) NSString *blockId; +@property (nonatomic, strong) NSNumber *directionId; +@property (nonatomic, strong) NSString *shapeId; + +- (void)addTrip:(Trip *)trip; +- (id)initWithDB:(FMDatabase *)fmdb; +- (void)cleanupAndCreate; +- (void)receiveRecord:(NSDictionary *)aRecord; +- (NSArray *)getAllTripIds; + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Trip.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/Trip.m new file mode 100644 index 0000000..4a77ecd --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Model/Trip.m @@ -0,0 +1,152 @@ +// +// Trip.m +// GTFS-VTA +// +// Created by Vashishtha Jogi on 7/31/11. +// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. +// + +#import "Trip.h" +#import "FMDatabase.h" +#import "CSVParser.h" +#import "Util.h" + +@interface Trip () +{ + FMDatabase *db; +} + +@end + +@implementation Trip + +- (id) initWithDB:(FMDatabase *)fmdb +{ + self = [super init]; + if (self) + { + db = fmdb; + } + return self; +} + +- (void)addTrip:(Trip *)trip +{ + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + [db executeUpdate:@"INSERT into trips(block_id,route_id,direction_id,trip_headsign,service_id,trip_id,shape_id) values(?, ?, ?, ?, ?, ?, ?)", + trip.blockId, + trip.routeId, + trip.directionId, + trip.tripHeadsign, + trip.serviceId, + trip.tripId, + trip.shapeId]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } +} + +- (void)cleanupAndCreate +{ + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + return; + } + } + + //Drop table if it exists + NSString *drop = @"DROP TABLE IF EXISTS trips"; + + [db executeUpdate:drop]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } + + //Create table + NSString *create = @"CREATE TABLE 'trips' ('block_id' TEXT DEFAULT NULL, 'route_id' TEXT DEFAULT NULL, 'direction_id' tinyint(1) DEFAULT NULL, 'trip_headsign' TEXT DEFAULT NULL, 'service_id' TEXT DEFAULT NULL, 'trip_id' TEXT NOT NULL, 'shape_id' TEXT NOT NULL, PRIMARY KEY ('trip_id'))"; + + NSString *createIndex = @"CREATE INDEX route_id_trips ON trips(route_id)"; + + [db executeUpdate:create]; + [db executeUpdate:createIndex]; + + if ([db hadError]) { + NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); + return; + } +} + +- (void)receiveRecord:(NSDictionary *)aRecord +{ + Trip *tripRecord = [[Trip alloc] init]; + tripRecord.blockId = aRecord[@"block_id"]; + tripRecord.routeId = aRecord[@"route_id"]; + tripRecord.serviceId = aRecord[@"service_id"]; + tripRecord.tripId = aRecord[@"trip_id"]; + tripRecord.shapeId = aRecord[@"shape_id"]; + + if (aRecord[@"trip_headsign"]) { + NSString *headsign = [[[aRecord[@"trip_headsign"] localizedCapitalizedString] stringByReplacingOccurrencesOfString:aRecord[@"route_id"] withString:@""] stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]]; + tripRecord.tripHeadsign = headsign; + } + + // if direction_id is empty, try to derive it + if ([aRecord[@"direction_id"] length] == 0) { + if ([aRecord[@"trip_headsign"] rangeOfString:@"NB"].location != NSNotFound || [aRecord[@"trip_headsign"] rangeOfString:@"WB"].location != NSNotFound) { + tripRecord.directionId = @0; + } else if ([aRecord[@"trip_headsign"] rangeOfString:@"SB"].location != NSNotFound || [aRecord[@"trip_headsign"] rangeOfString:@"EB"].location != NSNotFound) { + tripRecord.directionId = @1; + } else { + tripRecord.directionId = @2; + } + } else { + tripRecord.directionId = aRecord[@"direction_id"]; + } + + [self addTrip:tripRecord]; +} + +- (NSArray *)getAllTripIds +{ + NSMutableArray *tripIds = [[NSMutableArray alloc] init]; + + if (db==nil) { + db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; + if (![db open]) { + NSLog(@"Could not open db."); + db = nil; + return nil; + } + + db.shouldCacheStatements=YES; + } + + NSString *query = @"SELECT trip_id from trips"; + + FMResultSet *rs = [db executeQuery:query]; + while ([rs next]) { + [tripIds addObject:[rs objectForColumnName:@"trip_id"]]; + } + // close the result set. + [rs close]; + [db close]; + + // NSLog(@"getStopTimesByTripId %d", [stop_times count]); + return tripIds; +} + + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Util.h b/iOS/GTFSImporteriOS/GTFSImporter/Util.h new file mode 100644 index 0000000..83b86a3 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Util.h @@ -0,0 +1,29 @@ +// +// Util.h +// GTFSImporter +// +// Created by Vashishtha Jogi on 9/7/11. +// Copyright 2011 Vashishtha Jogi. All rights reserved. +// + +#import +#import "Stop.h" + +@interface Util : NSObject + ++ (NSString *) getTransitFilesBasepath; ++ (NSString *) getTransformationsFilePath; ++ (NSString *) getDatabasePath; ++ (double) ApproximateDistanceWithLat1:(double)lat1 withLon1:(double)lon1 withLat2:(double)lat2 withLon2:(double)lon2; ++ (double) ApproximateDistanceBetweenStop1:(Stop *)stop1 stop2:(Stop *)stop2; ++ (NSNumber *) TimeToSecondsSinceMidnight:(NSString *)time; ++ (NSString *) FormatSecondsSinceMidnight:(NSNumber *)seconds; ++ (NSString *) getDayFromDate:(NSDate *)date; ++ (NSString *) getDateStringFromDate:(NSDate *)date withFormat:(NSString *)format; ++ (NSString *) getTimeStringFromDate:(NSDate *)date withFormat:(NSString *)format; + ++ (void) setTransitFilesBasepath:(NSString *)transitFilesBasepath; ++ (void) setTransformationsFilePath:(NSString *)transformationsFilePath; ++ (void) setDatabasePath:(NSString *)databasePath; + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Util.m b/iOS/GTFSImporteriOS/GTFSImporter/Util.m new file mode 100644 index 0000000..7325653 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/Util.m @@ -0,0 +1,181 @@ +// +// Util.m +// GTFSImporter +// +// Created by Vashishtha Jogi on 9/7/11. +// Copyright 2011 Vashishtha Jogi. All rights reserved. +// + +#import "Util.h" + +#define kEarthRadius 6378135 //in meters + +@implementation Util + +static NSString *kTransitFilesBasepath; +static NSString *kTransformationsFilePath; +static NSString *kDatabasePath; + ++ (void)initialize +{ + if (self == [Util class]) { + kTransitFilesBasepath = @"~/Desktop/gtfs_source"; + kTransformationsFilePath = @"~/Desktop/gtfs_transformations.txt"; + kDatabasePath = @"~/Desktop/gtfs.db"; + } +} + +/* + This is root directory where all the gtfs files live. This directory will contain agency.txt, routes.txt, etc. + */ ++ (NSString *) getTransitFilesBasepath +{ + return [kTransitFilesBasepath stringByExpandingTildeInPath]; +} + ++ (void) setTransitFilesBasepath:(NSString *)transitFilesBasepath +{ + kTransitFilesBasepath = transitFilesBasepath; +} + +/* + This is something new. After your data is imported, sqlite queries from this file will be executed on the imported data. You may want to delete any extraneous trips, or delete all trips before a certain date, etc. This is a comma separeted file with all queries. For an example see transformations.txt. If you dont need to apply any transformations, leave the file empty. Or if you dont want to apply the transformations just comment out the transformations call in main.m file. + */ ++ (NSString *) getTransformationsFilePath +{ + return [kTransformationsFilePath stringByExpandingTildeInPath]; +} + ++ (void) setTransformationsFilePath:(NSString *)transformationsFilePath +{ + kTransformationsFilePath = transformationsFilePath; +} + +/* + The path where the database will be created. The file is created for you if it does not exist. But the directory in which the file will be created needs to pre-exist. + */ ++ (NSString *) getDatabasePath +{ + return [kDatabasePath stringByExpandingTildeInPath]; +} + ++ (void) setDatabasePath:(NSString *)databasePath +{ + kDatabasePath = databasePath; +} + +/*Compute approximate distance between two points in meters. Assumes the + Earth is a sphere. + # TODO: change to ellipsoid approximation, such as + # http://www.codeguru.com/Cpp/Cpp/algorithms/article.php/c5115/ + */ ++ (double) ApproximateDistanceWithLat1:(double)lat1 withLon1:(double)lon1 withLat2:(double)lat2 withLon2:(double)lon2 +{ + lat1 = lat1 * M_PI/180; + lon1 = lon1 * M_PI/180; + lat2 = lat2 * M_PI/180; + lon2 = lon2 * M_PI/180; + + double dlat = sin(0.5 * (lat2 - lat1)); + double dlng = sin(0.5 * (lon2 - lon1)); + double x = dlat * dlat + dlng * dlng * cos(lat1) * cos(lat2); + + return kEarthRadius * (2 * atan2(sqrt(x), sqrt(MAX(0.0, 1.0 - x)))); +} + +//Compute approximate distance between two stops in meters. Assumes the +//Earth is a sphere. + ++ (double) ApproximateDistanceBetweenStop1:(Stop *)stop1 stop2:(Stop *)stop2 +{ + return [Util ApproximateDistanceWithLat1:[stop1.stopLat doubleValue] withLon1:[stop1.stopLon doubleValue] + withLat2:[stop2.stopLat doubleValue] withLon2:[stop2.stopLon doubleValue]]; +} + +/* + Convert HHH:MM:SS into seconds since midnight. + + For example "01:02:03" returns 3723. The leading zero of the hours may be + omitted. HH may be more than 23 if the time is on the following day. + */ + ++ (NSNumber *) TimeToSecondsSinceMidnight:(NSString *)time +{ + NSArray *timeArray = [time componentsSeparatedByString:@":"]; + return @([timeArray[0] intValue] * 3600 + [timeArray[1] intValue] * 60 + [timeArray[2] intValue]);; +} + +// Formats an int number of seconds past midnight into a string as "HH:MM:SS". + ++ (NSString *) FormatSecondsSinceMidnight:(NSNumber *)seconds +{ + int s = [seconds intValue]; + return [NSString stringWithFormat:@"%02d:%02d:%02d", s / 3600, (s / 60) % 60, s % 60]; +} + ++ (NSString *) getDayFromDate:(NSDate *)date +{ + // setting units we would like to use in future + unsigned units = NSYearCalendarUnit | NSMonthCalendarUnit | NSDayCalendarUnit | NSWeekdayCalendarUnit; + // creating NSCalendar object + NSCalendar *calendar = [[NSCalendar alloc] initWithCalendarIdentifier:NSGregorianCalendar]; + // extracting components from date + NSDateComponents *components = [calendar components:units fromDate:date]; + + + switch ([components weekday]) { + case 1: + return @"sunday"; + break; + case 2: + return @"monday"; + break; + case 3: + return @"tuesday"; + break; + case 4: + return @"wednesday"; + break; + case 5: + return @"thursday"; + break; + case 6: + return @"friday"; + break; + case 7: + return @"saturday"; + break; + default: + return @""; + break; + } +} + +//Converts NSDate to specified format, Default yyyy-MM-dd if nil is passed for format ++ (NSString *) getDateStringFromDate:(NSDate *)date withFormat:(NSString *)format +{ + NSDateFormatter *sDateFormatter = [[NSDateFormatter alloc] init]; + if (format==nil) + [sDateFormatter setDateFormat:@"yyyy-MM-dd"]; + else + [sDateFormatter setDateFormat:format]; + + return [sDateFormatter stringFromDate:date]; + +} + +//Converts NSDate to specified format, Default hh:mm:ss if nil is passed for format ++ (NSString *) getTimeStringFromDate:(NSDate *)date withFormat:(NSString *)format +{ + NSDateFormatter *sDateFormatter = [[NSDateFormatter alloc] init]; + if (format==nil) + [sDateFormatter setDateFormat:@"HH:mm:ss"]; + else + [sDateFormatter setDateFormat:format]; + + return [sDateFormatter stringFromDate:date]; + +} + + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/main.m b/iOS/GTFSImporteriOS/GTFSImporter/main.m new file mode 100644 index 0000000..85428d2 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporter/main.m @@ -0,0 +1,101 @@ +// +// main.m +// GTFSImporter +// +// Created by Vashishtha Jogi on 8/27/11. +// Copyright 2011 Vashishtha Jogi. All rights reserved. +// + +#import +#import "CSVImporter.h" +#import "Util.h" + +int main (int argc, const char * argv[]) +{ + NSLog(@"Originally built by Vashishtha Jogi -> https://github.com/jvashishtha."); + NSLog(@"Modified by Connect Think LLC -> www.connectthink.com "); + NSLog(@"Source available at https://github.com/ConnectThink/GTFSImporter"); + NSLog(@"========================="); + + // SET PATH OVERRIDES + if (argc >= 2) { + NSString *sourcePath = [NSString stringWithUTF8String:argv[1]]; + [Util setTransitFilesBasepath:sourcePath]; + } + + if (argc >= 3) { + NSString *destinationPath = [NSString stringWithUTF8String:argv[2]]; + [Util setDatabasePath:destinationPath]; + } + + // IMPORT + CSVImporter *importer = [[CSVImporter alloc] init]; + + NSLog(@"Importing Agency..."); + [importer addAgency]; + + + NSLog(@"Importing Fare Attributes..."); + [importer addFareAttributes]; + + + NSLog(@"Importing Fare Rules..."); + [importer addFareRules]; + + + NSLog(@"Importing Calendar..."); + [importer addCalendar]; + + + NSLog(@"Importing Calendar Dates..."); + [importer addCalendarDate]; + + + NSLog(@"Importing Routes..."); + [importer addRoute]; + + + NSLog(@"Importing Stops..."); + [importer addStop]; + + + NSLog(@"Importing Trips..."); + [importer addTrip]; + + + NSLog(@"Importing Shapes..."); + [importer addShape]; + + + NSLog(@"Importing StopTime..."); + [importer addStopTime]; + + //Comment this out if you dont want to apply any transformations + //NSLog(@"Sanitizing data..."); + //[importer sanitizeData]; + + NSLog(@"Vacumming..."); + [importer vacuum]; + + + NSLog(@"Reindexing..."); + [importer reindex]; + + + //For convinience. This will add and extra column routes which will contain comma seperated route numbers passing through this stop + NSLog(@"Adding routes to stops..."); + [importer addStopRoutes]; + + NSLog(@"Interpolating stop times"); + [importer addInterpolatedStopTime]; + + NSLog(@"Vacumming..."); + [importer vacuum]; + + NSLog(@"Reindexing..."); + [importer reindex]; + + NSLog(@"Import complete!"); + + return 0; +} diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS.xcodeproj/project.pbxproj b/iOS/GTFSImporteriOS/GTFSImporteriOS.xcodeproj/project.pbxproj new file mode 100644 index 0000000..7230159 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS.xcodeproj/project.pbxproj @@ -0,0 +1,630 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 47; + objects = { + +/* Begin PBXBuildFile section */ + 93BA29111D83EDFC008674E7 /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29101D83EDFC008674E7 /* main.m */; }; + 93BA29141D83EDFC008674E7 /* AppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29131D83EDFC008674E7 /* AppDelegate.m */; }; + 93BA29171D83EDFC008674E7 /* ViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29161D83EDFC008674E7 /* ViewController.m */; }; + 93BA291A1D83EDFC008674E7 /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 93BA29181D83EDFC008674E7 /* Main.storyboard */; }; + 93BA291C1D83EDFC008674E7 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 93BA291B1D83EDFC008674E7 /* Assets.xcassets */; }; + 93BA291F1D83EDFC008674E7 /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 93BA291D1D83EDFC008674E7 /* LaunchScreen.storyboard */; }; + 93BA29271D83EF09008674E7 /* GTFSImporter in Resources */ = {isa = PBXBuildFile; fileRef = 93BA29261D83EF09008674E7 /* GTFSImporter */; }; + 93BA292A1D83EF8B008674E7 /* GTFS Caltrain Devs.zip in Resources */ = {isa = PBXBuildFile; fileRef = 93BA29291D83EF8B008674E7 /* GTFS Caltrain Devs.zip */; }; + 93BA29531D83F0B1008674E7 /* aescrypt.c in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29301D83F0B1008674E7 /* aescrypt.c */; }; + 93BA29541D83F0B1008674E7 /* aeskey.c in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29311D83F0B1008674E7 /* aeskey.c */; }; + 93BA29551D83F0B1008674E7 /* aestab.c in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29331D83F0B1008674E7 /* aestab.c */; }; + 93BA29561D83F0B1008674E7 /* entropy.c in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29371D83F0B1008674E7 /* entropy.c */; }; + 93BA29571D83F0B1008674E7 /* fileenc.c in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29391D83F0B1008674E7 /* fileenc.c */; }; + 93BA29581D83F0B1008674E7 /* hmac.c in Sources */ = {isa = PBXBuildFile; fileRef = 93BA293B1D83F0B1008674E7 /* hmac.c */; }; + 93BA29591D83F0B1008674E7 /* prng.c in Sources */ = {isa = PBXBuildFile; fileRef = 93BA293D1D83F0B1008674E7 /* prng.c */; }; + 93BA295A1D83F0B1008674E7 /* pwd2key.c in Sources */ = {isa = PBXBuildFile; fileRef = 93BA293F1D83F0B1008674E7 /* pwd2key.c */; }; + 93BA295B1D83F0B1008674E7 /* sha1.c in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29411D83F0B1008674E7 /* sha1.c */; }; + 93BA295C1D83F0B1008674E7 /* Info.plist in Resources */ = {isa = PBXBuildFile; fileRef = 93BA29431D83F0B1008674E7 /* Info.plist */; }; + 93BA295D1D83F0B1008674E7 /* ioapi.c in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29461D83F0B1008674E7 /* ioapi.c */; }; + 93BA295E1D83F0B1008674E7 /* mztools.c in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29481D83F0B1008674E7 /* mztools.c */; }; + 93BA295F1D83F0B1008674E7 /* unzip.c in Sources */ = {isa = PBXBuildFile; fileRef = 93BA294A1D83F0B1008674E7 /* unzip.c */; }; + 93BA29601D83F0B1008674E7 /* zip.c in Sources */ = {isa = PBXBuildFile; fileRef = 93BA294C1D83F0B1008674E7 /* zip.c */; }; + 93BA29621D83F0B1008674E7 /* SSZipArchive.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29501D83F0B1008674E7 /* SSZipArchive.m */; }; + 93BA29641D83F149008674E7 /* libz.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 93BA29631D83F149008674E7 /* libz.tbd */; }; + 93BA29941D83F84D008674E7 /* CSVImporter.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29681D83F84D008674E7 /* CSVImporter.m */; }; + 93BA29951D83F84D008674E7 /* GTFSImporter.1 in Resources */ = {isa = PBXBuildFile; fileRef = 93BA296A1D83F84D008674E7 /* GTFSImporter.1 */; }; + 93BA29961D83F84D008674E7 /* CSVParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA296E1D83F84D008674E7 /* CSVParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; }; + 93BA29971D83F84D008674E7 /* FMDatabase.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29711D83F84D008674E7 /* FMDatabase.m */; }; + 93BA29981D83F84D008674E7 /* FMDatabaseAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29731D83F84D008674E7 /* FMDatabaseAdditions.m */; }; + 93BA29991D83F84D008674E7 /* FMDatabasePool.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29751D83F84D008674E7 /* FMDatabasePool.m */; }; + 93BA299A1D83F84D008674E7 /* FMDatabaseQueue.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29771D83F84D008674E7 /* FMDatabaseQueue.m */; }; + 93BA299B1D83F84D008674E7 /* FMResultSet.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29791D83F84D008674E7 /* FMResultSet.m */; }; + 93BA299D1D83F84D008674E7 /* Agency.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA297D1D83F84D008674E7 /* Agency.m */; }; + 93BA299E1D83F84D008674E7 /* Calendar.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA297F1D83F84D008674E7 /* Calendar.m */; }; + 93BA299F1D83F84D008674E7 /* CalendarDate.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29811D83F84D008674E7 /* CalendarDate.m */; }; + 93BA29A01D83F84D008674E7 /* FareAttributes.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29831D83F84D008674E7 /* FareAttributes.m */; }; + 93BA29A11D83F84D008674E7 /* FareRules.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29851D83F84D008674E7 /* FareRules.m */; }; + 93BA29A21D83F84D008674E7 /* Route.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29871D83F84D008674E7 /* Route.m */; }; + 93BA29A31D83F84D008674E7 /* Shape.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29891D83F84D008674E7 /* Shape.m */; }; + 93BA29A41D83F84D008674E7 /* Stop.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA298B1D83F84D008674E7 /* Stop.m */; }; + 93BA29A51D83F84D008674E7 /* StopTime.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA298D1D83F84D008674E7 /* StopTime.m */; }; + 93BA29A61D83F84D008674E7 /* Transformations.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA298F1D83F84D008674E7 /* Transformations.m */; }; + 93BA29A71D83F84D008674E7 /* Trip.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29911D83F84D008674E7 /* Trip.m */; }; + 93BA29A81D83F84D008674E7 /* Util.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29931D83F84D008674E7 /* Util.m */; }; + 93BA29AA1D83F98B008674E7 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 93BA29A91D83F98B008674E7 /* Foundation.framework */; }; + 93BA29AC1D83F9B0008674E7 /* libsqlite3.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 93BA29AB1D83F9B0008674E7 /* libsqlite3.tbd */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 93BA290C1D83EDFC008674E7 /* GTFSImporteriOS.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = GTFSImporteriOS.app; sourceTree = BUILT_PRODUCTS_DIR; }; + 93BA29101D83EDFC008674E7 /* main.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = ""; }; + 93BA29121D83EDFC008674E7 /* AppDelegate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AppDelegate.h; sourceTree = ""; }; + 93BA29131D83EDFC008674E7 /* AppDelegate.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = AppDelegate.m; sourceTree = ""; }; + 93BA29151D83EDFC008674E7 /* ViewController.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ViewController.h; sourceTree = ""; }; + 93BA29161D83EDFC008674E7 /* ViewController.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = ViewController.m; sourceTree = ""; }; + 93BA29191D83EDFC008674E7 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = ""; }; + 93BA291B1D83EDFC008674E7 /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = ""; }; + 93BA291E1D83EDFC008674E7 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = ""; }; + 93BA29201D83EDFC008674E7 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; + 93BA29261D83EF09008674E7 /* GTFSImporter */ = {isa = PBXFileReference; lastKnownFileType = folder; name = GTFSImporter; path = "/Users/aaron/Dropbox/Programming/Projects/Open Source/GTFSImporter/GTFSImporter"; sourceTree = ""; }; + 93BA29291D83EF8B008674E7 /* GTFS Caltrain Devs.zip */ = {isa = PBXFileReference; lastKnownFileType = archive.zip; path = "GTFS Caltrain Devs.zip"; sourceTree = ""; }; + 93BA292E1D83F0B1008674E7 /* aes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = aes.h; sourceTree = ""; }; + 93BA292F1D83F0B1008674E7 /* aes_via_ace.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = aes_via_ace.h; sourceTree = ""; }; + 93BA29301D83F0B1008674E7 /* aescrypt.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = aescrypt.c; sourceTree = ""; }; + 93BA29311D83F0B1008674E7 /* aeskey.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = aeskey.c; sourceTree = ""; }; + 93BA29321D83F0B1008674E7 /* aesopt.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = aesopt.h; sourceTree = ""; }; + 93BA29331D83F0B1008674E7 /* aestab.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = aestab.c; sourceTree = ""; }; + 93BA29341D83F0B1008674E7 /* aestab.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = aestab.h; sourceTree = ""; }; + 93BA29351D83F0B1008674E7 /* brg_endian.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = brg_endian.h; sourceTree = ""; }; + 93BA29361D83F0B1008674E7 /* brg_types.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = brg_types.h; sourceTree = ""; }; + 93BA29371D83F0B1008674E7 /* entropy.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = entropy.c; sourceTree = ""; }; + 93BA29381D83F0B1008674E7 /* entropy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = entropy.h; sourceTree = ""; }; + 93BA29391D83F0B1008674E7 /* fileenc.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = fileenc.c; sourceTree = ""; }; + 93BA293A1D83F0B1008674E7 /* fileenc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fileenc.h; sourceTree = ""; }; + 93BA293B1D83F0B1008674E7 /* hmac.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = hmac.c; sourceTree = ""; }; + 93BA293C1D83F0B1008674E7 /* hmac.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = hmac.h; sourceTree = ""; }; + 93BA293D1D83F0B1008674E7 /* prng.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = prng.c; sourceTree = ""; }; + 93BA293E1D83F0B1008674E7 /* prng.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = prng.h; sourceTree = ""; }; + 93BA293F1D83F0B1008674E7 /* pwd2key.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = pwd2key.c; sourceTree = ""; }; + 93BA29401D83F0B1008674E7 /* pwd2key.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pwd2key.h; sourceTree = ""; }; + 93BA29411D83F0B1008674E7 /* sha1.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = sha1.c; sourceTree = ""; }; + 93BA29421D83F0B1008674E7 /* sha1.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sha1.h; sourceTree = ""; }; + 93BA29431D83F0B1008674E7 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; + 93BA29451D83F0B1008674E7 /* crypt.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = crypt.h; sourceTree = ""; }; + 93BA29461D83F0B1008674E7 /* ioapi.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = ioapi.c; sourceTree = ""; }; + 93BA29471D83F0B1008674E7 /* ioapi.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ioapi.h; sourceTree = ""; }; + 93BA29481D83F0B1008674E7 /* mztools.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = mztools.c; sourceTree = ""; }; + 93BA29491D83F0B1008674E7 /* mztools.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mztools.h; sourceTree = ""; }; + 93BA294A1D83F0B1008674E7 /* unzip.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = unzip.c; sourceTree = ""; }; + 93BA294B1D83F0B1008674E7 /* unzip.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = unzip.h; sourceTree = ""; }; + 93BA294C1D83F0B1008674E7 /* zip.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = zip.c; sourceTree = ""; }; + 93BA294D1D83F0B1008674E7 /* zip.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = zip.h; sourceTree = ""; }; + 93BA294F1D83F0B1008674E7 /* SSZipArchive.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SSZipArchive.h; sourceTree = ""; }; + 93BA29501D83F0B1008674E7 /* SSZipArchive.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SSZipArchive.m; sourceTree = ""; }; + 93BA29511D83F0B1008674E7 /* SSZipCommon.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SSZipCommon.h; sourceTree = ""; }; + 93BA29521D83F0B1008674E7 /* ZipArchive.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZipArchive.h; sourceTree = ""; }; + 93BA29631D83F149008674E7 /* libz.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libz.tbd; path = usr/lib/libz.tbd; sourceTree = SDKROOT; }; + 93BA29671D83F84D008674E7 /* CSVImporter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSVImporter.h; sourceTree = ""; }; + 93BA29681D83F84D008674E7 /* CSVImporter.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CSVImporter.m; sourceTree = ""; }; + 93BA29691D83F84D008674E7 /* GTFSImporter-Prefix.pch */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "GTFSImporter-Prefix.pch"; sourceTree = ""; }; + 93BA296A1D83F84D008674E7 /* GTFSImporter.1 */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.man; path = GTFSImporter.1; sourceTree = ""; }; + 93BA296D1D83F84D008674E7 /* CSVParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSVParser.h; sourceTree = ""; }; + 93BA296E1D83F84D008674E7 /* CSVParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CSVParser.m; sourceTree = ""; }; + 93BA29701D83F84D008674E7 /* FMDatabase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FMDatabase.h; sourceTree = ""; }; + 93BA29711D83F84D008674E7 /* FMDatabase.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FMDatabase.m; sourceTree = ""; }; + 93BA29721D83F84D008674E7 /* FMDatabaseAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FMDatabaseAdditions.h; sourceTree = ""; }; + 93BA29731D83F84D008674E7 /* FMDatabaseAdditions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FMDatabaseAdditions.m; sourceTree = ""; }; + 93BA29741D83F84D008674E7 /* FMDatabasePool.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FMDatabasePool.h; sourceTree = ""; }; + 93BA29751D83F84D008674E7 /* FMDatabasePool.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FMDatabasePool.m; sourceTree = ""; }; + 93BA29761D83F84D008674E7 /* FMDatabaseQueue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FMDatabaseQueue.h; sourceTree = ""; }; + 93BA29771D83F84D008674E7 /* FMDatabaseQueue.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FMDatabaseQueue.m; sourceTree = ""; }; + 93BA29781D83F84D008674E7 /* FMResultSet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FMResultSet.h; sourceTree = ""; }; + 93BA29791D83F84D008674E7 /* FMResultSet.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FMResultSet.m; sourceTree = ""; }; + 93BA297A1D83F84D008674E7 /* main.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = ""; }; + 93BA297C1D83F84D008674E7 /* Agency.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Agency.h; sourceTree = ""; }; + 93BA297D1D83F84D008674E7 /* Agency.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Agency.m; sourceTree = ""; }; + 93BA297E1D83F84D008674E7 /* Calendar.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Calendar.h; sourceTree = ""; }; + 93BA297F1D83F84D008674E7 /* Calendar.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Calendar.m; sourceTree = ""; }; + 93BA29801D83F84D008674E7 /* CalendarDate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CalendarDate.h; sourceTree = ""; }; + 93BA29811D83F84D008674E7 /* CalendarDate.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CalendarDate.m; sourceTree = ""; }; + 93BA29821D83F84D008674E7 /* FareAttributes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FareAttributes.h; sourceTree = ""; }; + 93BA29831D83F84D008674E7 /* FareAttributes.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FareAttributes.m; sourceTree = ""; }; + 93BA29841D83F84D008674E7 /* FareRules.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FareRules.h; sourceTree = ""; }; + 93BA29851D83F84D008674E7 /* FareRules.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FareRules.m; sourceTree = ""; }; + 93BA29861D83F84D008674E7 /* Route.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Route.h; sourceTree = ""; }; + 93BA29871D83F84D008674E7 /* Route.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Route.m; sourceTree = ""; }; + 93BA29881D83F84D008674E7 /* Shape.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Shape.h; sourceTree = ""; }; + 93BA29891D83F84D008674E7 /* Shape.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Shape.m; sourceTree = ""; }; + 93BA298A1D83F84D008674E7 /* Stop.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Stop.h; sourceTree = ""; }; + 93BA298B1D83F84D008674E7 /* Stop.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Stop.m; sourceTree = ""; }; + 93BA298C1D83F84D008674E7 /* StopTime.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StopTime.h; sourceTree = ""; }; + 93BA298D1D83F84D008674E7 /* StopTime.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = StopTime.m; sourceTree = ""; }; + 93BA298E1D83F84D008674E7 /* Transformations.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Transformations.h; sourceTree = ""; }; + 93BA298F1D83F84D008674E7 /* Transformations.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Transformations.m; sourceTree = ""; }; + 93BA29901D83F84D008674E7 /* Trip.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Trip.h; sourceTree = ""; }; + 93BA29911D83F84D008674E7 /* Trip.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Trip.m; sourceTree = ""; }; + 93BA29921D83F84D008674E7 /* Util.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Util.h; sourceTree = ""; }; + 93BA29931D83F84D008674E7 /* Util.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Util.m; sourceTree = ""; }; + 93BA29A91D83F98B008674E7 /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = System/Library/Frameworks/Foundation.framework; sourceTree = SDKROOT; }; + 93BA29AB1D83F9B0008674E7 /* libsqlite3.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libsqlite3.tbd; path = usr/lib/libsqlite3.tbd; sourceTree = SDKROOT; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 93BA29091D83EDFC008674E7 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 93BA29AC1D83F9B0008674E7 /* libsqlite3.tbd in Frameworks */, + 93BA29AA1D83F98B008674E7 /* Foundation.framework in Frameworks */, + 93BA29641D83F149008674E7 /* libz.tbd in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 93BA29031D83EDFC008674E7 = { + isa = PBXGroup; + children = ( + 93BA29AB1D83F9B0008674E7 /* libsqlite3.tbd */, + 93BA29A91D83F98B008674E7 /* Foundation.framework */, + 93BA29631D83F149008674E7 /* libz.tbd */, + 93BA29661D83F84D008674E7 /* GTFSImporter */, + 93BA290E1D83EDFC008674E7 /* GTFSImporteriOS */, + 93BA290D1D83EDFC008674E7 /* Products */, + ); + sourceTree = ""; + }; + 93BA290D1D83EDFC008674E7 /* Products */ = { + isa = PBXGroup; + children = ( + 93BA290C1D83EDFC008674E7 /* GTFSImporteriOS.app */, + ); + name = Products; + sourceTree = ""; + }; + 93BA290E1D83EDFC008674E7 /* GTFSImporteriOS */ = { + isa = PBXGroup; + children = ( + 93BA292B1D83F0B1008674E7 /* External Libraries */, + 93BA29281D83EF8B008674E7 /* Resources */, + 93BA29121D83EDFC008674E7 /* AppDelegate.h */, + 93BA29131D83EDFC008674E7 /* AppDelegate.m */, + 93BA29151D83EDFC008674E7 /* ViewController.h */, + 93BA29161D83EDFC008674E7 /* ViewController.m */, + 93BA29181D83EDFC008674E7 /* Main.storyboard */, + 93BA291B1D83EDFC008674E7 /* Assets.xcassets */, + 93BA291D1D83EDFC008674E7 /* LaunchScreen.storyboard */, + 93BA29201D83EDFC008674E7 /* Info.plist */, + 93BA290F1D83EDFC008674E7 /* Supporting Files */, + ); + path = GTFSImporteriOS; + sourceTree = ""; + }; + 93BA290F1D83EDFC008674E7 /* Supporting Files */ = { + isa = PBXGroup; + children = ( + 93BA29101D83EDFC008674E7 /* main.m */, + ); + name = "Supporting Files"; + sourceTree = ""; + }; + 93BA29281D83EF8B008674E7 /* Resources */ = { + isa = PBXGroup; + children = ( + 93BA29291D83EF8B008674E7 /* GTFS Caltrain Devs.zip */, + ); + path = Resources; + sourceTree = ""; + }; + 93BA292B1D83F0B1008674E7 /* External Libraries */ = { + isa = PBXGroup; + children = ( + 93BA292C1D83F0B1008674E7 /* SSZipArchive */, + ); + path = "External Libraries"; + sourceTree = ""; + }; + 93BA292C1D83F0B1008674E7 /* SSZipArchive */ = { + isa = PBXGroup; + children = ( + 93BA292D1D83F0B1008674E7 /* aes */, + 93BA29431D83F0B1008674E7 /* Info.plist */, + 93BA29441D83F0B1008674E7 /* minizip */, + 93BA294F1D83F0B1008674E7 /* SSZipArchive.h */, + 93BA29501D83F0B1008674E7 /* SSZipArchive.m */, + 93BA29511D83F0B1008674E7 /* SSZipCommon.h */, + 93BA29521D83F0B1008674E7 /* ZipArchive.h */, + ); + path = SSZipArchive; + sourceTree = ""; + }; + 93BA292D1D83F0B1008674E7 /* aes */ = { + isa = PBXGroup; + children = ( + 93BA292E1D83F0B1008674E7 /* aes.h */, + 93BA292F1D83F0B1008674E7 /* aes_via_ace.h */, + 93BA29301D83F0B1008674E7 /* aescrypt.c */, + 93BA29311D83F0B1008674E7 /* aeskey.c */, + 93BA29321D83F0B1008674E7 /* aesopt.h */, + 93BA29331D83F0B1008674E7 /* aestab.c */, + 93BA29341D83F0B1008674E7 /* aestab.h */, + 93BA29351D83F0B1008674E7 /* brg_endian.h */, + 93BA29361D83F0B1008674E7 /* brg_types.h */, + 93BA29371D83F0B1008674E7 /* entropy.c */, + 93BA29381D83F0B1008674E7 /* entropy.h */, + 93BA29391D83F0B1008674E7 /* fileenc.c */, + 93BA293A1D83F0B1008674E7 /* fileenc.h */, + 93BA293B1D83F0B1008674E7 /* hmac.c */, + 93BA293C1D83F0B1008674E7 /* hmac.h */, + 93BA293D1D83F0B1008674E7 /* prng.c */, + 93BA293E1D83F0B1008674E7 /* prng.h */, + 93BA293F1D83F0B1008674E7 /* pwd2key.c */, + 93BA29401D83F0B1008674E7 /* pwd2key.h */, + 93BA29411D83F0B1008674E7 /* sha1.c */, + 93BA29421D83F0B1008674E7 /* sha1.h */, + ); + path = aes; + sourceTree = ""; + }; + 93BA29441D83F0B1008674E7 /* minizip */ = { + isa = PBXGroup; + children = ( + 93BA29451D83F0B1008674E7 /* crypt.h */, + 93BA29461D83F0B1008674E7 /* ioapi.c */, + 93BA29471D83F0B1008674E7 /* ioapi.h */, + 93BA29481D83F0B1008674E7 /* mztools.c */, + 93BA29491D83F0B1008674E7 /* mztools.h */, + 93BA294A1D83F0B1008674E7 /* unzip.c */, + 93BA294B1D83F0B1008674E7 /* unzip.h */, + 93BA294C1D83F0B1008674E7 /* zip.c */, + 93BA294D1D83F0B1008674E7 /* zip.h */, + ); + path = minizip; + sourceTree = ""; + }; + 93BA29661D83F84D008674E7 /* GTFSImporter */ = { + isa = PBXGroup; + children = ( + 93BA29671D83F84D008674E7 /* CSVImporter.h */, + 93BA29681D83F84D008674E7 /* CSVImporter.m */, + 93BA29691D83F84D008674E7 /* GTFSImporter-Prefix.pch */, + 93BA296A1D83F84D008674E7 /* GTFSImporter.1 */, + 93BA296B1D83F84D008674E7 /* Libraries */, + 93BA297A1D83F84D008674E7 /* main.m */, + 93BA297B1D83F84D008674E7 /* Model */, + 93BA29921D83F84D008674E7 /* Util.h */, + 93BA29931D83F84D008674E7 /* Util.m */, + ); + path = GTFSImporter; + sourceTree = ""; + }; + 93BA296B1D83F84D008674E7 /* Libraries */ = { + isa = PBXGroup; + children = ( + 93BA296C1D83F84D008674E7 /* CSVParser */, + 93BA296F1D83F84D008674E7 /* SQLite */, + ); + path = Libraries; + sourceTree = ""; + }; + 93BA296C1D83F84D008674E7 /* CSVParser */ = { + isa = PBXGroup; + children = ( + 93BA296D1D83F84D008674E7 /* CSVParser.h */, + 93BA296E1D83F84D008674E7 /* CSVParser.m */, + ); + path = CSVParser; + sourceTree = ""; + }; + 93BA296F1D83F84D008674E7 /* SQLite */ = { + isa = PBXGroup; + children = ( + 93BA29701D83F84D008674E7 /* FMDatabase.h */, + 93BA29711D83F84D008674E7 /* FMDatabase.m */, + 93BA29721D83F84D008674E7 /* FMDatabaseAdditions.h */, + 93BA29731D83F84D008674E7 /* FMDatabaseAdditions.m */, + 93BA29741D83F84D008674E7 /* FMDatabasePool.h */, + 93BA29751D83F84D008674E7 /* FMDatabasePool.m */, + 93BA29761D83F84D008674E7 /* FMDatabaseQueue.h */, + 93BA29771D83F84D008674E7 /* FMDatabaseQueue.m */, + 93BA29781D83F84D008674E7 /* FMResultSet.h */, + 93BA29791D83F84D008674E7 /* FMResultSet.m */, + ); + path = SQLite; + sourceTree = ""; + }; + 93BA297B1D83F84D008674E7 /* Model */ = { + isa = PBXGroup; + children = ( + 93BA297C1D83F84D008674E7 /* Agency.h */, + 93BA297D1D83F84D008674E7 /* Agency.m */, + 93BA297E1D83F84D008674E7 /* Calendar.h */, + 93BA297F1D83F84D008674E7 /* Calendar.m */, + 93BA29801D83F84D008674E7 /* CalendarDate.h */, + 93BA29811D83F84D008674E7 /* CalendarDate.m */, + 93BA29821D83F84D008674E7 /* FareAttributes.h */, + 93BA29831D83F84D008674E7 /* FareAttributes.m */, + 93BA29841D83F84D008674E7 /* FareRules.h */, + 93BA29851D83F84D008674E7 /* FareRules.m */, + 93BA29861D83F84D008674E7 /* Route.h */, + 93BA29871D83F84D008674E7 /* Route.m */, + 93BA29881D83F84D008674E7 /* Shape.h */, + 93BA29891D83F84D008674E7 /* Shape.m */, + 93BA298A1D83F84D008674E7 /* Stop.h */, + 93BA298B1D83F84D008674E7 /* Stop.m */, + 93BA298C1D83F84D008674E7 /* StopTime.h */, + 93BA298D1D83F84D008674E7 /* StopTime.m */, + 93BA298E1D83F84D008674E7 /* Transformations.h */, + 93BA298F1D83F84D008674E7 /* Transformations.m */, + 93BA29901D83F84D008674E7 /* Trip.h */, + 93BA29911D83F84D008674E7 /* Trip.m */, + ); + path = Model; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 93BA290B1D83EDFC008674E7 /* GTFSImporteriOS */ = { + isa = PBXNativeTarget; + buildConfigurationList = 93BA29231D83EDFC008674E7 /* Build configuration list for PBXNativeTarget "GTFSImporteriOS" */; + buildPhases = ( + 93BA29081D83EDFC008674E7 /* Sources */, + 93BA29091D83EDFC008674E7 /* Frameworks */, + 93BA290A1D83EDFC008674E7 /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = GTFSImporteriOS; + productName = GTFSImporteriOS; + productReference = 93BA290C1D83EDFC008674E7 /* GTFSImporteriOS.app */; + productType = "com.apple.product-type.application"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 93BA29041D83EDFC008674E7 /* Project object */ = { + isa = PBXProject; + attributes = { + LastUpgradeCheck = 0730; + ORGANIZATIONNAME = "Aaron Jubbal"; + TargetAttributes = { + 93BA290B1D83EDFC008674E7 = { + CreatedOnToolsVersion = 7.3.1; + }; + }; + }; + buildConfigurationList = 93BA29071D83EDFC008674E7 /* Build configuration list for PBXProject "GTFSImporteriOS" */; + compatibilityVersion = "Xcode 6.3"; + developmentRegion = English; + hasScannedForEncodings = 0; + knownRegions = ( + en, + Base, + ); + mainGroup = 93BA29031D83EDFC008674E7; + productRefGroup = 93BA290D1D83EDFC008674E7 /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + 93BA290B1D83EDFC008674E7 /* GTFSImporteriOS */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + 93BA290A1D83EDFC008674E7 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 93BA292A1D83EF8B008674E7 /* GTFS Caltrain Devs.zip in Resources */, + 93BA291F1D83EDFC008674E7 /* LaunchScreen.storyboard in Resources */, + 93BA29951D83F84D008674E7 /* GTFSImporter.1 in Resources */, + 93BA295C1D83F0B1008674E7 /* Info.plist in Resources */, + 93BA291C1D83EDFC008674E7 /* Assets.xcassets in Resources */, + 93BA29271D83EF09008674E7 /* GTFSImporter in Resources */, + 93BA291A1D83EDFC008674E7 /* Main.storyboard in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 93BA29081D83EDFC008674E7 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 93BA295B1D83F0B1008674E7 /* sha1.c in Sources */, + 93BA295D1D83F0B1008674E7 /* ioapi.c in Sources */, + 93BA29A41D83F84D008674E7 /* Stop.m in Sources */, + 93BA29A21D83F84D008674E7 /* Route.m in Sources */, + 93BA29621D83F0B1008674E7 /* SSZipArchive.m in Sources */, + 93BA29971D83F84D008674E7 /* FMDatabase.m in Sources */, + 93BA29591D83F0B1008674E7 /* prng.c in Sources */, + 93BA29991D83F84D008674E7 /* FMDatabasePool.m in Sources */, + 93BA29A71D83F84D008674E7 /* Trip.m in Sources */, + 93BA299B1D83F84D008674E7 /* FMResultSet.m in Sources */, + 93BA29981D83F84D008674E7 /* FMDatabaseAdditions.m in Sources */, + 93BA295A1D83F0B1008674E7 /* pwd2key.c in Sources */, + 93BA299E1D83F84D008674E7 /* Calendar.m in Sources */, + 93BA29961D83F84D008674E7 /* CSVParser.m in Sources */, + 93BA295E1D83F0B1008674E7 /* mztools.c in Sources */, + 93BA29571D83F0B1008674E7 /* fileenc.c in Sources */, + 93BA295F1D83F0B1008674E7 /* unzip.c in Sources */, + 93BA299A1D83F84D008674E7 /* FMDatabaseQueue.m in Sources */, + 93BA29171D83EDFC008674E7 /* ViewController.m in Sources */, + 93BA29551D83F0B1008674E7 /* aestab.c in Sources */, + 93BA29A31D83F84D008674E7 /* Shape.m in Sources */, + 93BA29601D83F0B1008674E7 /* zip.c in Sources */, + 93BA29A01D83F84D008674E7 /* FareAttributes.m in Sources */, + 93BA29141D83EDFC008674E7 /* AppDelegate.m in Sources */, + 93BA29A51D83F84D008674E7 /* StopTime.m in Sources */, + 93BA29941D83F84D008674E7 /* CSVImporter.m in Sources */, + 93BA29A81D83F84D008674E7 /* Util.m in Sources */, + 93BA299F1D83F84D008674E7 /* CalendarDate.m in Sources */, + 93BA29A11D83F84D008674E7 /* FareRules.m in Sources */, + 93BA29531D83F0B1008674E7 /* aescrypt.c in Sources */, + 93BA29111D83EDFC008674E7 /* main.m in Sources */, + 93BA29A61D83F84D008674E7 /* Transformations.m in Sources */, + 93BA29581D83F0B1008674E7 /* hmac.c in Sources */, + 93BA29541D83F0B1008674E7 /* aeskey.c in Sources */, + 93BA299D1D83F84D008674E7 /* Agency.m in Sources */, + 93BA29561D83F0B1008674E7 /* entropy.c in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXVariantGroup section */ + 93BA29181D83EDFC008674E7 /* Main.storyboard */ = { + isa = PBXVariantGroup; + children = ( + 93BA29191D83EDFC008674E7 /* Base */, + ); + name = Main.storyboard; + sourceTree = ""; + }; + 93BA291D1D83EDFC008674E7 /* LaunchScreen.storyboard */ = { + isa = PBXVariantGroup; + children = ( + 93BA291E1D83EDFC008674E7 /* Base */, + ); + name = LaunchScreen.storyboard; + sourceTree = ""; + }; +/* End PBXVariantGroup section */ + +/* Begin XCBuildConfiguration section */ + 93BA29211D83EDFC008674E7 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_ANALYZER_NONNULL = YES; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_DYNAMIC_NO_PIC = NO; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 9.3; + MTL_ENABLE_DEBUG_INFO = YES; + ONLY_ACTIVE_ARCH = YES; + SDKROOT = iphoneos; + TARGETED_DEVICE_FAMILY = "1,2"; + }; + name = Debug; + }; + 93BA29221D83EDFC008674E7 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_ANALYZER_NONNULL = YES; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 9.3; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = iphoneos; + TARGETED_DEVICE_FAMILY = "1,2"; + VALIDATE_PRODUCT = YES; + }; + name = Release; + }; + 93BA29241D83EDFC008674E7 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + INFOPLIST_FILE = GTFSImporteriOS/Info.plist; + LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks"; + PRODUCT_BUNDLE_IDENTIFIER = com.sample.GTFSImporteriOS; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + 93BA29251D83EDFC008674E7 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + INFOPLIST_FILE = GTFSImporteriOS/Info.plist; + LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks"; + PRODUCT_BUNDLE_IDENTIFIER = com.sample.GTFSImporteriOS; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 93BA29071D83EDFC008674E7 /* Build configuration list for PBXProject "GTFSImporteriOS" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 93BA29211D83EDFC008674E7 /* Debug */, + 93BA29221D83EDFC008674E7 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 93BA29231D83EDFC008674E7 /* Build configuration list for PBXNativeTarget "GTFSImporteriOS" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 93BA29241D83EDFC008674E7 /* Debug */, + 93BA29251D83EDFC008674E7 /* Release */, + ); + defaultConfigurationIsVisible = 0; + }; +/* End XCConfigurationList section */ + }; + rootObject = 93BA29041D83EDFC008674E7 /* Project object */; +} diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/AppDelegate.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/AppDelegate.h new file mode 100644 index 0000000..c21b431 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/AppDelegate.h @@ -0,0 +1,17 @@ +// +// AppDelegate.h +// GTFSImporteriOS +// +// Created by Aaron Jubbal on 9/10/16. +// Copyright © 2016 Aaron Jubbal. All rights reserved. +// + +#import + +@interface AppDelegate : UIResponder + +@property (strong, nonatomic) UIWindow *window; + + +@end + diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/AppDelegate.m b/iOS/GTFSImporteriOS/GTFSImporteriOS/AppDelegate.m new file mode 100644 index 0000000..a599e31 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/AppDelegate.m @@ -0,0 +1,133 @@ +// +// AppDelegate.m +// GTFSImporteriOS +// +// Created by Aaron Jubbal on 9/10/16. +// Copyright © 2016 Aaron Jubbal. All rights reserved. +// + +#import "AppDelegate.h" +#import "ZipArchive.h" +#import "CSVImporter.h" +#import "Util.h" + +@interface AppDelegate () + +@end + +@implementation AppDelegate + +- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions { + // Override point for customization after application launch. + NSString *sourcePath = [[NSBundle mainBundle] pathForResource:@"GTFS Caltrain Devs" ofType:@"zip"]; + NSString *libraryDirectory = [NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask, YES) firstObject]; + NSError *error = nil; + NSString *destinationPath = libraryDirectory; + [[NSFileManager defaultManager] createDirectoryAtPath:destinationPath + withIntermediateDirectories:YES attributes:nil error:&error]; + if (error) { + NSLog(@"error occured while creating directory! %@", error); + } + [SSZipArchive unzipFileAtPath:sourcePath toDestination:destinationPath]; + + NSString *gtfsSourcePath = [destinationPath stringByAppendingPathComponent:@"GTFS Caltrain Devs"]; + [Util setTransitFilesBasepath:gtfsSourcePath]; + [Util setDatabasePath:[gtfsSourcePath stringByAppendingPathComponent:@"gtfs.db"]]; + + // IMPORT + CSVImporter *importer = [[CSVImporter alloc] init]; + + NSLog(@"Importing Agency..."); + [importer addAgency]; + + + NSLog(@"Importing Fare Attributes..."); + [importer addFareAttributes]; + + + NSLog(@"Importing Fare Rules..."); + [importer addFareRules]; + + + NSLog(@"Importing Calendar..."); + [importer addCalendar]; + + + NSLog(@"Importing Calendar Dates..."); + [importer addCalendarDate]; + + + NSLog(@"Importing Routes..."); + [importer addRoute]; + + + NSLog(@"Importing Stops..."); + [importer addStop]; + + + NSLog(@"Importing Trips..."); + [importer addTrip]; + + + NSLog(@"Importing Shapes..."); + [importer addShape]; + + + NSLog(@"Importing StopTime..."); + [importer addStopTime]; + + //Comment this out if you dont want to apply any transformations + //NSLog(@"Sanitizing data..."); + //[importer sanitizeData]; + + NSLog(@"Vacumming..."); + [importer vacuum]; + + + NSLog(@"Reindexing..."); + [importer reindex]; + + + //For convinience. This will add and extra column routes which will contain comma seperated route numbers passing through this stop + NSLog(@"Adding routes to stops..."); + [importer addStopRoutes]; + + NSLog(@"Interpolating stop times"); + [importer addInterpolatedStopTime]; + + NSLog(@"Vacumming..."); + [importer vacuum]; + + NSLog(@"Reindexing..."); + [importer reindex]; + + NSLog(@"Import complete!"); + + NSLog(@"database written to: %@", gtfsSourcePath); + + return YES; +} + +- (void)applicationWillResignActive:(UIApplication *)application { + // Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state. + // Use this method to pause ongoing tasks, disable timers, and throttle down OpenGL ES frame rates. Games should use this method to pause the game. +} + +- (void)applicationDidEnterBackground:(UIApplication *)application { + // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later. + // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits. +} + +- (void)applicationWillEnterForeground:(UIApplication *)application { + // Called as part of the transition from the background to the inactive state; here you can undo many of the changes made on entering the background. +} + +- (void)applicationDidBecomeActive:(UIApplication *)application { + // Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface. +} + +- (void)applicationWillTerminate:(UIApplication *)application { + // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:. +} + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/Assets.xcassets/AppIcon.appiconset/Contents.json b/iOS/GTFSImporteriOS/GTFSImporteriOS/Assets.xcassets/AppIcon.appiconset/Contents.json new file mode 100644 index 0000000..36d2c80 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/Assets.xcassets/AppIcon.appiconset/Contents.json @@ -0,0 +1,68 @@ +{ + "images" : [ + { + "idiom" : "iphone", + "size" : "29x29", + "scale" : "2x" + }, + { + "idiom" : "iphone", + "size" : "29x29", + "scale" : "3x" + }, + { + "idiom" : "iphone", + "size" : "40x40", + "scale" : "2x" + }, + { + "idiom" : "iphone", + "size" : "40x40", + "scale" : "3x" + }, + { + "idiom" : "iphone", + "size" : "60x60", + "scale" : "2x" + }, + { + "idiom" : "iphone", + "size" : "60x60", + "scale" : "3x" + }, + { + "idiom" : "ipad", + "size" : "29x29", + "scale" : "1x" + }, + { + "idiom" : "ipad", + "size" : "29x29", + "scale" : "2x" + }, + { + "idiom" : "ipad", + "size" : "40x40", + "scale" : "1x" + }, + { + "idiom" : "ipad", + "size" : "40x40", + "scale" : "2x" + }, + { + "idiom" : "ipad", + "size" : "76x76", + "scale" : "1x" + }, + { + "idiom" : "ipad", + "size" : "76x76", + "scale" : "2x" + } + ], + "info" : { + "version" : 1, + "author" : "xcode" + } +} \ No newline at end of file diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/Base.lproj/LaunchScreen.storyboard b/iOS/GTFSImporteriOS/GTFSImporteriOS/Base.lproj/LaunchScreen.storyboard new file mode 100644 index 0000000..2e721e1 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/Base.lproj/LaunchScreen.storyboard @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/Base.lproj/Main.storyboard b/iOS/GTFSImporteriOS/GTFSImporteriOS/Base.lproj/Main.storyboard new file mode 100644 index 0000000..f56d2f3 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/Base.lproj/Main.storyboard @@ -0,0 +1,25 @@ + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/Info.plist b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/Info.plist new file mode 100755 index 0000000..d3de8ee --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/Info.plist @@ -0,0 +1,26 @@ + + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + FMWK + CFBundleShortVersionString + 1.0 + CFBundleSignature + ???? + CFBundleVersion + $(CURRENT_PROJECT_VERSION) + NSPrincipalClass + + + diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/SSZipArchive.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/SSZipArchive.h new file mode 100755 index 0000000..3931bc4 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/SSZipArchive.h @@ -0,0 +1,93 @@ +// +// SSZipArchive.h +// SSZipArchive +// +// Created by Sam Soffes on 7/21/10. +// Copyright (c) Sam Soffes 2010-2015. All rights reserved. +// + +#ifndef _SSZIPARCHIVE_H +#define _SSZIPARCHIVE_H + +#import +#include "SSZipCommon.h" + +NS_ASSUME_NONNULL_BEGIN + +@protocol SSZipArchiveDelegate; + +@interface SSZipArchive : NSObject + +// Password check ++ (BOOL)isFilePasswordProtectedAtPath:(NSString *)path; + +// Unzip ++ (BOOL)unzipFileAtPath:(NSString *)path toDestination:(NSString *)destination; ++ (BOOL)unzipFileAtPath:(NSString *)path toDestination:(NSString *)destination delegate:(nullable id)delegate; + ++ (BOOL)unzipFileAtPath:(NSString *)path toDestination:(NSString *)destination overwrite:(BOOL)overwrite password:(nullable NSString *)password error:(NSError * *)error; ++ (BOOL)unzipFileAtPath:(NSString *)path toDestination:(NSString *)destination overwrite:(BOOL)overwrite password:(nullable NSString *)password error:(NSError * *)error delegate:(nullable id)delegate NS_REFINED_FOR_SWIFT; + ++ (BOOL)unzipFileAtPath:(NSString *)path + toDestination:(NSString *)destination + preserveAttributes:(BOOL)preserveAttributes + overwrite:(BOOL)overwrite + password:(nullable NSString *)password + error:(NSError * *)error + delegate:(nullable id)delegate; + ++ (BOOL)unzipFileAtPath:(NSString *)path + toDestination:(NSString *)destination + progressHandler:(void (^)(NSString *entry, unz_file_info zipInfo, long entryNumber, long total))progressHandler + completionHandler:(void (^)(NSString *path, BOOL succeeded, NSError *error))completionHandler; + ++ (BOOL)unzipFileAtPath:(NSString *)path + toDestination:(NSString *)destination + overwrite:(BOOL)overwrite + password:(nullable NSString *)password + progressHandler:(void (^)(NSString *entry, unz_file_info zipInfo, long entryNumber, long total))progressHandler + completionHandler:(void (^)(NSString *path, BOOL succeeded, NSError *error))completionHandler; + +// Zip + +// without password ++ (BOOL)createZipFileAtPath:(NSString *)path withFilesAtPaths:(NSArray *)paths; ++ (BOOL)createZipFileAtPath:(NSString *)path withContentsOfDirectory:(NSString *)directoryPath; + ++ (BOOL)createZipFileAtPath:(NSString *)path withContentsOfDirectory:(NSString *)directoryPath keepParentDirectory:(BOOL)keepParentDirectory; + +// with password, password could be nil ++ (BOOL)createZipFileAtPath:(NSString *)path withFilesAtPaths:(NSArray *)paths withPassword:(nullable NSString *)password; ++ (BOOL)createZipFileAtPath:(NSString *)path withContentsOfDirectory:(NSString *)directoryPath withPassword:(nullable NSString *)password; ++ (BOOL)createZipFileAtPath:(NSString *)path withContentsOfDirectory:(NSString *)directoryPath keepParentDirectory:(BOOL)keepParentDirectory withPassword:(nullable NSString *)password; + +- (instancetype)initWithPath:(NSString *)path; +@property (NS_NONATOMIC_IOSONLY, readonly) BOOL open; +- (BOOL)writeFile:(NSString *)path withPassword:(nullable NSString *)password; +- (BOOL)writeFolderAtPath:(NSString *)path withFolderName:(NSString *)folderName withPassword:(nullable NSString *)password; +- (BOOL)writeFileAtPath:(NSString *)path withFileName:(nullable NSString *)fileName withPassword:(nullable NSString *)password; +- (BOOL)writeData:(NSData *)data filename:(nullable NSString *)filename withPassword:(nullable NSString *)password; +@property (NS_NONATOMIC_IOSONLY, readonly) BOOL close; + +@end + +@protocol SSZipArchiveDelegate + +@optional + +- (void)zipArchiveWillUnzipArchiveAtPath:(NSString *)path zipInfo:(unz_global_info)zipInfo; +- (void)zipArchiveDidUnzipArchiveAtPath:(NSString *)path zipInfo:(unz_global_info)zipInfo unzippedPath:(NSString *)unzippedPath; + +- (BOOL)zipArchiveShouldUnzipFileAtIndex:(NSInteger)fileIndex totalFiles:(NSInteger)totalFiles archivePath:(NSString *)archivePath fileInfo:(unz_file_info)fileInfo; +- (void)zipArchiveWillUnzipFileAtIndex:(NSInteger)fileIndex totalFiles:(NSInteger)totalFiles archivePath:(NSString *)archivePath fileInfo:(unz_file_info)fileInfo; +- (void)zipArchiveDidUnzipFileAtIndex:(NSInteger)fileIndex totalFiles:(NSInteger)totalFiles archivePath:(NSString *)archivePath fileInfo:(unz_file_info)fileInfo; +- (void)zipArchiveDidUnzipFileAtIndex:(NSInteger)fileIndex totalFiles:(NSInteger)totalFiles archivePath:(NSString *)archivePath unzippedFilePath:(NSString *)unzippedFilePath; + +- (void)zipArchiveProgressEvent:(unsigned long long)loaded total:(unsigned long long)total; +- (void)zipArchiveDidUnzipArchiveFile:(NSString *)zipFile entryPath:(NSString *)entryPath destPath:(NSString *)destPath; + +@end + +NS_ASSUME_NONNULL_END + +#endif /* _SSZIPARCHIVE_H */ diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/SSZipArchive.m b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/SSZipArchive.m new file mode 100755 index 0000000..d9c29b1 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/SSZipArchive.m @@ -0,0 +1,816 @@ +// +// 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" +#import "zlib.h" +#import "zconf.h" + +#include + +#define CHUNK 16384 + +@interface SSZipArchive () ++ (NSDate *)_dateWithMSDOSFormat:(UInt32)msdosDateTime; +@end + +@implementation SSZipArchive +{ + NSString *_path; + NSString *_filename; + zipFile _zip; +} + +#pragma mark - Password check + ++ (BOOL)isFilePasswordProtectedAtPath:(NSString *)path { + // Begin opening + zipFile zip = unzOpen((const char*)[path UTF8String]); + 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 ={0}; + 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 && UNZ_OK!=UNZ_END_OF_LIST_OF_FILE ); + + } + + return NO; +} + +#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 *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 (^)(NSString *entry, unz_file_info zipInfo, long entryNumber, long total))progressHandler + completionHandler:(void (^)(NSString *path, BOOL succeeded, NSError *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:(NSString *)password + error:(NSError **)error + delegate:(id)delegate + progressHandler:(void (^)(NSString *entry, unz_file_info zipInfo, long entryNumber, long total))progressHandler + completionHandler:(void (^)(NSString *path, BOOL succeeded, NSError *error))completionHandler +{ + // Begin opening + zipFile zip = unzOpen((const char*)[path UTF8String]); + if (zip == NULL) + { + NSDictionary *userInfo = @{NSLocalizedDescriptionKey: @"failed to open zip file"}; + NSError *err = [NSError errorWithDomain:@"SSZipArchiveErrorDomain" code:-1 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 = {0ul, 0ul}; + unzGetGlobalInfo(zip, &globalInfo); + + // Begin unzipping + if (unzGoToFirstFile(zip) != UNZ_OK) + { + NSDictionary *userInfo = @{NSLocalizedDescriptionKey: @"failed to open first file in zip file"}; + NSError *err = [NSError errorWithDomain:@"SSZipArchiveErrorDomain" code:-2 userInfo:userInfo]; + if (error) + { + *error = err; + } + if (completionHandler) + { + completionHandler(nil, NO, err); + } + return NO; + } + + BOOL success = YES; + BOOL canceled = NO; + int ret = 0; + 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 = 0; + NSError *unzippingError; + do { + @autoreleasepool { + if ([password length] == 0) { + ret = unzOpenCurrentFile(zip); + } else { + ret = unzOpenCurrentFilePassword(zip, [password cStringUsingEncoding:NSASCIIStringEncoding]); + } + + if (ret != UNZ_OK) { + 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) { + 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) + { + return NO; + } + + unzGetCurrentFileInfo(zip, &fileInfo, filename, fileInfo.size_filename + 1, NULL, 0, NULL, 0); + filename[fileInfo.size_filename] = '\0'; + + // + // 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 = NO; + if (((fileInfo.version >> 8) == ZipUNIXVersion) && BSD_IFLNK == (BSD_SFMT & (fileInfo.external_fa >> 16))) { + fileIsSymbolicLink = YES; + } + + // Check if it contains directory + // NSString * strPath = @(filename); + NSString * strPath = [NSString stringWithCString:filename encoding:NSUTF8StringEncoding]; + //if filename contains chinese dir transform Encoding + if (!strPath) { + NSStringEncoding enc = CFStringConvertEncodingToNSStringEncoding(kCFStringEncodingGB_18030_2000); + strPath = [NSString stringWithCString:filename encoding:enc]; + } + //end by skyfox + + 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.dosDate]; + 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) { + FILE *fp = fopen((const char*)[fullPath UTF8String], "wb"); + while (fp) { + int readBytes = unzReadCurrentFile(zip, buffer, 4096); + + if (readBytes > 0) { + fwrite(buffer, readBytes, 1, fp ); + } else { + break; + } + } + + if (fp) { + if ([[[fullPath pathExtension] lowercaseString] isEqualToString:@"zip"]) { + NSLog(@"Unzipping nested .zip file: %@", [fullPath lastPathComponent]); + if ([self unzipFileAtPath:fullPath toDestination:[fullPath stringByDeletingLastPathComponent] overwrite:overwrite password:password error:nil delegate:nil ]) { + [[NSFileManager defaultManager] removeItemAtPath:fullPath error:nil]; + } + } + + fclose(fp); + + if (preserveAttributes) { + + // Set the original datetime property + if (fileInfo.dosDate != 0) { + NSDate *orgDate = [[self class] _dateWithMSDOSFormat:(UInt32)fileInfo.dosDate]; + NSDictionary *attr = @{NSFileModificationDate: orgDate}; + + if (attr) { + if ([fileManager setAttributes:attr ofItemAtPath:fullPath error:nil] == NO) { + // Can't set attributes + NSLog(@"[SSZipArchive] Failed to set attributes - whilst setting modification date"); + } + } + } + + // Set the original permissions on the file + uLong permissions = fileInfo.external_fa >> 16; + 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] == NO) { + // Unable to set the permissions attribute + NSLog(@"[SSZipArchive] Failed to set attributes - whilst setting permissions"); + } + +#if !__has_feature(objc_arc) + [attrs release]; +#endif + } + } + } + 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 + { + // Assemble the path for the symbolic link + NSMutableString* destinationPath = [NSMutableString string]; + int bytesRead = 0; + while((bytesRead = unzReadCurrentFile(zip, buffer, 4096)) > 0) + { + buffer[bytesRead] = (int)0; + [destinationPath appendString:@((const char*)buffer)]; + } + + // 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) + { + NSLog(@"Failed to create symbolic link at \"%@\" to \"%@\". symlink() error code: %d", fullPath, destinationPath, errno); + } + } + + 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]; + } + + currentFileNumber++; + if (progressHandler) + { + progressHandler(strPath, fileInfo, currentFileNumber, globalInfo.number_entry); + } + } + } while(ret == UNZ_OK && ret != UNZ_END_OF_LIST_OF_FILE); + + // 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); + } + } +#if !__has_feature(objc_arc) + [directoriesModificationDates release]; +#endif + } + + // 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:-3 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 +{ + BOOL success = NO; + SSZipArchive *zipArchive = [[SSZipArchive alloc] initWithPath:path]; + if ([zipArchive open]) { + for (NSString *filePath in paths) { + [zipArchive writeFile:filePath withPassword:password]; + } + success = [zipArchive close]; + } + +#if !__has_feature(objc_arc) + [zipArchive release]; +#endif + + return success; +} + ++ (BOOL)createZipFileAtPath:(NSString *)path withContentsOfDirectory:(NSString *)directoryPath withPassword:(nullable NSString *)password{ + return [self createZipFileAtPath:path withContentsOfDirectory:directoryPath keepParentDirectory:NO withPassword:password]; +} + + ++ (BOOL)createZipFileAtPath:(NSString *)path withContentsOfDirectory:(NSString *)directoryPath keepParentDirectory:(BOOL)keepParentDirectory withPassword:(nullable NSString *)password{ + BOOL success = NO; + + NSFileManager *fileManager = nil; + SSZipArchive *zipArchive = [[SSZipArchive alloc] initWithPath:path]; + + if ([zipArchive open]) { + // use a local filemanager (queue/thread compatibility) + fileManager = [[NSFileManager alloc] init]; + NSDirectoryEnumerator *dirEnumerator = [fileManager enumeratorAtPath:directoryPath]; + NSString *fileName; + while ((fileName = [dirEnumerator nextObject])) { + BOOL isDir; + NSString *fullFilePath = [directoryPath stringByAppendingPathComponent:fileName]; + [fileManager fileExistsAtPath:fullFilePath isDirectory:&isDir]; + + if (keepParentDirectory) + { + fileName = [[directoryPath lastPathComponent] stringByAppendingPathComponent:fileName]; + } + + if (!isDir) { + [zipArchive writeFileAtPath:fullFilePath withFileName:fileName withPassword:password]; + } + else + { + if([[NSFileManager defaultManager] subpathsOfDirectoryAtPath:fullFilePath error:nil].count == 0) + { + NSString *tempFilePath = [self _temporaryPathForDiscardableFile]; + NSString *tempFileFilename = [fileName stringByAppendingPathComponent:tempFilePath.lastPathComponent]; + [zipArchive writeFileAtPath:tempFilePath withFileName:tempFileFilename withPassword:password]; + } + } + } + success = [zipArchive close]; + } + +#if !__has_feature(objc_arc) + [fileManager release]; + [zipArchive release]; +#endif + + return success; +} + + +- (instancetype)initWithPath:(NSString *)path +{ + if ((self = [super init])) { + _path = [path copy]; + } + return self; +} + + +#if !__has_feature(objc_arc) +- (void)dealloc +{ + [_path release]; + [super dealloc]; +} +#endif + + +- (BOOL)open +{ + NSAssert((_zip == NULL), @"Attempting open an archive which is already open"); + _zip = zipOpen([_path UTF8String], APPEND_STATUS_CREATE); + return (NULL != _zip); +} + + +- (void)zipInfo:(zip_fileinfo*)zipInfo setDate:(NSDate*)date +{ + NSCalendar *currentCalendar = [NSCalendar currentCalendar]; +#if defined(__IPHONE_8_0) || defined(__MAC_10_10) + uint flags = NSCalendarUnitYear | NSCalendarUnitMonth | NSCalendarUnitDay | NSCalendarUnitHour | NSCalendarUnitMinute | NSCalendarUnitSecond; +#else + uint flags = NSYearCalendarUnit | NSMonthCalendarUnit | NSDayCalendarUnit | NSHourCalendarUnit | NSMinuteCalendarUnit | NSSecondCalendarUnit; +#endif + NSDateComponents *components = [currentCalendar components:flags fromDate:date]; + zipInfo->tmz_date.tm_sec = (unsigned int)components.second; + zipInfo->tmz_date.tm_min = (unsigned int)components.minute; + zipInfo->tmz_date.tm_hour = (unsigned int)components.hour; + zipInfo->tmz_date.tm_mday = (unsigned int)components.day; + zipInfo->tmz_date.tm_mon = (unsigned int)components.month - 1; + zipInfo->tmz_date.tm_year = (unsigned int)components.year; +} + +- (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 = {{0}}; + + 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) { + // 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 + zipInfo.external_fa = permissionsLong << 16L; + } + } + + unsigned int len = 0; + zipOpenNewFileInZip3(_zip, [[folderName stringByAppendingString:@"/"] UTF8String], &zipInfo, NULL, 0, NULL, 0, NULL, Z_DEFLATED, Z_NO_COMPRESSION, 0, -MAX_WBITS, DEF_MEM_LEVEL, + Z_DEFAULT_STRATEGY, [password UTF8String], 0); + zipWriteInFileInZip(_zip, &len, 0); + zipCloseFileInZip(_zip); + return YES; +} + +- (BOOL)writeFile:(NSString *)path withPassword:(nullable NSString *)password; +{ + return [self writeFileAtPath:path withFileName:nil withPassword:password]; +} + +// 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 withPassword:(nullable NSString *)password +{ + NSAssert((_zip != NULL), @"Attempting to write to an archive which was never opened"); + + FILE *input = fopen([path UTF8String], "r"); + if (NULL == input) { + return NO; + } + + const char *afileName; + if (!fileName) { + afileName = [path.lastPathComponent UTF8String]; + } + else { + afileName = [fileName UTF8String]; + } + + zip_fileinfo zipInfo = {{0}}; + + 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) { + // 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 + zipInfo.external_fa = permissionsLong << 16L; + } + } + + void *buffer = malloc(CHUNK); + if (buffer == NULL) + { + return NO; + } + + zipOpenNewFileInZip3(_zip, afileName, &zipInfo, NULL, 0, NULL, 0, NULL, Z_DEFLATED, Z_DEFAULT_COMPRESSION, 0, -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, [password UTF8String], 0); + unsigned int len = 0; + + while (!feof(input)) + { + len = (unsigned int) fread(buffer, 1, CHUNK, input); + zipWriteInFileInZip(_zip, buffer, len); + } + + zipCloseFileInZip(_zip); + free(buffer); + fclose(input); + return YES; +} + +- (BOOL)writeData:(NSData *)data filename:(nullable NSString *)filename withPassword:(nullable NSString *)password; +{ + if (!_zip) { + return NO; + } + if (!data) { + return NO; + } + zip_fileinfo zipInfo = {{0,0,0,0,0,0},0,0,0}; + [self zipInfo:&zipInfo setDate:[NSDate date]]; + + zipOpenNewFileInZip3(_zip, [filename UTF8String], &zipInfo, NULL, 0, NULL, 0, NULL, Z_DEFLATED, Z_DEFAULT_COMPRESSION, 0, -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, [password UTF8String], 0); + + zipWriteInFileInZip(_zip, data.bytes, (unsigned int)data.length); + + zipCloseFileInZip(_zip); + return YES; +} + + +- (BOOL)close +{ + NSAssert((_zip != NULL), @"[SSZipArchive] Attempting to close an archive which was never opened"); + zipClose(_zip, NULL); + return YES; +} + +#pragma mark - Private + ++ (NSString *)_temporaryPathForDiscardableFile +{ + static NSString *discardableFileName = @".DS_Store"; + static NSString *discardableFilePath = nil; + static dispatch_once_t onceToken; + dispatch_once(&onceToken, ^{ + NSString *temporaryDirectoryName = [[NSUUID UUID] UUIDString]; + NSString *temporaryDirectory = [NSTemporaryDirectory() stringByAppendingPathComponent:temporaryDirectoryName]; + BOOL directoryCreated = [[NSFileManager defaultManager] createDirectoryAtPath:temporaryDirectory withIntermediateDirectories:YES attributes:nil error:nil]; + discardableFilePath = directoryCreated ? [temporaryDirectory stringByAppendingPathComponent:discardableFileName] : nil; + [@"" writeToFile:discardableFilePath atomically:YES encoding:NSUTF8StringEncoding error:nil]; + }); + return discardableFilePath; +} + +// 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 +{ + 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; + + static NSCalendar *gregorian; + static dispatch_once_t onceToken; + dispatch_once(&onceToken, ^{ +#if defined(__IPHONE_8_0) || defined(__MAC_10_10) + gregorian = [[NSCalendar alloc] initWithCalendarIdentifier:NSCalendarIdentifierGregorian]; +#else + gregorian = [[NSCalendar alloc] initWithCalendarIdentifier:NSGregorianCalendar]; +#endif + }); + + NSDateComponents *components = [[NSDateComponents alloc] init]; + + NSAssert(0xFFFFFFFF == (kYearMask | kMonthMask | kDayMask | kHourMask | kMinuteMask | kSecondMask), @"[SSZipArchive] MSDOS date masks don't add up"); + + [components setYear:1980 + ((msdosDateTime & kYearMask) >> 25)]; + [components setMonth:(msdosDateTime & kMonthMask) >> 21]; + [components setDay:(msdosDateTime & kDayMask) >> 16]; + [components setHour:(msdosDateTime & kHourMask) >> 11]; + [components setMinute:(msdosDateTime & kMinuteMask) >> 5]; + [components setSecond:(msdosDateTime & kSecondMask) * 2]; + + NSDate *date = [NSDate dateWithTimeInterval:0 sinceDate:[gregorian dateFromComponents:components]]; + +#if !__has_feature(objc_arc) + [components release]; +#endif + + return date; +} + +@end \ No newline at end of file diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/SSZipCommon.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/SSZipCommon.h new file mode 100755 index 0000000..cddf040 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/SSZipCommon.h @@ -0,0 +1,81 @@ +#ifndef SSZipCommon +#define SSZipCommon + +/* tm_unz contain date/time info */ +typedef struct tm_unz_s +{ + unsigned int tm_sec; /* seconds after the minute - [0,59] */ + unsigned int tm_min; /* minutes after the hour - [0,59] */ + unsigned int tm_hour; /* hours since midnight - [0,23] */ + unsigned int tm_mday; /* day of the month - [1,31] */ + unsigned int tm_mon; /* months since January - [0,11] */ + unsigned int tm_year; /* years - [1980..2044] */ +} tm_unz; + +typedef struct unz_file_info_s +{ + unsigned long version; /* version made by 2 bytes */ + unsigned long version_needed; /* version needed to extract 2 bytes */ + unsigned long flag; /* general purpose bit flag 2 bytes */ + unsigned long compression_method; /* compression method 2 bytes */ + unsigned long dosDate; /* last mod file date in Dos fmt 4 bytes */ + unsigned long crc; /* crc-32 4 bytes */ + unsigned long compressed_size; /* compressed size 4 bytes */ + unsigned long uncompressed_size; /* uncompressed size 4 bytes */ + unsigned long size_filename; /* filename length 2 bytes */ + unsigned long size_file_extra; /* extra field length 2 bytes */ + unsigned long size_file_comment; /* file comment length 2 bytes */ + + unsigned long disk_num_start; /* disk number start 2 bytes */ + unsigned long internal_fa; /* internal file attributes 2 bytes */ + unsigned long external_fa; /* external file attributes 4 bytes */ + + tm_unz tmu_date; +} unz_file_info; + +/* unz_file_info contain information about a file in the zipfile */ +typedef struct unz_file_info64_s +{ + unsigned long version; /* version made by 2 bytes */ + unsigned long version_needed; /* version needed to extract 2 bytes */ + unsigned long flag; /* general purpose bit flag 2 bytes */ + unsigned long compression_method; /* compression method 2 bytes */ + unsigned long dosDate; /* last mod file date in Dos fmt 4 bytes */ + unsigned long crc; /* crc-32 4 bytes */ + unsigned long long compressed_size; /* compressed size 8 bytes */ + unsigned long long uncompressed_size; /* uncompressed size 8 bytes */ + unsigned long size_filename; /* filename length 2 bytes */ + unsigned long size_file_extra; /* extra field length 2 bytes */ + unsigned long size_file_comment; /* file comment length 2 bytes */ + + unsigned long disk_num_start; /* disk number start 2 bytes */ + unsigned long internal_fa; /* internal file attributes 2 bytes */ + unsigned long external_fa; /* external file attributes 4 bytes */ + + tm_unz tmu_date; + unsigned long long disk_offset; + unsigned long size_file_extra_internal; +} unz_file_info64; + +typedef struct unz_global_info_s +{ + unsigned long number_entry; /* total number of entries in + the central dir on this disk */ + + unsigned long number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP*/ + + + unsigned long size_comment; /* size of the global comment of the zipfile */ +} unz_global_info; + +typedef struct unz_global_info64 +{ + unsigned long long number_entry; /* total number of entries in + the central dir on this disk */ + + unsigned long number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP*/ + + unsigned long size_comment; /* size of the global comment of the zipfile */ +} unz_global_info64; + +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/ZipArchive.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/ZipArchive.h new file mode 100755 index 0000000..f9391cb --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/ZipArchive.h @@ -0,0 +1,19 @@ +// +// ZipArchive.h +// ZipArchive +// +// Created by Serhii Mumriak on 12/1/15. +// Copyright © 2015 smumryak. All rights reserved. +// + +#import + +//! Project version number for ZipArchive. +FOUNDATION_EXPORT double ZipArchiveVersionNumber; + +//! Project version string for ZipArchive. +FOUNDATION_EXPORT const unsigned char ZipArchiveVersionString[]; + +// In this header, you should import all the public headers of your framework using statements like #import + +#import "SSZipArchive.h" diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aes.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aes.h new file mode 100755 index 0000000..44682c3 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aes.h @@ -0,0 +1,198 @@ +/* +--------------------------------------------------------------------------- +Copyright (c) 1998-2010, Brian Gladman, Worcester, UK. All rights reserved. + +The redistribution and use of this software (with or without changes) +is allowed without the payment of fees or royalties provided that: + + source code distributions include the above copyright notice, this + list of conditions and the following disclaimer; + + binary distributions include the above copyright notice, this list + of conditions and the following disclaimer in their documentation. + +This software is provided 'as is' with no explicit or implied warranties +in respect of its operation, including, but not limited to, correctness +and fitness for purpose. +--------------------------------------------------------------------------- +Issue Date: 20/12/2007 + + This file contains the definitions required to use AES in C. See aesopt.h + for optimisation details. +*/ + +#ifndef _AES_H +#define _AES_H + +#include + +/* This include is used to find 8 & 32 bit unsigned integer types */ +#include "brg_types.h" + +#if defined(__cplusplus) +extern "C" +{ +#endif + +#define AES_128 /* if a fast 128 bit key scheduler is needed */ +#define AES_192 /* if a fast 192 bit key scheduler is needed */ +#define AES_256 /* if a fast 256 bit key scheduler is needed */ +#define AES_VAR /* if variable key size scheduler is needed */ +#define AES_MODES /* if support is needed for modes */ + +/* The following must also be set in assembler files if being used */ + +#define AES_ENCRYPT /* if support for encryption is needed */ +#define AES_DECRYPT /* if support for decryption is needed */ +#define AES_REV_DKS /* define to reverse decryption key schedule */ + +#define AES_BLOCK_SIZE 16 /* the AES block size in bytes */ +#define N_COLS 4 /* the number of columns in the state */ + +/* The key schedule length is 11, 13 or 15 16-byte blocks for 128, */ +/* 192 or 256-bit keys respectively. That is 176, 208 or 240 bytes */ +/* or 44, 52 or 60 32-bit words. */ + +#if defined( AES_VAR ) || defined( AES_256 ) +#define KS_LENGTH 60 +#elif defined( AES_192 ) +#define KS_LENGTH 52 +#else +#define KS_LENGTH 44 +#endif + +#define AES_RETURN INT_RETURN + +/* the character array 'inf' in the following structures is used */ +/* to hold AES context information. This AES code uses cx->inf.b[0] */ +/* to hold the number of rounds multiplied by 16. The other three */ +/* elements can be used by code that implements additional modes */ + +typedef union +{ uint_32t l; + uint_8t b[4]; +} aes_inf; + +typedef struct +{ uint_32t ks[KS_LENGTH]; + aes_inf inf; +} aes_encrypt_ctx; + +typedef struct +{ uint_32t ks[KS_LENGTH]; + aes_inf inf; +} aes_decrypt_ctx; + +/* This routine must be called before first use if non-static */ +/* tables are being used */ + +AES_RETURN aes_init(void); + +/* Key lengths in the range 16 <= key_len <= 32 are given in bytes, */ +/* those in the range 128 <= key_len <= 256 are given in bits */ + +#if defined( AES_ENCRYPT ) + +#if defined( AES_128 ) || defined( AES_VAR) +AES_RETURN aes_encrypt_key128(const unsigned char *key, aes_encrypt_ctx cx[1]); +#endif + +#if defined( AES_192 ) || defined( AES_VAR) +AES_RETURN aes_encrypt_key192(const unsigned char *key, aes_encrypt_ctx cx[1]); +#endif + +#if defined( AES_256 ) || defined( AES_VAR) +AES_RETURN aes_encrypt_key256(const unsigned char *key, aes_encrypt_ctx cx[1]); +#endif + +#if defined( AES_VAR ) +AES_RETURN aes_encrypt_key(const unsigned char *key, int key_len, aes_encrypt_ctx cx[1]); +#endif + +AES_RETURN aes_encrypt(const unsigned char *in, unsigned char *out, const aes_encrypt_ctx cx[1]); + +#endif + +#if defined( AES_DECRYPT ) + +#if defined( AES_128 ) || defined( AES_VAR) +AES_RETURN aes_decrypt_key128(const unsigned char *key, aes_decrypt_ctx cx[1]); +#endif + +#if defined( AES_192 ) || defined( AES_VAR) +AES_RETURN aes_decrypt_key192(const unsigned char *key, aes_decrypt_ctx cx[1]); +#endif + +#if defined( AES_256 ) || defined( AES_VAR) +AES_RETURN aes_decrypt_key256(const unsigned char *key, aes_decrypt_ctx cx[1]); +#endif + +#if defined( AES_VAR ) +AES_RETURN aes_decrypt_key(const unsigned char *key, int key_len, aes_decrypt_ctx cx[1]); +#endif + +AES_RETURN aes_decrypt(const unsigned char *in, unsigned char *out, const aes_decrypt_ctx cx[1]); + +#endif + +#if defined( AES_MODES ) + +/* Multiple calls to the following subroutines for multiple block */ +/* ECB, CBC, CFB, OFB and CTR mode encryption can be used to handle */ +/* long messages incremantally provided that the context AND the iv */ +/* are preserved between all such calls. For the ECB and CBC modes */ +/* each individual call within a series of incremental calls must */ +/* process only full blocks (i.e. len must be a multiple of 16) but */ +/* the CFB, OFB and CTR mode calls can handle multiple incremental */ +/* calls of any length. Each mode is reset when a new AES key is */ +/* set but ECB and CBC operations can be reset without setting a */ +/* new key by setting a new IV value. To reset CFB, OFB and CTR */ +/* without setting the key, aes_mode_reset() must be called and the */ +/* IV must be set. NOTE: All these calls update the IV on exit so */ +/* this has to be reset if a new operation with the same IV as the */ +/* previous one is required (or decryption follows encryption with */ +/* the same IV array). */ + +AES_RETURN aes_test_alignment_detection(unsigned int n); + +AES_RETURN aes_ecb_encrypt(const unsigned char *ibuf, unsigned char *obuf, + int len, const aes_encrypt_ctx cx[1]); + +AES_RETURN aes_ecb_decrypt(const unsigned char *ibuf, unsigned char *obuf, + int len, const aes_decrypt_ctx cx[1]); + +AES_RETURN aes_cbc_encrypt(const unsigned char *ibuf, unsigned char *obuf, + int len, unsigned char *iv, const aes_encrypt_ctx cx[1]); + +AES_RETURN aes_cbc_decrypt(const unsigned char *ibuf, unsigned char *obuf, + int len, unsigned char *iv, const aes_decrypt_ctx cx[1]); + +AES_RETURN aes_mode_reset(aes_encrypt_ctx cx[1]); + +AES_RETURN aes_cfb_encrypt(const unsigned char *ibuf, unsigned char *obuf, + int len, unsigned char *iv, aes_encrypt_ctx cx[1]); + +AES_RETURN aes_cfb_decrypt(const unsigned char *ibuf, unsigned char *obuf, + int len, unsigned char *iv, aes_encrypt_ctx cx[1]); + +#define aes_ofb_encrypt aes_ofb_crypt +#define aes_ofb_decrypt aes_ofb_crypt + +AES_RETURN aes_ofb_crypt(const unsigned char *ibuf, unsigned char *obuf, + int len, unsigned char *iv, aes_encrypt_ctx cx[1]); + +typedef void cbuf_inc(unsigned char *cbuf); + +#define aes_ctr_encrypt aes_ctr_crypt +#define aes_ctr_decrypt aes_ctr_crypt + +AES_RETURN aes_ctr_crypt(const unsigned char *ibuf, unsigned char *obuf, + int len, unsigned char *cbuf, cbuf_inc ctr_inc, aes_encrypt_ctx cx[1]); + +#endif + +#if defined(__cplusplus) +} +#endif + +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aes_via_ace.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aes_via_ace.h new file mode 100755 index 0000000..cb2aa1b --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aes_via_ace.h @@ -0,0 +1,541 @@ +/* +Copyright (c) 1998-2010, Brian Gladman, Worcester, UK. All rights reserved. + +The redistribution and use of this software (with or without changes) +is allowed without the payment of fees or royalties provided that: + + source code distributions include the above copyright notice, this + list of conditions and the following disclaimer; + + binary distributions include the above copyright notice, this list + of conditions and the following disclaimer in their documentation. + +This software is provided 'as is' with no explicit or implied warranties +in respect of its operation, including, but not limited to, correctness +and fitness for purpose. +--------------------------------------------------------------------------- +Issue Date: 20/12/2007 +*/ + +#ifndef AES_VIA_ACE_H +#define AES_VIA_ACE_H + +#if defined( _MSC_VER ) +# define INLINE __inline +#elif defined( __GNUC__ ) +# define INLINE static inline +#else +# error VIA ACE requires Microsoft or GNU C +#endif + +#define NEH_GENERATE 1 +#define NEH_LOAD 2 +#define NEH_HYBRID 3 + +#define MAX_READ_ATTEMPTS 1000 + +/* VIA Nehemiah RNG and ACE Feature Mask Values */ + +#define NEH_CPU_IS_VIA 0x00000001 +#define NEH_CPU_READ 0x00000010 +#define NEH_CPU_MASK 0x00000011 + +#define NEH_RNG_PRESENT 0x00000004 +#define NEH_RNG_ENABLED 0x00000008 +#define NEH_ACE_PRESENT 0x00000040 +#define NEH_ACE_ENABLED 0x00000080 +#define NEH_RNG_FLAGS (NEH_RNG_PRESENT | NEH_RNG_ENABLED) +#define NEH_ACE_FLAGS (NEH_ACE_PRESENT | NEH_ACE_ENABLED) +#define NEH_FLAGS_MASK (NEH_RNG_FLAGS | NEH_ACE_FLAGS) + +/* VIA Nehemiah Advanced Cryptography Engine (ACE) Control Word Values */ + +#define NEH_GEN_KEY 0x00000000 /* generate key schedule */ +#define NEH_LOAD_KEY 0x00000080 /* load schedule from memory */ +#define NEH_ENCRYPT 0x00000000 /* encryption */ +#define NEH_DECRYPT 0x00000200 /* decryption */ +#define NEH_KEY128 0x00000000+0x0a /* 128 bit key */ +#define NEH_KEY192 0x00000400+0x0c /* 192 bit key */ +#define NEH_KEY256 0x00000800+0x0e /* 256 bit key */ + +#define NEH_ENC_GEN (NEH_ENCRYPT | NEH_GEN_KEY) +#define NEH_DEC_GEN (NEH_DECRYPT | NEH_GEN_KEY) +#define NEH_ENC_LOAD (NEH_ENCRYPT | NEH_LOAD_KEY) +#define NEH_DEC_LOAD (NEH_DECRYPT | NEH_LOAD_KEY) + +#define NEH_ENC_GEN_DATA {\ + NEH_ENC_GEN | NEH_KEY128, 0, 0, 0,\ + NEH_ENC_GEN | NEH_KEY192, 0, 0, 0,\ + NEH_ENC_GEN | NEH_KEY256, 0, 0, 0 } + +#define NEH_ENC_LOAD_DATA {\ + NEH_ENC_LOAD | NEH_KEY128, 0, 0, 0,\ + NEH_ENC_LOAD | NEH_KEY192, 0, 0, 0,\ + NEH_ENC_LOAD | NEH_KEY256, 0, 0, 0 } + +#define NEH_ENC_HYBRID_DATA {\ + NEH_ENC_GEN | NEH_KEY128, 0, 0, 0,\ + NEH_ENC_LOAD | NEH_KEY192, 0, 0, 0,\ + NEH_ENC_LOAD | NEH_KEY256, 0, 0, 0 } + +#define NEH_DEC_GEN_DATA {\ + NEH_DEC_GEN | NEH_KEY128, 0, 0, 0,\ + NEH_DEC_GEN | NEH_KEY192, 0, 0, 0,\ + NEH_DEC_GEN | NEH_KEY256, 0, 0, 0 } + +#define NEH_DEC_LOAD_DATA {\ + NEH_DEC_LOAD | NEH_KEY128, 0, 0, 0,\ + NEH_DEC_LOAD | NEH_KEY192, 0, 0, 0,\ + NEH_DEC_LOAD | NEH_KEY256, 0, 0, 0 } + +#define NEH_DEC_HYBRID_DATA {\ + NEH_DEC_GEN | NEH_KEY128, 0, 0, 0,\ + NEH_DEC_LOAD | NEH_KEY192, 0, 0, 0,\ + NEH_DEC_LOAD | NEH_KEY256, 0, 0, 0 } + +#define neh_enc_gen_key(x) ((x) == 128 ? (NEH_ENC_GEN | NEH_KEY128) : \ + (x) == 192 ? (NEH_ENC_GEN | NEH_KEY192) : (NEH_ENC_GEN | NEH_KEY256)) + +#define neh_enc_load_key(x) ((x) == 128 ? (NEH_ENC_LOAD | NEH_KEY128) : \ + (x) == 192 ? (NEH_ENC_LOAD | NEH_KEY192) : (NEH_ENC_LOAD | NEH_KEY256)) + +#define neh_enc_hybrid_key(x) ((x) == 128 ? (NEH_ENC_GEN | NEH_KEY128) : \ + (x) == 192 ? (NEH_ENC_LOAD | NEH_KEY192) : (NEH_ENC_LOAD | NEH_KEY256)) + +#define neh_dec_gen_key(x) ((x) == 128 ? (NEH_DEC_GEN | NEH_KEY128) : \ + (x) == 192 ? (NEH_DEC_GEN | NEH_KEY192) : (NEH_DEC_GEN | NEH_KEY256)) + +#define neh_dec_load_key(x) ((x) == 128 ? (NEH_DEC_LOAD | NEH_KEY128) : \ + (x) == 192 ? (NEH_DEC_LOAD | NEH_KEY192) : (NEH_DEC_LOAD | NEH_KEY256)) + +#define neh_dec_hybrid_key(x) ((x) == 128 ? (NEH_DEC_GEN | NEH_KEY128) : \ + (x) == 192 ? (NEH_DEC_LOAD | NEH_KEY192) : (NEH_DEC_LOAD | NEH_KEY256)) + +#if defined( _MSC_VER ) && ( _MSC_VER > 1200 ) +#define aligned_auto(type, name, no, stride) __declspec(align(stride)) type name[no] +#else +#define aligned_auto(type, name, no, stride) \ + unsigned char _##name[no * sizeof(type) + stride]; \ + type *name = (type*)(16 * ((((unsigned long)(_##name)) + stride - 1) / stride)) +#endif + +#if defined( _MSC_VER ) && ( _MSC_VER > 1200 ) +#define aligned_array(type, name, no, stride) __declspec(align(stride)) type name[no] +#elif defined( __GNUC__ ) +#define aligned_array(type, name, no, stride) type name[no] __attribute__ ((aligned(stride))) +#else +#define aligned_array(type, name, no, stride) type name[no] +#endif + +/* VIA ACE codeword */ + +static unsigned char via_flags = 0; + +#if defined ( _MSC_VER ) && ( _MSC_VER > 800 ) + +#define NEH_REKEY __asm pushfd __asm popfd +#define NEH_AES __asm _emit 0xf3 __asm _emit 0x0f __asm _emit 0xa7 +#define NEH_ECB NEH_AES __asm _emit 0xc8 +#define NEH_CBC NEH_AES __asm _emit 0xd0 +#define NEH_CFB NEH_AES __asm _emit 0xe0 +#define NEH_OFB NEH_AES __asm _emit 0xe8 +#define NEH_RNG __asm _emit 0x0f __asm _emit 0xa7 __asm _emit 0xc0 + +INLINE int has_cpuid(void) +{ char ret_value; + __asm + { pushfd /* save EFLAGS register */ + mov eax,[esp] /* copy it to eax */ + mov edx,0x00200000 /* CPUID bit position */ + xor eax,edx /* toggle the CPUID bit */ + push eax /* attempt to set EFLAGS to */ + popfd /* the new value */ + pushfd /* get the new EFLAGS value */ + pop eax /* into eax */ + xor eax,[esp] /* xor with original value */ + and eax,edx /* has CPUID bit changed? */ + setne al /* set to 1 if we have been */ + mov ret_value,al /* able to change it */ + popfd /* restore original EFLAGS */ + } + return (int)ret_value; +} + +INLINE int is_via_cpu(void) +{ char ret_value; + __asm + { push ebx + xor eax,eax /* use CPUID to get vendor */ + cpuid /* identity string */ + xor eax,eax /* is it "CentaurHauls" ? */ + sub ebx,0x746e6543 /* 'Cent' */ + or eax,ebx + sub edx,0x48727561 /* 'aurH' */ + or eax,edx + sub ecx,0x736c7561 /* 'auls' */ + or eax,ecx + sete al /* set to 1 if it is VIA ID */ + mov dl,NEH_CPU_READ /* mark CPU type as read */ + or dl,al /* & store result in flags */ + mov [via_flags],dl /* set VIA detected flag */ + mov ret_value,al /* able to change it */ + pop ebx + } + return (int)ret_value; +} + +INLINE int read_via_flags(void) +{ char ret_value = 0; + __asm + { mov eax,0xC0000000 /* Centaur extended CPUID */ + cpuid + mov edx,0xc0000001 /* >= 0xc0000001 if support */ + cmp eax,edx /* for VIA extended feature */ + jnae no_rng /* flags is available */ + mov eax,edx /* read Centaur extended */ + cpuid /* feature flags */ + mov eax,NEH_FLAGS_MASK /* mask out and save */ + and eax,edx /* the RNG and ACE flags */ + or [via_flags],al /* present & enabled flags */ + mov ret_value,al /* able to change it */ +no_rng: + } + return (int)ret_value; +} + +INLINE unsigned int via_rng_in(void *buf) +{ char ret_value = 0x1f; + __asm + { push edi + mov edi,buf /* input buffer address */ + xor edx,edx /* try to fetch 8 bytes */ + NEH_RNG /* do RNG read operation */ + and ret_value,al /* count of bytes returned */ + pop edi + } + return (int)ret_value; +} + +INLINE void via_ecb_op5( + const void *k, const void *c, const void *s, void *d, int l) +{ __asm + { push ebx + NEH_REKEY + mov ebx, (k) + mov edx, (c) + mov esi, (s) + mov edi, (d) + mov ecx, (l) + NEH_ECB + pop ebx + } +} + +INLINE void via_cbc_op6( + const void *k, const void *c, const void *s, void *d, int l, void *v) +{ __asm + { push ebx + NEH_REKEY + mov ebx, (k) + mov edx, (c) + mov esi, (s) + mov edi, (d) + mov ecx, (l) + mov eax, (v) + NEH_CBC + pop ebx + } +} + +INLINE void via_cbc_op7( + const void *k, const void *c, const void *s, void *d, int l, void *v, void *w) +{ __asm + { push ebx + NEH_REKEY + mov ebx, (k) + mov edx, (c) + mov esi, (s) + mov edi, (d) + mov ecx, (l) + mov eax, (v) + NEH_CBC + mov esi, eax + mov edi, (w) + movsd + movsd + movsd + movsd + pop ebx + } +} + +INLINE void via_cfb_op6( + const void *k, const void *c, const void *s, void *d, int l, void *v) +{ __asm + { push ebx + NEH_REKEY + mov ebx, (k) + mov edx, (c) + mov esi, (s) + mov edi, (d) + mov ecx, (l) + mov eax, (v) + NEH_CFB + pop ebx + } +} + +INLINE void via_cfb_op7( + const void *k, const void *c, const void *s, void *d, int l, void *v, void *w) +{ __asm + { push ebx + NEH_REKEY + mov ebx, (k) + mov edx, (c) + mov esi, (s) + mov edi, (d) + mov ecx, (l) + mov eax, (v) + NEH_CFB + mov esi, eax + mov edi, (w) + movsd + movsd + movsd + movsd + pop ebx + } +} + +INLINE void via_ofb_op6( + const void *k, const void *c, const void *s, void *d, int l, void *v) +{ __asm + { push ebx + NEH_REKEY + mov ebx, (k) + mov edx, (c) + mov esi, (s) + mov edi, (d) + mov ecx, (l) + mov eax, (v) + NEH_OFB + pop ebx + } +} + +#elif defined( __GNUC__ ) + +#define NEH_REKEY asm("pushfl\n popfl\n\t") +#define NEH_ECB asm(".byte 0xf3, 0x0f, 0xa7, 0xc8\n\t") +#define NEH_CBC asm(".byte 0xf3, 0x0f, 0xa7, 0xd0\n\t") +#define NEH_CFB asm(".byte 0xf3, 0x0f, 0xa7, 0xe0\n\t") +#define NEH_OFB asm(".byte 0xf3, 0x0f, 0xa7, 0xe8\n\t") +#define NEH_RNG asm(".byte 0x0f, 0xa7, 0xc0\n\t"); + +INLINE int has_cpuid(void) +{ int val; + asm("pushfl\n\t"); + asm("movl 0(%esp),%eax\n\t"); + asm("xor $0x00200000,%eax\n\t"); + asm("pushl %eax\n\t"); + asm("popfl\n\t"); + asm("pushfl\n\t"); + asm("popl %eax\n\t"); + asm("xorl 0(%esp),%edx\n\t"); + asm("andl $0x00200000,%eax\n\t"); + asm("movl %%eax,%0\n\t" : "=m" (val)); + asm("popfl\n\t"); + return val ? 1 : 0; +} + +INLINE int is_via_cpu(void) +{ int val; + asm("pushl %ebx\n\t"); + asm("xorl %eax,%eax\n\t"); + asm("cpuid\n\t"); + asm("xorl %eax,%eax\n\t"); + asm("subl $0x746e6543,%ebx\n\t"); + asm("orl %ebx,%eax\n\t"); + asm("subl $0x48727561,%edx\n\t"); + asm("orl %edx,%eax\n\t"); + asm("subl $0x736c7561,%ecx\n\t"); + asm("orl %ecx,%eax\n\t"); + asm("movl %%eax,%0\n\t" : "=m" (val)); + asm("popl %ebx\n\t"); + val = (val ? 0 : 1); + via_flags = (val | NEH_CPU_READ); + return val; +} + +INLINE int read_via_flags(void) +{ unsigned char val; + asm("movl $0xc0000000,%eax\n\t"); + asm("cpuid\n\t"); + asm("movl $0xc0000001,%edx\n\t"); + asm("cmpl %edx,%eax\n\t"); + asm("setae %al\n\t"); + asm("movb %%al,%0\n\t" : "=m" (val)); + if(!val) return 0; + asm("movl $0xc0000001,%eax\n\t"); + asm("cpuid\n\t"); + asm("movb %%dl,%0\n\t" : "=m" (val)); + val &= NEH_FLAGS_MASK; + via_flags |= val; + return (int) val; +} + +INLINE int via_rng_in(void *buf) +{ int val; + asm("pushl %edi\n\t"); + asm("movl %0,%%edi\n\t" : : "m" (buf)); + asm("xorl %edx,%edx\n\t"); + NEH_RNG + asm("andl $0x0000001f,%eax\n\t"); + asm("movl %%eax,%0\n\t" : "=m" (val)); + asm("popl %edi\n\t"); + return val; +} + +INLINE volatile void via_ecb_op5( + const void *k, const void *c, const void *s, void *d, int l) +{ + asm("pushl %ebx\n\t"); + NEH_REKEY; + asm("movl %0, %%ebx\n\t" : : "m" (k)); + asm("movl %0, %%edx\n\t" : : "m" (c)); + asm("movl %0, %%esi\n\t" : : "m" (s)); + asm("movl %0, %%edi\n\t" : : "m" (d)); + asm("movl %0, %%ecx\n\t" : : "m" (l)); + NEH_ECB; + asm("popl %ebx\n\t"); +} + +INLINE volatile void via_cbc_op6( + const void *k, const void *c, const void *s, void *d, int l, void *v) +{ + asm("pushl %ebx\n\t"); + NEH_REKEY; + asm("movl %0, %%ebx\n\t" : : "m" (k)); + asm("movl %0, %%edx\n\t" : : "m" (c)); + asm("movl %0, %%esi\n\t" : : "m" (s)); + asm("movl %0, %%edi\n\t" : : "m" (d)); + asm("movl %0, %%ecx\n\t" : : "m" (l)); + asm("movl %0, %%eax\n\t" : : "m" (v)); + NEH_CBC; + asm("popl %ebx\n\t"); +} + +INLINE volatile void via_cbc_op7( + const void *k, const void *c, const void *s, void *d, int l, void *v, void *w) +{ + asm("pushl %ebx\n\t"); + NEH_REKEY; + asm("movl %0, %%ebx\n\t" : : "m" (k)); + asm("movl %0, %%edx\n\t" : : "m" (c)); + asm("movl %0, %%esi\n\t" : : "m" (s)); + asm("movl %0, %%edi\n\t" : : "m" (d)); + asm("movl %0, %%ecx\n\t" : : "m" (l)); + asm("movl %0, %%eax\n\t" : : "m" (v)); + NEH_CBC; + asm("movl %eax,%esi\n\t"); + asm("movl %0, %%edi\n\t" : : "m" (w)); + asm("movsl; movsl; movsl; movsl\n\t"); + asm("popl %ebx\n\t"); +} + +INLINE volatile void via_cfb_op6( + const void *k, const void *c, const void *s, void *d, int l, void *v) +{ + asm("pushl %ebx\n\t"); + NEH_REKEY; + asm("movl %0, %%ebx\n\t" : : "m" (k)); + asm("movl %0, %%edx\n\t" : : "m" (c)); + asm("movl %0, %%esi\n\t" : : "m" (s)); + asm("movl %0, %%edi\n\t" : : "m" (d)); + asm("movl %0, %%ecx\n\t" : : "m" (l)); + asm("movl %0, %%eax\n\t" : : "m" (v)); + NEH_CFB; + asm("popl %ebx\n\t"); +} + +INLINE volatile void via_cfb_op7( + const void *k, const void *c, const void *s, void *d, int l, void *v, void *w) +{ + asm("pushl %ebx\n\t"); + NEH_REKEY; + asm("movl %0, %%ebx\n\t" : : "m" (k)); + asm("movl %0, %%edx\n\t" : : "m" (c)); + asm("movl %0, %%esi\n\t" : : "m" (s)); + asm("movl %0, %%edi\n\t" : : "m" (d)); + asm("movl %0, %%ecx\n\t" : : "m" (l)); + asm("movl %0, %%eax\n\t" : : "m" (v)); + NEH_CFB; + asm("movl %eax,%esi\n\t"); + asm("movl %0, %%edi\n\t" : : "m" (w)); + asm("movsl; movsl; movsl; movsl\n\t"); + asm("popl %ebx\n\t"); +} + +INLINE volatile void via_ofb_op6( + const void *k, const void *c, const void *s, void *d, int l, void *v) +{ + asm("pushl %ebx\n\t"); + NEH_REKEY; + asm("movl %0, %%ebx\n\t" : : "m" (k)); + asm("movl %0, %%edx\n\t" : : "m" (c)); + asm("movl %0, %%esi\n\t" : : "m" (s)); + asm("movl %0, %%edi\n\t" : : "m" (d)); + asm("movl %0, %%ecx\n\t" : : "m" (l)); + asm("movl %0, %%eax\n\t" : : "m" (v)); + NEH_OFB; + asm("popl %ebx\n\t"); +} + +#else +#error VIA ACE is not available with this compiler +#endif + +INLINE int via_ace_test(void) +{ + return has_cpuid() && is_via_cpu() && ((read_via_flags() & NEH_ACE_FLAGS) == NEH_ACE_FLAGS); +} + +#define VIA_ACE_AVAILABLE (((via_flags & NEH_ACE_FLAGS) == NEH_ACE_FLAGS) \ + || (via_flags & NEH_CPU_READ) && (via_flags & NEH_CPU_IS_VIA) || via_ace_test()) + +INLINE int via_rng_test(void) +{ + return has_cpuid() && is_via_cpu() && ((read_via_flags() & NEH_RNG_FLAGS) == NEH_RNG_FLAGS); +} + +#define VIA_RNG_AVAILABLE (((via_flags & NEH_RNG_FLAGS) == NEH_RNG_FLAGS) \ + || (via_flags & NEH_CPU_READ) && (via_flags & NEH_CPU_IS_VIA) || via_rng_test()) + +INLINE int read_via_rng(void *buf, int count) +{ int nbr, max_reads, lcnt = count; + unsigned char *p, *q; + aligned_auto(unsigned char, bp, 64, 16); + + if(!VIA_RNG_AVAILABLE) + return 0; + + do + { + max_reads = MAX_READ_ATTEMPTS; + do + nbr = via_rng_in(bp); + while + (nbr == 0 && --max_reads); + + lcnt -= nbr; + p = (unsigned char*)buf; q = bp; + while(nbr--) + *p++ = *q++; + } + while + (lcnt && max_reads); + + return count - lcnt; +} + +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aescrypt.c b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aescrypt.c new file mode 100755 index 0000000..99141cf --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aescrypt.c @@ -0,0 +1,294 @@ +/* +--------------------------------------------------------------------------- +Copyright (c) 1998-2010, Brian Gladman, Worcester, UK. All rights reserved. + +The redistribution and use of this software (with or without changes) +is allowed without the payment of fees or royalties provided that: + + source code distributions include the above copyright notice, this + list of conditions and the following disclaimer; + + binary distributions include the above copyright notice, this list + of conditions and the following disclaimer in their documentation. + +This software is provided 'as is' with no explicit or implied warranties +in respect of its operation, including, but not limited to, correctness +and fitness for purpose. +--------------------------------------------------------------------------- +Issue Date: 20/12/2007 +*/ + +#include "aesopt.h" +#include "aestab.h" + +#if defined(__cplusplus) +extern "C" +{ +#endif + +#define si(y,x,k,c) (s(y,c) = word_in(x, c) ^ (k)[c]) +#define so(y,x,c) word_out(y, c, s(x,c)) + +#if defined(ARRAYS) +#define locals(y,x) x[4],y[4] +#else +#define locals(y,x) x##0,x##1,x##2,x##3,y##0,y##1,y##2,y##3 +#endif + +#define l_copy(y, x) s(y,0) = s(x,0); s(y,1) = s(x,1); \ + s(y,2) = s(x,2); s(y,3) = s(x,3); +#define state_in(y,x,k) si(y,x,k,0); si(y,x,k,1); si(y,x,k,2); si(y,x,k,3) +#define state_out(y,x) so(y,x,0); so(y,x,1); so(y,x,2); so(y,x,3) +#define round(rm,y,x,k) rm(y,x,k,0); rm(y,x,k,1); rm(y,x,k,2); rm(y,x,k,3) + +#if ( FUNCS_IN_C & ENCRYPTION_IN_C ) + +/* Visual C++ .Net v7.1 provides the fastest encryption code when using + Pentium optimiation with small code but this is poor for decryption + so we need to control this with the following VC++ pragmas +*/ + +#if defined( _MSC_VER ) && !defined( _WIN64 ) +#pragma optimize( "s", on ) +#endif + +/* Given the column (c) of the output state variable, the following + macros give the input state variables which are needed in its + computation for each row (r) of the state. All the alternative + macros give the same end values but expand into different ways + of calculating these values. In particular the complex macro + used for dynamically variable block sizes is designed to expand + to a compile time constant whenever possible but will expand to + conditional clauses on some branches (I am grateful to Frank + Yellin for this construction) +*/ + +#define fwd_var(x,r,c)\ + ( r == 0 ? ( c == 0 ? s(x,0) : c == 1 ? s(x,1) : c == 2 ? s(x,2) : s(x,3))\ + : r == 1 ? ( c == 0 ? s(x,1) : c == 1 ? s(x,2) : c == 2 ? s(x,3) : s(x,0))\ + : r == 2 ? ( c == 0 ? s(x,2) : c == 1 ? s(x,3) : c == 2 ? s(x,0) : s(x,1))\ + : ( c == 0 ? s(x,3) : c == 1 ? s(x,0) : c == 2 ? s(x,1) : s(x,2))) + +#if defined(FT4_SET) +#undef dec_fmvars +#define fwd_rnd(y,x,k,c) (s(y,c) = (k)[c] ^ four_tables(x,t_use(f,n),fwd_var,rf1,c)) +#elif defined(FT1_SET) +#undef dec_fmvars +#define fwd_rnd(y,x,k,c) (s(y,c) = (k)[c] ^ one_table(x,upr,t_use(f,n),fwd_var,rf1,c)) +#else +#define fwd_rnd(y,x,k,c) (s(y,c) = (k)[c] ^ fwd_mcol(no_table(x,t_use(s,box),fwd_var,rf1,c))) +#endif + +#if defined(FL4_SET) +#define fwd_lrnd(y,x,k,c) (s(y,c) = (k)[c] ^ four_tables(x,t_use(f,l),fwd_var,rf1,c)) +#elif defined(FL1_SET) +#define fwd_lrnd(y,x,k,c) (s(y,c) = (k)[c] ^ one_table(x,ups,t_use(f,l),fwd_var,rf1,c)) +#else +#define fwd_lrnd(y,x,k,c) (s(y,c) = (k)[c] ^ no_table(x,t_use(s,box),fwd_var,rf1,c)) +#endif + +AES_RETURN aes_encrypt(const unsigned char *in, unsigned char *out, const aes_encrypt_ctx cx[1]) +{ uint_32t locals(b0, b1); + const uint_32t *kp; +#if defined( dec_fmvars ) + dec_fmvars; /* declare variables for fwd_mcol() if needed */ +#endif + + if( cx->inf.b[0] != 10 * 16 && cx->inf.b[0] != 12 * 16 && cx->inf.b[0] != 14 * 16 ) + return EXIT_FAILURE; + + kp = cx->ks; + state_in(b0, in, kp); + +#if (ENC_UNROLL == FULL) + + switch(cx->inf.b[0]) + { + case 14 * 16: + round(fwd_rnd, b1, b0, kp + 1 * N_COLS); + round(fwd_rnd, b0, b1, kp + 2 * N_COLS); + kp += 2 * N_COLS; + case 12 * 16: + round(fwd_rnd, b1, b0, kp + 1 * N_COLS); + round(fwd_rnd, b0, b1, kp + 2 * N_COLS); + kp += 2 * N_COLS; + case 10 * 16: + round(fwd_rnd, b1, b0, kp + 1 * N_COLS); + round(fwd_rnd, b0, b1, kp + 2 * N_COLS); + round(fwd_rnd, b1, b0, kp + 3 * N_COLS); + round(fwd_rnd, b0, b1, kp + 4 * N_COLS); + round(fwd_rnd, b1, b0, kp + 5 * N_COLS); + round(fwd_rnd, b0, b1, kp + 6 * N_COLS); + round(fwd_rnd, b1, b0, kp + 7 * N_COLS); + round(fwd_rnd, b0, b1, kp + 8 * N_COLS); + round(fwd_rnd, b1, b0, kp + 9 * N_COLS); + round(fwd_lrnd, b0, b1, kp +10 * N_COLS); + } + +#else + +#if (ENC_UNROLL == PARTIAL) + { uint_32t rnd; + for(rnd = 0; rnd < (cx->inf.b[0] >> 5) - 1; ++rnd) + { + kp += N_COLS; + round(fwd_rnd, b1, b0, kp); + kp += N_COLS; + round(fwd_rnd, b0, b1, kp); + } + kp += N_COLS; + round(fwd_rnd, b1, b0, kp); +#else + { uint_32t rnd; + for(rnd = 0; rnd < (cx->inf.b[0] >> 4) - 1; ++rnd) + { + kp += N_COLS; + round(fwd_rnd, b1, b0, kp); + l_copy(b0, b1); + } +#endif + kp += N_COLS; + round(fwd_lrnd, b0, b1, kp); + } +#endif + + state_out(out, b0); + return EXIT_SUCCESS; +} + +#endif + +#if ( FUNCS_IN_C & DECRYPTION_IN_C) + +/* Visual C++ .Net v7.1 provides the fastest encryption code when using + Pentium optimiation with small code but this is poor for decryption + so we need to control this with the following VC++ pragmas +*/ + +#if defined( _MSC_VER ) && !defined( _WIN64 ) +#pragma optimize( "t", on ) +#endif + +/* Given the column (c) of the output state variable, the following + macros give the input state variables which are needed in its + computation for each row (r) of the state. All the alternative + macros give the same end values but expand into different ways + of calculating these values. In particular the complex macro + used for dynamically variable block sizes is designed to expand + to a compile time constant whenever possible but will expand to + conditional clauses on some branches (I am grateful to Frank + Yellin for this construction) +*/ + +#define inv_var(x,r,c)\ + ( r == 0 ? ( c == 0 ? s(x,0) : c == 1 ? s(x,1) : c == 2 ? s(x,2) : s(x,3))\ + : r == 1 ? ( c == 0 ? s(x,3) : c == 1 ? s(x,0) : c == 2 ? s(x,1) : s(x,2))\ + : r == 2 ? ( c == 0 ? s(x,2) : c == 1 ? s(x,3) : c == 2 ? s(x,0) : s(x,1))\ + : ( c == 0 ? s(x,1) : c == 1 ? s(x,2) : c == 2 ? s(x,3) : s(x,0))) + +#if defined(IT4_SET) +#undef dec_imvars +#define inv_rnd(y,x,k,c) (s(y,c) = (k)[c] ^ four_tables(x,t_use(i,n),inv_var,rf1,c)) +#elif defined(IT1_SET) +#undef dec_imvars +#define inv_rnd(y,x,k,c) (s(y,c) = (k)[c] ^ one_table(x,upr,t_use(i,n),inv_var,rf1,c)) +#else +#define inv_rnd(y,x,k,c) (s(y,c) = inv_mcol((k)[c] ^ no_table(x,t_use(i,box),inv_var,rf1,c))) +#endif + +#if defined(IL4_SET) +#define inv_lrnd(y,x,k,c) (s(y,c) = (k)[c] ^ four_tables(x,t_use(i,l),inv_var,rf1,c)) +#elif defined(IL1_SET) +#define inv_lrnd(y,x,k,c) (s(y,c) = (k)[c] ^ one_table(x,ups,t_use(i,l),inv_var,rf1,c)) +#else +#define inv_lrnd(y,x,k,c) (s(y,c) = (k)[c] ^ no_table(x,t_use(i,box),inv_var,rf1,c)) +#endif + +/* This code can work with the decryption key schedule in the */ +/* order that is used for encrytpion (where the 1st decryption */ +/* round key is at the high end ot the schedule) or with a key */ +/* schedule that has been reversed to put the 1st decryption */ +/* round key at the low end of the schedule in memory (when */ +/* AES_REV_DKS is defined) */ + +#ifdef AES_REV_DKS +#define key_ofs 0 +#define rnd_key(n) (kp + n * N_COLS) +#else +#define key_ofs 1 +#define rnd_key(n) (kp - n * N_COLS) +#endif + +AES_RETURN aes_decrypt(const unsigned char *in, unsigned char *out, const aes_decrypt_ctx cx[1]) +{ uint_32t locals(b0, b1); +#if defined( dec_imvars ) + dec_imvars; /* declare variables for inv_mcol() if needed */ +#endif + const uint_32t *kp; + + if( cx->inf.b[0] != 10 * 16 && cx->inf.b[0] != 12 * 16 && cx->inf.b[0] != 14 * 16 ) + return EXIT_FAILURE; + + kp = cx->ks + (key_ofs ? (cx->inf.b[0] >> 2) : 0); + state_in(b0, in, kp); + +#if (DEC_UNROLL == FULL) + + kp = cx->ks + (key_ofs ? 0 : (cx->inf.b[0] >> 2)); + switch(cx->inf.b[0]) + { + case 14 * 16: + round(inv_rnd, b1, b0, rnd_key(-13)); + round(inv_rnd, b0, b1, rnd_key(-12)); + case 12 * 16: + round(inv_rnd, b1, b0, rnd_key(-11)); + round(inv_rnd, b0, b1, rnd_key(-10)); + case 10 * 16: + round(inv_rnd, b1, b0, rnd_key(-9)); + round(inv_rnd, b0, b1, rnd_key(-8)); + round(inv_rnd, b1, b0, rnd_key(-7)); + round(inv_rnd, b0, b1, rnd_key(-6)); + round(inv_rnd, b1, b0, rnd_key(-5)); + round(inv_rnd, b0, b1, rnd_key(-4)); + round(inv_rnd, b1, b0, rnd_key(-3)); + round(inv_rnd, b0, b1, rnd_key(-2)); + round(inv_rnd, b1, b0, rnd_key(-1)); + round(inv_lrnd, b0, b1, rnd_key( 0)); + } + +#else + +#if (DEC_UNROLL == PARTIAL) + { uint_32t rnd; + for(rnd = 0; rnd < (cx->inf.b[0] >> 5) - 1; ++rnd) + { + kp = rnd_key(1); + round(inv_rnd, b1, b0, kp); + kp = rnd_key(1); + round(inv_rnd, b0, b1, kp); + } + kp = rnd_key(1); + round(inv_rnd, b1, b0, kp); +#else + { uint_32t rnd; + for(rnd = 0; rnd < (cx->inf.b[0] >> 4) - 1; ++rnd) + { + kp = rnd_key(1); + round(inv_rnd, b1, b0, kp); + l_copy(b0, b1); + } +#endif + kp = rnd_key(1); + round(inv_lrnd, b0, b1, kp); + } +#endif + + state_out(out, b0); + return EXIT_SUCCESS; +} + +#endif + +#if defined(__cplusplus) +} +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aeskey.c b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aeskey.c new file mode 100755 index 0000000..0378f0c --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aeskey.c @@ -0,0 +1,548 @@ +/* +--------------------------------------------------------------------------- +Copyright (c) 1998-2010, Brian Gladman, Worcester, UK. All rights reserved. + +The redistribution and use of this software (with or without changes) +is allowed without the payment of fees or royalties provided that: + + source code distributions include the above copyright notice, this + list of conditions and the following disclaimer; + + binary distributions include the above copyright notice, this list + of conditions and the following disclaimer in their documentation. + +This software is provided 'as is' with no explicit or implied warranties +in respect of its operation, including, but not limited to, correctness +and fitness for purpose. +--------------------------------------------------------------------------- +Issue Date: 20/12/2007 +*/ + +#include "aesopt.h" +#include "aestab.h" + +#ifdef USE_VIA_ACE_IF_PRESENT +# include "aes_via_ace.h" +#endif + +#if defined(__cplusplus) +extern "C" +{ +#endif + +/* Initialise the key schedule from the user supplied key. The key + length can be specified in bytes, with legal values of 16, 24 + and 32, or in bits, with legal values of 128, 192 and 256. These + values correspond with Nk values of 4, 6 and 8 respectively. + + The following macros implement a single cycle in the key + schedule generation process. The number of cycles needed + for each cx->n_col and nk value is: + + nk = 4 5 6 7 8 + ------------------------------ + cx->n_col = 4 10 9 8 7 7 + cx->n_col = 5 14 11 10 9 9 + cx->n_col = 6 19 15 12 11 11 + cx->n_col = 7 21 19 16 13 14 + cx->n_col = 8 29 23 19 17 14 +*/ + +#if defined( REDUCE_CODE_SIZE ) +# define ls_box ls_sub + uint_32t ls_sub(const uint_32t t, const uint_32t n); +# define inv_mcol im_sub + uint_32t im_sub(const uint_32t x); +# ifdef ENC_KS_UNROLL +# undef ENC_KS_UNROLL +# endif +# ifdef DEC_KS_UNROLL +# undef DEC_KS_UNROLL +# endif +#endif + +#if (FUNCS_IN_C & ENC_KEYING_IN_C) + +#if defined(AES_128) || defined( AES_VAR ) + +#define ke4(k,i) \ +{ k[4*(i)+4] = ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; \ + k[4*(i)+5] = ss[1] ^= ss[0]; \ + k[4*(i)+6] = ss[2] ^= ss[1]; \ + k[4*(i)+7] = ss[3] ^= ss[2]; \ +} + +AES_RETURN aes_encrypt_key128(const unsigned char *key, aes_encrypt_ctx cx[1]) +{ uint_32t ss[4]; + + cx->ks[0] = ss[0] = word_in(key, 0); + cx->ks[1] = ss[1] = word_in(key, 1); + cx->ks[2] = ss[2] = word_in(key, 2); + cx->ks[3] = ss[3] = word_in(key, 3); + +#ifdef ENC_KS_UNROLL + ke4(cx->ks, 0); ke4(cx->ks, 1); + ke4(cx->ks, 2); ke4(cx->ks, 3); + ke4(cx->ks, 4); ke4(cx->ks, 5); + ke4(cx->ks, 6); ke4(cx->ks, 7); + ke4(cx->ks, 8); +#else + { uint_32t i; + for(i = 0; i < 9; ++i) + ke4(cx->ks, i); + } +#endif + ke4(cx->ks, 9); + cx->inf.l = 0; + cx->inf.b[0] = 10 * 16; + +#ifdef USE_VIA_ACE_IF_PRESENT + if(VIA_ACE_AVAILABLE) + cx->inf.b[1] = 0xff; +#endif + return EXIT_SUCCESS; +} + +#endif + +#if defined(AES_192) || defined( AES_VAR ) + +#define kef6(k,i) \ +{ k[6*(i)+ 6] = ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; \ + k[6*(i)+ 7] = ss[1] ^= ss[0]; \ + k[6*(i)+ 8] = ss[2] ^= ss[1]; \ + k[6*(i)+ 9] = ss[3] ^= ss[2]; \ +} + +#define ke6(k,i) \ +{ kef6(k,i); \ + k[6*(i)+10] = ss[4] ^= ss[3]; \ + k[6*(i)+11] = ss[5] ^= ss[4]; \ +} + +AES_RETURN aes_encrypt_key192(const unsigned char *key, aes_encrypt_ctx cx[1]) +{ uint_32t ss[6]; + + cx->ks[0] = ss[0] = word_in(key, 0); + cx->ks[1] = ss[1] = word_in(key, 1); + cx->ks[2] = ss[2] = word_in(key, 2); + cx->ks[3] = ss[3] = word_in(key, 3); + cx->ks[4] = ss[4] = word_in(key, 4); + cx->ks[5] = ss[5] = word_in(key, 5); + +#ifdef ENC_KS_UNROLL + ke6(cx->ks, 0); ke6(cx->ks, 1); + ke6(cx->ks, 2); ke6(cx->ks, 3); + ke6(cx->ks, 4); ke6(cx->ks, 5); + ke6(cx->ks, 6); +#else + { uint_32t i; + for(i = 0; i < 7; ++i) + ke6(cx->ks, i); + } +#endif + kef6(cx->ks, 7); + cx->inf.l = 0; + cx->inf.b[0] = 12 * 16; + +#ifdef USE_VIA_ACE_IF_PRESENT + if(VIA_ACE_AVAILABLE) + cx->inf.b[1] = 0xff; +#endif + return EXIT_SUCCESS; +} + +#endif + +#if defined(AES_256) || defined( AES_VAR ) + +#define kef8(k,i) \ +{ k[8*(i)+ 8] = ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; \ + k[8*(i)+ 9] = ss[1] ^= ss[0]; \ + k[8*(i)+10] = ss[2] ^= ss[1]; \ + k[8*(i)+11] = ss[3] ^= ss[2]; \ +} + +#define ke8(k,i) \ +{ kef8(k,i); \ + k[8*(i)+12] = ss[4] ^= ls_box(ss[3],0); \ + k[8*(i)+13] = ss[5] ^= ss[4]; \ + k[8*(i)+14] = ss[6] ^= ss[5]; \ + k[8*(i)+15] = ss[7] ^= ss[6]; \ +} + +AES_RETURN aes_encrypt_key256(const unsigned char *key, aes_encrypt_ctx cx[1]) +{ uint_32t ss[8]; + + cx->ks[0] = ss[0] = word_in(key, 0); + cx->ks[1] = ss[1] = word_in(key, 1); + cx->ks[2] = ss[2] = word_in(key, 2); + cx->ks[3] = ss[3] = word_in(key, 3); + cx->ks[4] = ss[4] = word_in(key, 4); + cx->ks[5] = ss[5] = word_in(key, 5); + cx->ks[6] = ss[6] = word_in(key, 6); + cx->ks[7] = ss[7] = word_in(key, 7); + +#ifdef ENC_KS_UNROLL + ke8(cx->ks, 0); ke8(cx->ks, 1); + ke8(cx->ks, 2); ke8(cx->ks, 3); + ke8(cx->ks, 4); ke8(cx->ks, 5); +#else + { uint_32t i; + for(i = 0; i < 6; ++i) + ke8(cx->ks, i); + } +#endif + kef8(cx->ks, 6); + cx->inf.l = 0; + cx->inf.b[0] = 14 * 16; + +#ifdef USE_VIA_ACE_IF_PRESENT + if(VIA_ACE_AVAILABLE) + cx->inf.b[1] = 0xff; +#endif + return EXIT_SUCCESS; +} + +#endif + +#if defined( AES_VAR ) + +AES_RETURN aes_encrypt_key(const unsigned char *key, int key_len, aes_encrypt_ctx cx[1]) +{ + switch(key_len) + { + case 16: case 128: return aes_encrypt_key128(key, cx); + case 24: case 192: return aes_encrypt_key192(key, cx); + case 32: case 256: return aes_encrypt_key256(key, cx); + default: return EXIT_FAILURE; + } +} + +#endif + +#endif + +#if (FUNCS_IN_C & DEC_KEYING_IN_C) + +/* this is used to store the decryption round keys */ +/* in forward or reverse order */ + +#ifdef AES_REV_DKS +#define v(n,i) ((n) - (i) + 2 * ((i) & 3)) +#else +#define v(n,i) (i) +#endif + +#if DEC_ROUND == NO_TABLES +#define ff(x) (x) +#else +#define ff(x) inv_mcol(x) +#if defined( dec_imvars ) +#define d_vars dec_imvars +#endif +#endif + +#if defined(AES_128) || defined( AES_VAR ) + +#define k4e(k,i) \ +{ k[v(40,(4*(i))+4)] = ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; \ + k[v(40,(4*(i))+5)] = ss[1] ^= ss[0]; \ + k[v(40,(4*(i))+6)] = ss[2] ^= ss[1]; \ + k[v(40,(4*(i))+7)] = ss[3] ^= ss[2]; \ +} + +#if 1 + +#define kdf4(k,i) \ +{ ss[0] = ss[0] ^ ss[2] ^ ss[1] ^ ss[3]; \ + ss[1] = ss[1] ^ ss[3]; \ + ss[2] = ss[2] ^ ss[3]; \ + ss[4] = ls_box(ss[(i+3) % 4], 3) ^ t_use(r,c)[i]; \ + ss[i % 4] ^= ss[4]; \ + ss[4] ^= k[v(40,(4*(i)))]; k[v(40,(4*(i))+4)] = ff(ss[4]); \ + ss[4] ^= k[v(40,(4*(i))+1)]; k[v(40,(4*(i))+5)] = ff(ss[4]); \ + ss[4] ^= k[v(40,(4*(i))+2)]; k[v(40,(4*(i))+6)] = ff(ss[4]); \ + ss[4] ^= k[v(40,(4*(i))+3)]; k[v(40,(4*(i))+7)] = ff(ss[4]); \ +} + +#define kd4(k,i) \ +{ ss[4] = ls_box(ss[(i+3) % 4], 3) ^ t_use(r,c)[i]; \ + ss[i % 4] ^= ss[4]; ss[4] = ff(ss[4]); \ + k[v(40,(4*(i))+4)] = ss[4] ^= k[v(40,(4*(i)))]; \ + k[v(40,(4*(i))+5)] = ss[4] ^= k[v(40,(4*(i))+1)]; \ + k[v(40,(4*(i))+6)] = ss[4] ^= k[v(40,(4*(i))+2)]; \ + k[v(40,(4*(i))+7)] = ss[4] ^= k[v(40,(4*(i))+3)]; \ +} + +#define kdl4(k,i) \ +{ ss[4] = ls_box(ss[(i+3) % 4], 3) ^ t_use(r,c)[i]; ss[i % 4] ^= ss[4]; \ + k[v(40,(4*(i))+4)] = (ss[0] ^= ss[1]) ^ ss[2] ^ ss[3]; \ + k[v(40,(4*(i))+5)] = ss[1] ^ ss[3]; \ + k[v(40,(4*(i))+6)] = ss[0]; \ + k[v(40,(4*(i))+7)] = ss[1]; \ +} + +#else + +#define kdf4(k,i) \ +{ ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; k[v(40,(4*(i))+ 4)] = ff(ss[0]); \ + ss[1] ^= ss[0]; k[v(40,(4*(i))+ 5)] = ff(ss[1]); \ + ss[2] ^= ss[1]; k[v(40,(4*(i))+ 6)] = ff(ss[2]); \ + ss[3] ^= ss[2]; k[v(40,(4*(i))+ 7)] = ff(ss[3]); \ +} + +#define kd4(k,i) \ +{ ss[4] = ls_box(ss[3],3) ^ t_use(r,c)[i]; \ + ss[0] ^= ss[4]; ss[4] = ff(ss[4]); k[v(40,(4*(i))+ 4)] = ss[4] ^= k[v(40,(4*(i)))]; \ + ss[1] ^= ss[0]; k[v(40,(4*(i))+ 5)] = ss[4] ^= k[v(40,(4*(i))+ 1)]; \ + ss[2] ^= ss[1]; k[v(40,(4*(i))+ 6)] = ss[4] ^= k[v(40,(4*(i))+ 2)]; \ + ss[3] ^= ss[2]; k[v(40,(4*(i))+ 7)] = ss[4] ^= k[v(40,(4*(i))+ 3)]; \ +} + +#define kdl4(k,i) \ +{ ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; k[v(40,(4*(i))+ 4)] = ss[0]; \ + ss[1] ^= ss[0]; k[v(40,(4*(i))+ 5)] = ss[1]; \ + ss[2] ^= ss[1]; k[v(40,(4*(i))+ 6)] = ss[2]; \ + ss[3] ^= ss[2]; k[v(40,(4*(i))+ 7)] = ss[3]; \ +} + +#endif + +AES_RETURN aes_decrypt_key128(const unsigned char *key, aes_decrypt_ctx cx[1]) +{ uint_32t ss[5]; +#if defined( d_vars ) + d_vars; +#endif + cx->ks[v(40,(0))] = ss[0] = word_in(key, 0); + cx->ks[v(40,(1))] = ss[1] = word_in(key, 1); + cx->ks[v(40,(2))] = ss[2] = word_in(key, 2); + cx->ks[v(40,(3))] = ss[3] = word_in(key, 3); + +#ifdef DEC_KS_UNROLL + kdf4(cx->ks, 0); kd4(cx->ks, 1); + kd4(cx->ks, 2); kd4(cx->ks, 3); + kd4(cx->ks, 4); kd4(cx->ks, 5); + kd4(cx->ks, 6); kd4(cx->ks, 7); + kd4(cx->ks, 8); kdl4(cx->ks, 9); +#else + { uint_32t i; + for(i = 0; i < 10; ++i) + k4e(cx->ks, i); +#if !(DEC_ROUND == NO_TABLES) + for(i = N_COLS; i < 10 * N_COLS; ++i) + cx->ks[i] = inv_mcol(cx->ks[i]); +#endif + } +#endif + cx->inf.l = 0; + cx->inf.b[0] = 10 * 16; + +#ifdef USE_VIA_ACE_IF_PRESENT + if(VIA_ACE_AVAILABLE) + cx->inf.b[1] = 0xff; +#endif + return EXIT_SUCCESS; +} + +#endif + +#if defined(AES_192) || defined( AES_VAR ) + +#define k6ef(k,i) \ +{ k[v(48,(6*(i))+ 6)] = ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; \ + k[v(48,(6*(i))+ 7)] = ss[1] ^= ss[0]; \ + k[v(48,(6*(i))+ 8)] = ss[2] ^= ss[1]; \ + k[v(48,(6*(i))+ 9)] = ss[3] ^= ss[2]; \ +} + +#define k6e(k,i) \ +{ k6ef(k,i); \ + k[v(48,(6*(i))+10)] = ss[4] ^= ss[3]; \ + k[v(48,(6*(i))+11)] = ss[5] ^= ss[4]; \ +} + +#define kdf6(k,i) \ +{ ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; k[v(48,(6*(i))+ 6)] = ff(ss[0]); \ + ss[1] ^= ss[0]; k[v(48,(6*(i))+ 7)] = ff(ss[1]); \ + ss[2] ^= ss[1]; k[v(48,(6*(i))+ 8)] = ff(ss[2]); \ + ss[3] ^= ss[2]; k[v(48,(6*(i))+ 9)] = ff(ss[3]); \ + ss[4] ^= ss[3]; k[v(48,(6*(i))+10)] = ff(ss[4]); \ + ss[5] ^= ss[4]; k[v(48,(6*(i))+11)] = ff(ss[5]); \ +} + +#define kd6(k,i) \ +{ ss[6] = ls_box(ss[5],3) ^ t_use(r,c)[i]; \ + ss[0] ^= ss[6]; ss[6] = ff(ss[6]); k[v(48,(6*(i))+ 6)] = ss[6] ^= k[v(48,(6*(i)))]; \ + ss[1] ^= ss[0]; k[v(48,(6*(i))+ 7)] = ss[6] ^= k[v(48,(6*(i))+ 1)]; \ + ss[2] ^= ss[1]; k[v(48,(6*(i))+ 8)] = ss[6] ^= k[v(48,(6*(i))+ 2)]; \ + ss[3] ^= ss[2]; k[v(48,(6*(i))+ 9)] = ss[6] ^= k[v(48,(6*(i))+ 3)]; \ + ss[4] ^= ss[3]; k[v(48,(6*(i))+10)] = ss[6] ^= k[v(48,(6*(i))+ 4)]; \ + ss[5] ^= ss[4]; k[v(48,(6*(i))+11)] = ss[6] ^= k[v(48,(6*(i))+ 5)]; \ +} + +#define kdl6(k,i) \ +{ ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; k[v(48,(6*(i))+ 6)] = ss[0]; \ + ss[1] ^= ss[0]; k[v(48,(6*(i))+ 7)] = ss[1]; \ + ss[2] ^= ss[1]; k[v(48,(6*(i))+ 8)] = ss[2]; \ + ss[3] ^= ss[2]; k[v(48,(6*(i))+ 9)] = ss[3]; \ +} + +AES_RETURN aes_decrypt_key192(const unsigned char *key, aes_decrypt_ctx cx[1]) +{ uint_32t ss[7]; +#if defined( d_vars ) + d_vars; +#endif + cx->ks[v(48,(0))] = ss[0] = word_in(key, 0); + cx->ks[v(48,(1))] = ss[1] = word_in(key, 1); + cx->ks[v(48,(2))] = ss[2] = word_in(key, 2); + cx->ks[v(48,(3))] = ss[3] = word_in(key, 3); + +#ifdef DEC_KS_UNROLL + cx->ks[v(48,(4))] = ff(ss[4] = word_in(key, 4)); + cx->ks[v(48,(5))] = ff(ss[5] = word_in(key, 5)); + kdf6(cx->ks, 0); kd6(cx->ks, 1); + kd6(cx->ks, 2); kd6(cx->ks, 3); + kd6(cx->ks, 4); kd6(cx->ks, 5); + kd6(cx->ks, 6); kdl6(cx->ks, 7); +#else + cx->ks[v(48,(4))] = ss[4] = word_in(key, 4); + cx->ks[v(48,(5))] = ss[5] = word_in(key, 5); + { uint_32t i; + + for(i = 0; i < 7; ++i) + k6e(cx->ks, i); + k6ef(cx->ks, 7); +#if !(DEC_ROUND == NO_TABLES) + for(i = N_COLS; i < 12 * N_COLS; ++i) + cx->ks[i] = inv_mcol(cx->ks[i]); +#endif + } +#endif + cx->inf.l = 0; + cx->inf.b[0] = 12 * 16; + +#ifdef USE_VIA_ACE_IF_PRESENT + if(VIA_ACE_AVAILABLE) + cx->inf.b[1] = 0xff; +#endif + return EXIT_SUCCESS; +} + +#endif + +#if defined(AES_256) || defined( AES_VAR ) + +#define k8ef(k,i) \ +{ k[v(56,(8*(i))+ 8)] = ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; \ + k[v(56,(8*(i))+ 9)] = ss[1] ^= ss[0]; \ + k[v(56,(8*(i))+10)] = ss[2] ^= ss[1]; \ + k[v(56,(8*(i))+11)] = ss[3] ^= ss[2]; \ +} + +#define k8e(k,i) \ +{ k8ef(k,i); \ + k[v(56,(8*(i))+12)] = ss[4] ^= ls_box(ss[3],0); \ + k[v(56,(8*(i))+13)] = ss[5] ^= ss[4]; \ + k[v(56,(8*(i))+14)] = ss[6] ^= ss[5]; \ + k[v(56,(8*(i))+15)] = ss[7] ^= ss[6]; \ +} + +#define kdf8(k,i) \ +{ ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; k[v(56,(8*(i))+ 8)] = ff(ss[0]); \ + ss[1] ^= ss[0]; k[v(56,(8*(i))+ 9)] = ff(ss[1]); \ + ss[2] ^= ss[1]; k[v(56,(8*(i))+10)] = ff(ss[2]); \ + ss[3] ^= ss[2]; k[v(56,(8*(i))+11)] = ff(ss[3]); \ + ss[4] ^= ls_box(ss[3],0); k[v(56,(8*(i))+12)] = ff(ss[4]); \ + ss[5] ^= ss[4]; k[v(56,(8*(i))+13)] = ff(ss[5]); \ + ss[6] ^= ss[5]; k[v(56,(8*(i))+14)] = ff(ss[6]); \ + ss[7] ^= ss[6]; k[v(56,(8*(i))+15)] = ff(ss[7]); \ +} + +#define kd8(k,i) \ +{ ss[8] = ls_box(ss[7],3) ^ t_use(r,c)[i]; \ + ss[0] ^= ss[8]; ss[8] = ff(ss[8]); k[v(56,(8*(i))+ 8)] = ss[8] ^= k[v(56,(8*(i)))]; \ + ss[1] ^= ss[0]; k[v(56,(8*(i))+ 9)] = ss[8] ^= k[v(56,(8*(i))+ 1)]; \ + ss[2] ^= ss[1]; k[v(56,(8*(i))+10)] = ss[8] ^= k[v(56,(8*(i))+ 2)]; \ + ss[3] ^= ss[2]; k[v(56,(8*(i))+11)] = ss[8] ^= k[v(56,(8*(i))+ 3)]; \ + ss[8] = ls_box(ss[3],0); \ + ss[4] ^= ss[8]; ss[8] = ff(ss[8]); k[v(56,(8*(i))+12)] = ss[8] ^= k[v(56,(8*(i))+ 4)]; \ + ss[5] ^= ss[4]; k[v(56,(8*(i))+13)] = ss[8] ^= k[v(56,(8*(i))+ 5)]; \ + ss[6] ^= ss[5]; k[v(56,(8*(i))+14)] = ss[8] ^= k[v(56,(8*(i))+ 6)]; \ + ss[7] ^= ss[6]; k[v(56,(8*(i))+15)] = ss[8] ^= k[v(56,(8*(i))+ 7)]; \ +} + +#define kdl8(k,i) \ +{ ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; k[v(56,(8*(i))+ 8)] = ss[0]; \ + ss[1] ^= ss[0]; k[v(56,(8*(i))+ 9)] = ss[1]; \ + ss[2] ^= ss[1]; k[v(56,(8*(i))+10)] = ss[2]; \ + ss[3] ^= ss[2]; k[v(56,(8*(i))+11)] = ss[3]; \ +} + +AES_RETURN aes_decrypt_key256(const unsigned char *key, aes_decrypt_ctx cx[1]) +{ uint_32t ss[9]; +#if defined( d_vars ) + d_vars; +#endif + cx->ks[v(56,(0))] = ss[0] = word_in(key, 0); + cx->ks[v(56,(1))] = ss[1] = word_in(key, 1); + cx->ks[v(56,(2))] = ss[2] = word_in(key, 2); + cx->ks[v(56,(3))] = ss[3] = word_in(key, 3); + +#ifdef DEC_KS_UNROLL + cx->ks[v(56,(4))] = ff(ss[4] = word_in(key, 4)); + cx->ks[v(56,(5))] = ff(ss[5] = word_in(key, 5)); + cx->ks[v(56,(6))] = ff(ss[6] = word_in(key, 6)); + cx->ks[v(56,(7))] = ff(ss[7] = word_in(key, 7)); + kdf8(cx->ks, 0); kd8(cx->ks, 1); + kd8(cx->ks, 2); kd8(cx->ks, 3); + kd8(cx->ks, 4); kd8(cx->ks, 5); + kdl8(cx->ks, 6); +#else + cx->ks[v(56,(4))] = ss[4] = word_in(key, 4); + cx->ks[v(56,(5))] = ss[5] = word_in(key, 5); + cx->ks[v(56,(6))] = ss[6] = word_in(key, 6); + cx->ks[v(56,(7))] = ss[7] = word_in(key, 7); + { uint_32t i; + + for(i = 0; i < 6; ++i) + k8e(cx->ks, i); + k8ef(cx->ks, 6); +#if !(DEC_ROUND == NO_TABLES) + for(i = N_COLS; i < 14 * N_COLS; ++i) + cx->ks[i] = inv_mcol(cx->ks[i]); +#endif + } +#endif + cx->inf.l = 0; + cx->inf.b[0] = 14 * 16; + +#ifdef USE_VIA_ACE_IF_PRESENT + if(VIA_ACE_AVAILABLE) + cx->inf.b[1] = 0xff; +#endif + return EXIT_SUCCESS; +} + +#endif + +#if defined( AES_VAR ) + +AES_RETURN aes_decrypt_key(const unsigned char *key, int key_len, aes_decrypt_ctx cx[1]) +{ + switch(key_len) + { + case 16: case 128: return aes_decrypt_key128(key, cx); + case 24: case 192: return aes_decrypt_key192(key, cx); + case 32: case 256: return aes_decrypt_key256(key, cx); + default: return EXIT_FAILURE; + } +} + +#endif + +#endif + +#if defined(__cplusplus) +} +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aesopt.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aesopt.h new file mode 100755 index 0000000..8851425 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aesopt.h @@ -0,0 +1,739 @@ +/* +--------------------------------------------------------------------------- +Copyright (c) 1998-2010, Brian Gladman, Worcester, UK. All rights reserved. + +The redistribution and use of this software (with or without changes) +is allowed without the payment of fees or royalties provided that: + + source code distributions include the above copyright notice, this + list of conditions and the following disclaimer; + + binary distributions include the above copyright notice, this list + of conditions and the following disclaimer in their documentation. + +This software is provided 'as is' with no explicit or implied warranties +in respect of its operation, including, but not limited to, correctness +and fitness for purpose. +--------------------------------------------------------------------------- +Issue Date: 20/12/2007 + + This file contains the compilation options for AES (Rijndael) and code + that is common across encryption, key scheduling and table generation. + + OPERATION + + These source code files implement the AES algorithm Rijndael designed by + Joan Daemen and Vincent Rijmen. This version is designed for the standard + block size of 16 bytes and for key sizes of 128, 192 and 256 bits (16, 24 + and 32 bytes). + + This version is designed for flexibility and speed using operations on + 32-bit words rather than operations on bytes. It can be compiled with + either big or little endian internal byte order but is faster when the + native byte order for the processor is used. + + THE CIPHER INTERFACE + + The cipher interface is implemented as an array of bytes in which lower + AES bit sequence indexes map to higher numeric significance within bytes. + + uint_8t (an unsigned 8-bit type) + uint_32t (an unsigned 32-bit type) + struct aes_encrypt_ctx (structure for the cipher encryption context) + struct aes_decrypt_ctx (structure for the cipher decryption context) + AES_RETURN the function return type + + C subroutine calls: + + AES_RETURN aes_encrypt_key128(const unsigned char *key, aes_encrypt_ctx cx[1]); + AES_RETURN aes_encrypt_key192(const unsigned char *key, aes_encrypt_ctx cx[1]); + AES_RETURN aes_encrypt_key256(const unsigned char *key, aes_encrypt_ctx cx[1]); + AES_RETURN aes_encrypt(const unsigned char *in, unsigned char *out, + const aes_encrypt_ctx cx[1]); + + AES_RETURN aes_decrypt_key128(const unsigned char *key, aes_decrypt_ctx cx[1]); + AES_RETURN aes_decrypt_key192(const unsigned char *key, aes_decrypt_ctx cx[1]); + AES_RETURN aes_decrypt_key256(const unsigned char *key, aes_decrypt_ctx cx[1]); + AES_RETURN aes_decrypt(const unsigned char *in, unsigned char *out, + const aes_decrypt_ctx cx[1]); + + IMPORTANT NOTE: If you are using this C interface with dynamic tables make sure that + you call aes_init() before AES is used so that the tables are initialised. + + C++ aes class subroutines: + + Class AESencrypt for encryption + + Construtors: + AESencrypt(void) + AESencrypt(const unsigned char *key) - 128 bit key + Members: + AES_RETURN key128(const unsigned char *key) + AES_RETURN key192(const unsigned char *key) + AES_RETURN key256(const unsigned char *key) + AES_RETURN encrypt(const unsigned char *in, unsigned char *out) const + + Class AESdecrypt for encryption + Construtors: + AESdecrypt(void) + AESdecrypt(const unsigned char *key) - 128 bit key + Members: + AES_RETURN key128(const unsigned char *key) + AES_RETURN key192(const unsigned char *key) + AES_RETURN key256(const unsigned char *key) + AES_RETURN decrypt(const unsigned char *in, unsigned char *out) const +*/ + +#if !defined( _AESOPT_H ) +#define _AESOPT_H + +#if defined( __cplusplus ) +#include "aescpp.h" +#else +#include "aes.h" +#endif + +/* PLATFORM SPECIFIC INCLUDES */ + +#include "brg_endian.h" + +/* CONFIGURATION - THE USE OF DEFINES + + Later in this section there are a number of defines that control the + operation of the code. In each section, the purpose of each define is + explained so that the relevant form can be included or excluded by + setting either 1's or 0's respectively on the branches of the related + #if clauses. The following local defines should not be changed. +*/ + +#define ENCRYPTION_IN_C 1 +#define DECRYPTION_IN_C 2 +#define ENC_KEYING_IN_C 4 +#define DEC_KEYING_IN_C 8 + +#define NO_TABLES 0 +#define ONE_TABLE 1 +#define FOUR_TABLES 4 +#define NONE 0 +#define PARTIAL 1 +#define FULL 2 + +/* --- START OF USER CONFIGURED OPTIONS --- */ + +/* 1. BYTE ORDER WITHIN 32 BIT WORDS + + The fundamental data processing units in Rijndael are 8-bit bytes. The + input, output and key input are all enumerated arrays of bytes in which + bytes are numbered starting at zero and increasing to one less than the + number of bytes in the array in question. This enumeration is only used + for naming bytes and does not imply any adjacency or order relationship + from one byte to another. When these inputs and outputs are considered + as bit sequences, bits 8*n to 8*n+7 of the bit sequence are mapped to + byte[n] with bit 8n+i in the sequence mapped to bit 7-i within the byte. + In this implementation bits are numbered from 0 to 7 starting at the + numerically least significant end of each byte (bit n represents 2^n). + + However, Rijndael can be implemented more efficiently using 32-bit + words by packing bytes into words so that bytes 4*n to 4*n+3 are placed + into word[n]. While in principle these bytes can be assembled into words + in any positions, this implementation only supports the two formats in + which bytes in adjacent positions within words also have adjacent byte + numbers. This order is called big-endian if the lowest numbered bytes + in words have the highest numeric significance and little-endian if the + opposite applies. + + This code can work in either order irrespective of the order used by the + machine on which it runs. Normally the internal byte order will be set + to the order of the processor on which the code is to be run but this + define can be used to reverse this in special situations + + WARNING: Assembler code versions rely on PLATFORM_BYTE_ORDER being set. + This define will hence be redefined later (in section 4) if necessary +*/ + +#if 1 +# define ALGORITHM_BYTE_ORDER PLATFORM_BYTE_ORDER +#elif 0 +# define ALGORITHM_BYTE_ORDER IS_LITTLE_ENDIAN +#elif 0 +# define ALGORITHM_BYTE_ORDER IS_BIG_ENDIAN +#else +# error The algorithm byte order is not defined +#endif + +/* 2. VIA ACE SUPPORT */ + +#if !defined(__APPLE__) && defined( __GNUC__ ) && defined( __i386__ ) \ + || defined( _WIN32 ) && defined( _M_IX86 ) \ + && !(defined( _WIN64 ) || defined( _WIN32_WCE ) || defined( _MSC_VER ) && ( _MSC_VER <= 800 )) +# define VIA_ACE_POSSIBLE +#endif + +/* Define this option if support for the VIA ACE is required. This uses + inline assembler instructions and is only implemented for the Microsoft, + Intel and GCC compilers. If VIA ACE is known to be present, then defining + ASSUME_VIA_ACE_PRESENT will remove the ordinary encryption/decryption + code. If USE_VIA_ACE_IF_PRESENT is defined then VIA ACE will be used if + it is detected (both present and enabled) but the normal AES code will + also be present. + + When VIA ACE is to be used, all AES encryption contexts MUST be 16 byte + aligned; other input/output buffers do not need to be 16 byte aligned + but there are very large performance gains if this can be arranged. + VIA ACE also requires the decryption key schedule to be in reverse + order (which later checks below ensure). +*/ + +#if 1 && defined( VIA_ACE_POSSIBLE ) && !defined( USE_VIA_ACE_IF_PRESENT ) +# define USE_VIA_ACE_IF_PRESENT +#endif + +#if 0 && defined( VIA_ACE_POSSIBLE ) && !defined( ASSUME_VIA_ACE_PRESENT ) +# define ASSUME_VIA_ACE_PRESENT +# endif + +/* 3. ASSEMBLER SUPPORT + + This define (which can be on the command line) enables the use of the + assembler code routines for encryption, decryption and key scheduling + as follows: + + ASM_X86_V1C uses the assembler (aes_x86_v1.asm) with large tables for + encryption and decryption and but with key scheduling in C + ASM_X86_V2 uses assembler (aes_x86_v2.asm) with compressed tables for + encryption, decryption and key scheduling + ASM_X86_V2C uses assembler (aes_x86_v2.asm) with compressed tables for + encryption and decryption and but with key scheduling in C + ASM_AMD64_C uses assembler (aes_amd64.asm) with compressed tables for + encryption and decryption and but with key scheduling in C + + Change one 'if 0' below to 'if 1' to select the version or define + as a compilation option. +*/ + +#if 0 && !defined( ASM_X86_V1C ) +# define ASM_X86_V1C +#elif 0 && !defined( ASM_X86_V2 ) +# define ASM_X86_V2 +#elif 0 && !defined( ASM_X86_V2C ) +# define ASM_X86_V2C +#elif 0 && !defined( ASM_AMD64_C ) +# define ASM_AMD64_C +#endif + +#if (defined ( ASM_X86_V1C ) || defined( ASM_X86_V2 ) || defined( ASM_X86_V2C )) \ + && !defined( _M_IX86 ) || defined( ASM_AMD64_C ) && !defined( _M_X64 ) +# error Assembler code is only available for x86 and AMD64 systems +#endif + +/* 4. FAST INPUT/OUTPUT OPERATIONS. + + On some machines it is possible to improve speed by transferring the + bytes in the input and output arrays to and from the internal 32-bit + variables by addressing these arrays as if they are arrays of 32-bit + words. On some machines this will always be possible but there may + be a large performance penalty if the byte arrays are not aligned on + the normal word boundaries. On other machines this technique will + lead to memory access errors when such 32-bit word accesses are not + properly aligned. The option SAFE_IO avoids such problems but will + often be slower on those machines that support misaligned access + (especially so if care is taken to align the input and output byte + arrays on 32-bit word boundaries). If SAFE_IO is not defined it is + assumed that access to byte arrays as if they are arrays of 32-bit + words will not cause problems when such accesses are misaligned. +*/ +#if 1 && !defined( _MSC_VER ) +# define SAFE_IO +#endif + +/* 5. LOOP UNROLLING + + The code for encryption and decrytpion cycles through a number of rounds + that can be implemented either in a loop or by expanding the code into a + long sequence of instructions, the latter producing a larger program but + one that will often be much faster. The latter is called loop unrolling. + There are also potential speed advantages in expanding two iterations in + a loop with half the number of iterations, which is called partial loop + unrolling. The following options allow partial or full loop unrolling + to be set independently for encryption and decryption +*/ +#if 1 +# define ENC_UNROLL FULL +#elif 0 +# define ENC_UNROLL PARTIAL +#else +# define ENC_UNROLL NONE +#endif + +#if 1 +# define DEC_UNROLL FULL +#elif 0 +# define DEC_UNROLL PARTIAL +#else +# define DEC_UNROLL NONE +#endif + +#if 1 +# define ENC_KS_UNROLL +#endif + +#if 1 +# define DEC_KS_UNROLL +#endif + +/* 6. FAST FINITE FIELD OPERATIONS + + If this section is included, tables are used to provide faster finite + field arithmetic (this has no effect if FIXED_TABLES is defined). +*/ +#if 1 +# define FF_TABLES +#endif + +/* 7. INTERNAL STATE VARIABLE FORMAT + + The internal state of Rijndael is stored in a number of local 32-bit + word varaibles which can be defined either as an array or as individual + names variables. Include this section if you want to store these local + varaibles in arrays. Otherwise individual local variables will be used. +*/ +#if 1 +# define ARRAYS +#endif + +/* 8. FIXED OR DYNAMIC TABLES + + When this section is included the tables used by the code are compiled + statically into the binary file. Otherwise the subroutine aes_init() + must be called to compute them before the code is first used. +*/ +#if 1 && !(defined( _MSC_VER ) && ( _MSC_VER <= 800 )) +# define FIXED_TABLES +#endif + +/* 9. MASKING OR CASTING FROM LONGER VALUES TO BYTES + + In some systems it is better to mask longer values to extract bytes + rather than using a cast. This option allows this choice. +*/ +#if 0 +# define to_byte(x) ((uint_8t)(x)) +#else +# define to_byte(x) ((x) & 0xff) +#endif + +/* 10. TABLE ALIGNMENT + + On some sytsems speed will be improved by aligning the AES large lookup + tables on particular boundaries. This define should be set to a power of + two giving the desired alignment. It can be left undefined if alignment + is not needed. This option is specific to the Microsft VC++ compiler - + it seems to sometimes cause trouble for the VC++ version 6 compiler. +*/ + +#if 1 && defined( _MSC_VER ) && ( _MSC_VER >= 1300 ) +# define TABLE_ALIGN 32 +#endif + +/* 11. REDUCE CODE AND TABLE SIZE + + This replaces some expanded macros with function calls if AES_ASM_V2 or + AES_ASM_V2C are defined +*/ + +#if 1 && (defined( ASM_X86_V2 ) || defined( ASM_X86_V2C )) +# define REDUCE_CODE_SIZE +#endif + +/* 12. TABLE OPTIONS + + This cipher proceeds by repeating in a number of cycles known as 'rounds' + which are implemented by a round function which can optionally be speeded + up using tables. The basic tables are each 256 32-bit words, with either + one or four tables being required for each round function depending on + how much speed is required. The encryption and decryption round functions + are different and the last encryption and decrytpion round functions are + different again making four different round functions in all. + + This means that: + 1. Normal encryption and decryption rounds can each use either 0, 1 + or 4 tables and table spaces of 0, 1024 or 4096 bytes each. + 2. The last encryption and decryption rounds can also use either 0, 1 + or 4 tables and table spaces of 0, 1024 or 4096 bytes each. + + Include or exclude the appropriate definitions below to set the number + of tables used by this implementation. +*/ + +#if 1 /* set tables for the normal encryption round */ +# define ENC_ROUND FOUR_TABLES +#elif 0 +# define ENC_ROUND ONE_TABLE +#else +# define ENC_ROUND NO_TABLES +#endif + +#if 1 /* set tables for the last encryption round */ +# define LAST_ENC_ROUND FOUR_TABLES +#elif 0 +# define LAST_ENC_ROUND ONE_TABLE +#else +# define LAST_ENC_ROUND NO_TABLES +#endif + +#if 1 /* set tables for the normal decryption round */ +# define DEC_ROUND FOUR_TABLES +#elif 0 +# define DEC_ROUND ONE_TABLE +#else +# define DEC_ROUND NO_TABLES +#endif + +#if 1 /* set tables for the last decryption round */ +# define LAST_DEC_ROUND FOUR_TABLES +#elif 0 +# define LAST_DEC_ROUND ONE_TABLE +#else +# define LAST_DEC_ROUND NO_TABLES +#endif + +/* The decryption key schedule can be speeded up with tables in the same + way that the round functions can. Include or exclude the following + defines to set this requirement. +*/ +#if 1 +# define KEY_SCHED FOUR_TABLES +#elif 0 +# define KEY_SCHED ONE_TABLE +#else +# define KEY_SCHED NO_TABLES +#endif + +/* ---- END OF USER CONFIGURED OPTIONS ---- */ + +/* VIA ACE support is only available for VC++ and GCC */ + +#if !defined( _MSC_VER ) && !defined( __GNUC__ ) +# if defined( ASSUME_VIA_ACE_PRESENT ) +# undef ASSUME_VIA_ACE_PRESENT +# endif +# if defined( USE_VIA_ACE_IF_PRESENT ) +# undef USE_VIA_ACE_IF_PRESENT +# endif +#endif + +#if defined( ASSUME_VIA_ACE_PRESENT ) && !defined( USE_VIA_ACE_IF_PRESENT ) +# define USE_VIA_ACE_IF_PRESENT +#endif + +#if defined( USE_VIA_ACE_IF_PRESENT ) && !defined ( AES_REV_DKS ) +# define AES_REV_DKS +#endif + +/* Assembler support requires the use of platform byte order */ + +#if ( defined( ASM_X86_V1C ) || defined( ASM_X86_V2C ) || defined( ASM_AMD64_C ) ) \ + && (ALGORITHM_BYTE_ORDER != PLATFORM_BYTE_ORDER) +# undef ALGORITHM_BYTE_ORDER +# define ALGORITHM_BYTE_ORDER PLATFORM_BYTE_ORDER +#endif + +/* In this implementation the columns of the state array are each held in + 32-bit words. The state array can be held in various ways: in an array + of words, in a number of individual word variables or in a number of + processor registers. The following define maps a variable name x and + a column number c to the way the state array variable is to be held. + The first define below maps the state into an array x[c] whereas the + second form maps the state into a number of individual variables x0, + x1, etc. Another form could map individual state colums to machine + register names. +*/ + +#if defined( ARRAYS ) +# define s(x,c) x[c] +#else +# define s(x,c) x##c +#endif + +/* This implementation provides subroutines for encryption, decryption + and for setting the three key lengths (separately) for encryption + and decryption. Since not all functions are needed, masks are set + up here to determine which will be implemented in C +*/ + +#if !defined( AES_ENCRYPT ) +# define EFUNCS_IN_C 0 +#elif defined( ASSUME_VIA_ACE_PRESENT ) || defined( ASM_X86_V1C ) \ + || defined( ASM_X86_V2C ) || defined( ASM_AMD64_C ) +# define EFUNCS_IN_C ENC_KEYING_IN_C +#elif !defined( ASM_X86_V2 ) +# define EFUNCS_IN_C ( ENCRYPTION_IN_C | ENC_KEYING_IN_C ) +#else +# define EFUNCS_IN_C 0 +#endif + +#if !defined( AES_DECRYPT ) +# define DFUNCS_IN_C 0 +#elif defined( ASSUME_VIA_ACE_PRESENT ) || defined( ASM_X86_V1C ) \ + || defined( ASM_X86_V2C ) || defined( ASM_AMD64_C ) +# define DFUNCS_IN_C DEC_KEYING_IN_C +#elif !defined( ASM_X86_V2 ) +# define DFUNCS_IN_C ( DECRYPTION_IN_C | DEC_KEYING_IN_C ) +#else +# define DFUNCS_IN_C 0 +#endif + +#define FUNCS_IN_C ( EFUNCS_IN_C | DFUNCS_IN_C ) + +/* END OF CONFIGURATION OPTIONS */ + +#define RC_LENGTH (5 * (AES_BLOCK_SIZE / 4 - 2)) + +/* Disable or report errors on some combinations of options */ + +#if ENC_ROUND == NO_TABLES && LAST_ENC_ROUND != NO_TABLES +# undef LAST_ENC_ROUND +# define LAST_ENC_ROUND NO_TABLES +#elif ENC_ROUND == ONE_TABLE && LAST_ENC_ROUND == FOUR_TABLES +# undef LAST_ENC_ROUND +# define LAST_ENC_ROUND ONE_TABLE +#endif + +#if ENC_ROUND == NO_TABLES && ENC_UNROLL != NONE +# undef ENC_UNROLL +# define ENC_UNROLL NONE +#endif + +#if DEC_ROUND == NO_TABLES && LAST_DEC_ROUND != NO_TABLES +# undef LAST_DEC_ROUND +# define LAST_DEC_ROUND NO_TABLES +#elif DEC_ROUND == ONE_TABLE && LAST_DEC_ROUND == FOUR_TABLES +# undef LAST_DEC_ROUND +# define LAST_DEC_ROUND ONE_TABLE +#endif + +#if DEC_ROUND == NO_TABLES && DEC_UNROLL != NONE +# undef DEC_UNROLL +# define DEC_UNROLL NONE +#endif + +#if defined( bswap32 ) +# define aes_sw32 bswap32 +#elif defined( bswap_32 ) +# define aes_sw32 bswap_32 +#else +# define brot(x,n) (((uint_32t)(x) << n) | ((uint_32t)(x) >> (32 - n))) +# define aes_sw32(x) ((brot((x),8) & 0x00ff00ff) | (brot((x),24) & 0xff00ff00)) +#endif + +/* upr(x,n): rotates bytes within words by n positions, moving bytes to + higher index positions with wrap around into low positions + ups(x,n): moves bytes by n positions to higher index positions in + words but without wrap around + bval(x,n): extracts a byte from a word + + WARNING: The definitions given here are intended only for use with + unsigned variables and with shift counts that are compile + time constants +*/ + +#if ( ALGORITHM_BYTE_ORDER == IS_LITTLE_ENDIAN ) +# define upr(x,n) (((uint_32t)(x) << (8 * (n))) | ((uint_32t)(x) >> (32 - 8 * (n)))) +# define ups(x,n) ((uint_32t) (x) << (8 * (n))) +# define bval(x,n) to_byte((x) >> (8 * (n))) +# define bytes2word(b0, b1, b2, b3) \ + (((uint_32t)(b3) << 24) | ((uint_32t)(b2) << 16) | ((uint_32t)(b1) << 8) | (b0)) +#endif + +#if ( ALGORITHM_BYTE_ORDER == IS_BIG_ENDIAN ) +# define upr(x,n) (((uint_32t)(x) >> (8 * (n))) | ((uint_32t)(x) << (32 - 8 * (n)))) +# define ups(x,n) ((uint_32t) (x) >> (8 * (n))) +# define bval(x,n) to_byte((x) >> (24 - 8 * (n))) +# define bytes2word(b0, b1, b2, b3) \ + (((uint_32t)(b0) << 24) | ((uint_32t)(b1) << 16) | ((uint_32t)(b2) << 8) | (b3)) +#endif + +#if defined( SAFE_IO ) +# define word_in(x,c) bytes2word(((const uint_8t*)(x)+4*c)[0], ((const uint_8t*)(x)+4*c)[1], \ + ((const uint_8t*)(x)+4*c)[2], ((const uint_8t*)(x)+4*c)[3]) +# define word_out(x,c,v) { ((uint_8t*)(x)+4*c)[0] = bval(v,0); ((uint_8t*)(x)+4*c)[1] = bval(v,1); \ + ((uint_8t*)(x)+4*c)[2] = bval(v,2); ((uint_8t*)(x)+4*c)[3] = bval(v,3); } +#elif ( ALGORITHM_BYTE_ORDER == PLATFORM_BYTE_ORDER ) +# define word_in(x,c) (*((uint_32t*)(x)+(c))) +# define word_out(x,c,v) (*((uint_32t*)(x)+(c)) = (v)) +#else +# define word_in(x,c) aes_sw32(*((uint_32t*)(x)+(c))) +# define word_out(x,c,v) (*((uint_32t*)(x)+(c)) = aes_sw32(v)) +#endif + +/* the finite field modular polynomial and elements */ + +#define WPOLY 0x011b +#define BPOLY 0x1b + +/* multiply four bytes in GF(2^8) by 'x' {02} in parallel */ + +#define gf_c1 0x80808080 +#define gf_c2 0x7f7f7f7f +#define gf_mulx(x) ((((x) & gf_c2) << 1) ^ ((((x) & gf_c1) >> 7) * BPOLY)) + +/* The following defines provide alternative definitions of gf_mulx that might + give improved performance if a fast 32-bit multiply is not available. Note + that a temporary variable u needs to be defined where gf_mulx is used. + +#define gf_mulx(x) (u = (x) & gf_c1, u |= (u >> 1), ((x) & gf_c2) << 1) ^ ((u >> 3) | (u >> 6)) +#define gf_c4 (0x01010101 * BPOLY) +#define gf_mulx(x) (u = (x) & gf_c1, ((x) & gf_c2) << 1) ^ ((u - (u >> 7)) & gf_c4) +*/ + +/* Work out which tables are needed for the different options */ + +#if defined( ASM_X86_V1C ) +# if defined( ENC_ROUND ) +# undef ENC_ROUND +# endif +# define ENC_ROUND FOUR_TABLES +# if defined( LAST_ENC_ROUND ) +# undef LAST_ENC_ROUND +# endif +# define LAST_ENC_ROUND FOUR_TABLES +# if defined( DEC_ROUND ) +# undef DEC_ROUND +# endif +# define DEC_ROUND FOUR_TABLES +# if defined( LAST_DEC_ROUND ) +# undef LAST_DEC_ROUND +# endif +# define LAST_DEC_ROUND FOUR_TABLES +# if defined( KEY_SCHED ) +# undef KEY_SCHED +# define KEY_SCHED FOUR_TABLES +# endif +#endif + +#if ( FUNCS_IN_C & ENCRYPTION_IN_C ) || defined( ASM_X86_V1C ) +# if ENC_ROUND == ONE_TABLE +# define FT1_SET +# elif ENC_ROUND == FOUR_TABLES +# define FT4_SET +# else +# define SBX_SET +# endif +# if LAST_ENC_ROUND == ONE_TABLE +# define FL1_SET +# elif LAST_ENC_ROUND == FOUR_TABLES +# define FL4_SET +# elif !defined( SBX_SET ) +# define SBX_SET +# endif +#endif + +#if ( FUNCS_IN_C & DECRYPTION_IN_C ) || defined( ASM_X86_V1C ) +# if DEC_ROUND == ONE_TABLE +# define IT1_SET +# elif DEC_ROUND == FOUR_TABLES +# define IT4_SET +# else +# define ISB_SET +# endif +# if LAST_DEC_ROUND == ONE_TABLE +# define IL1_SET +# elif LAST_DEC_ROUND == FOUR_TABLES +# define IL4_SET +# elif !defined(ISB_SET) +# define ISB_SET +# endif +#endif + +#if !(defined( REDUCE_CODE_SIZE ) && (defined( ASM_X86_V2 ) || defined( ASM_X86_V2C ))) +# if ((FUNCS_IN_C & ENC_KEYING_IN_C) || (FUNCS_IN_C & DEC_KEYING_IN_C)) +# if KEY_SCHED == ONE_TABLE +# if !defined( FL1_SET ) && !defined( FL4_SET ) +# define LS1_SET +# endif +# elif KEY_SCHED == FOUR_TABLES +# if !defined( FL4_SET ) +# define LS4_SET +# endif +# elif !defined( SBX_SET ) +# define SBX_SET +# endif +# endif +# if (FUNCS_IN_C & DEC_KEYING_IN_C) +# if KEY_SCHED == ONE_TABLE +# define IM1_SET +# elif KEY_SCHED == FOUR_TABLES +# define IM4_SET +# elif !defined( SBX_SET ) +# define SBX_SET +# endif +# endif +#endif + +/* generic definitions of Rijndael macros that use tables */ + +#define no_table(x,box,vf,rf,c) bytes2word( \ + box[bval(vf(x,0,c),rf(0,c))], \ + box[bval(vf(x,1,c),rf(1,c))], \ + box[bval(vf(x,2,c),rf(2,c))], \ + box[bval(vf(x,3,c),rf(3,c))]) + +#define one_table(x,op,tab,vf,rf,c) \ + ( tab[bval(vf(x,0,c),rf(0,c))] \ + ^ op(tab[bval(vf(x,1,c),rf(1,c))],1) \ + ^ op(tab[bval(vf(x,2,c),rf(2,c))],2) \ + ^ op(tab[bval(vf(x,3,c),rf(3,c))],3)) + +#define four_tables(x,tab,vf,rf,c) \ + ( tab[0][bval(vf(x,0,c),rf(0,c))] \ + ^ tab[1][bval(vf(x,1,c),rf(1,c))] \ + ^ tab[2][bval(vf(x,2,c),rf(2,c))] \ + ^ tab[3][bval(vf(x,3,c),rf(3,c))]) + +#define vf1(x,r,c) (x) +#define rf1(r,c) (r) +#define rf2(r,c) ((8+r-c)&3) + +/* perform forward and inverse column mix operation on four bytes in long word x in */ +/* parallel. NOTE: x must be a simple variable, NOT an expression in these macros. */ + +#if !(defined( REDUCE_CODE_SIZE ) && (defined( ASM_X86_V2 ) || defined( ASM_X86_V2C ))) + +#if defined( FM4_SET ) /* not currently used */ +# define fwd_mcol(x) four_tables(x,t_use(f,m),vf1,rf1,0) +#elif defined( FM1_SET ) /* not currently used */ +# define fwd_mcol(x) one_table(x,upr,t_use(f,m),vf1,rf1,0) +#else +# define dec_fmvars uint_32t g2 +# define fwd_mcol(x) (g2 = gf_mulx(x), g2 ^ upr((x) ^ g2, 3) ^ upr((x), 2) ^ upr((x), 1)) +#endif + +#if defined( IM4_SET ) +# define inv_mcol(x) four_tables(x,t_use(i,m),vf1,rf1,0) +#elif defined( IM1_SET ) +# define inv_mcol(x) one_table(x,upr,t_use(i,m),vf1,rf1,0) +#else +# define dec_imvars uint_32t g2, g4, g9 +# define inv_mcol(x) (g2 = gf_mulx(x), g4 = gf_mulx(g2), g9 = (x) ^ gf_mulx(g4), g4 ^= g9, \ + (x) ^ g2 ^ g4 ^ upr(g2 ^ g9, 3) ^ upr(g4, 2) ^ upr(g9, 1)) +#endif + +#if defined( FL4_SET ) +# define ls_box(x,c) four_tables(x,t_use(f,l),vf1,rf2,c) +#elif defined( LS4_SET ) +# define ls_box(x,c) four_tables(x,t_use(l,s),vf1,rf2,c) +#elif defined( FL1_SET ) +# define ls_box(x,c) one_table(x,upr,t_use(f,l),vf1,rf2,c) +#elif defined( LS1_SET ) +# define ls_box(x,c) one_table(x,upr,t_use(l,s),vf1,rf2,c) +#else +# define ls_box(x,c) no_table(x,t_use(s,box),vf1,rf2,c) +#endif + +#endif + +#if defined( ASM_X86_V1C ) && defined( AES_DECRYPT ) && !defined( ISB_SET ) +# define ISB_SET +#endif + +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aestab.c b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aestab.c new file mode 100755 index 0000000..6d193af --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aestab.c @@ -0,0 +1,391 @@ +/* +--------------------------------------------------------------------------- +Copyright (c) 1998-2010, Brian Gladman, Worcester, UK. All rights reserved. + +The redistribution and use of this software (with or without changes) +is allowed without the payment of fees or royalties provided that: + + source code distributions include the above copyright notice, this + list of conditions and the following disclaimer; + + binary distributions include the above copyright notice, this list + of conditions and the following disclaimer in their documentation. + +This software is provided 'as is' with no explicit or implied warranties +in respect of its operation, including, but not limited to, correctness +and fitness for purpose. +--------------------------------------------------------------------------- +Issue Date: 20/12/2007 +*/ + +#define DO_TABLES + +#include "aes.h" +#include "aesopt.h" + +#if defined(FIXED_TABLES) + +#define sb_data(w) {\ + w(0x63), w(0x7c), w(0x77), w(0x7b), w(0xf2), w(0x6b), w(0x6f), w(0xc5),\ + w(0x30), w(0x01), w(0x67), w(0x2b), w(0xfe), w(0xd7), w(0xab), w(0x76),\ + w(0xca), w(0x82), w(0xc9), w(0x7d), w(0xfa), w(0x59), w(0x47), w(0xf0),\ + w(0xad), w(0xd4), w(0xa2), w(0xaf), w(0x9c), w(0xa4), w(0x72), w(0xc0),\ + w(0xb7), w(0xfd), w(0x93), w(0x26), w(0x36), w(0x3f), w(0xf7), w(0xcc),\ + w(0x34), w(0xa5), w(0xe5), w(0xf1), w(0x71), w(0xd8), w(0x31), w(0x15),\ + w(0x04), w(0xc7), w(0x23), w(0xc3), w(0x18), w(0x96), w(0x05), w(0x9a),\ + w(0x07), w(0x12), w(0x80), w(0xe2), w(0xeb), w(0x27), w(0xb2), w(0x75),\ + w(0x09), w(0x83), w(0x2c), w(0x1a), w(0x1b), w(0x6e), w(0x5a), w(0xa0),\ + w(0x52), w(0x3b), w(0xd6), w(0xb3), w(0x29), w(0xe3), w(0x2f), w(0x84),\ + w(0x53), w(0xd1), w(0x00), w(0xed), w(0x20), w(0xfc), w(0xb1), w(0x5b),\ + w(0x6a), w(0xcb), w(0xbe), w(0x39), w(0x4a), w(0x4c), w(0x58), w(0xcf),\ + w(0xd0), w(0xef), w(0xaa), w(0xfb), w(0x43), w(0x4d), w(0x33), w(0x85),\ + w(0x45), w(0xf9), w(0x02), w(0x7f), w(0x50), w(0x3c), w(0x9f), w(0xa8),\ + w(0x51), w(0xa3), w(0x40), w(0x8f), w(0x92), w(0x9d), w(0x38), w(0xf5),\ + w(0xbc), w(0xb6), w(0xda), w(0x21), w(0x10), w(0xff), w(0xf3), w(0xd2),\ + w(0xcd), w(0x0c), w(0x13), w(0xec), w(0x5f), w(0x97), w(0x44), w(0x17),\ + w(0xc4), w(0xa7), w(0x7e), w(0x3d), w(0x64), w(0x5d), w(0x19), w(0x73),\ + w(0x60), w(0x81), w(0x4f), w(0xdc), w(0x22), w(0x2a), w(0x90), w(0x88),\ + w(0x46), w(0xee), w(0xb8), w(0x14), w(0xde), w(0x5e), w(0x0b), w(0xdb),\ + w(0xe0), w(0x32), w(0x3a), w(0x0a), w(0x49), w(0x06), w(0x24), w(0x5c),\ + w(0xc2), w(0xd3), w(0xac), w(0x62), w(0x91), w(0x95), w(0xe4), w(0x79),\ + w(0xe7), w(0xc8), w(0x37), w(0x6d), w(0x8d), w(0xd5), w(0x4e), w(0xa9),\ + w(0x6c), w(0x56), w(0xf4), w(0xea), w(0x65), w(0x7a), w(0xae), w(0x08),\ + w(0xba), w(0x78), w(0x25), w(0x2e), w(0x1c), w(0xa6), w(0xb4), w(0xc6),\ + w(0xe8), w(0xdd), w(0x74), w(0x1f), w(0x4b), w(0xbd), w(0x8b), w(0x8a),\ + w(0x70), w(0x3e), w(0xb5), w(0x66), w(0x48), w(0x03), w(0xf6), w(0x0e),\ + w(0x61), w(0x35), w(0x57), w(0xb9), w(0x86), w(0xc1), w(0x1d), w(0x9e),\ + w(0xe1), w(0xf8), w(0x98), w(0x11), w(0x69), w(0xd9), w(0x8e), w(0x94),\ + w(0x9b), w(0x1e), w(0x87), w(0xe9), w(0xce), w(0x55), w(0x28), w(0xdf),\ + w(0x8c), w(0xa1), w(0x89), w(0x0d), w(0xbf), w(0xe6), w(0x42), w(0x68),\ + w(0x41), w(0x99), w(0x2d), w(0x0f), w(0xb0), w(0x54), w(0xbb), w(0x16) } + +#define isb_data(w) {\ + w(0x52), w(0x09), w(0x6a), w(0xd5), w(0x30), w(0x36), w(0xa5), w(0x38),\ + w(0xbf), w(0x40), w(0xa3), w(0x9e), w(0x81), w(0xf3), w(0xd7), w(0xfb),\ + w(0x7c), w(0xe3), w(0x39), w(0x82), w(0x9b), w(0x2f), w(0xff), w(0x87),\ + w(0x34), w(0x8e), w(0x43), w(0x44), w(0xc4), w(0xde), w(0xe9), w(0xcb),\ + w(0x54), w(0x7b), w(0x94), w(0x32), w(0xa6), w(0xc2), w(0x23), w(0x3d),\ + w(0xee), w(0x4c), w(0x95), w(0x0b), w(0x42), w(0xfa), w(0xc3), w(0x4e),\ + w(0x08), w(0x2e), w(0xa1), w(0x66), w(0x28), w(0xd9), w(0x24), w(0xb2),\ + w(0x76), w(0x5b), w(0xa2), w(0x49), w(0x6d), w(0x8b), w(0xd1), w(0x25),\ + w(0x72), w(0xf8), w(0xf6), w(0x64), w(0x86), w(0x68), w(0x98), w(0x16),\ + w(0xd4), w(0xa4), w(0x5c), w(0xcc), w(0x5d), w(0x65), w(0xb6), w(0x92),\ + w(0x6c), w(0x70), w(0x48), w(0x50), w(0xfd), w(0xed), w(0xb9), w(0xda),\ + w(0x5e), w(0x15), w(0x46), w(0x57), w(0xa7), w(0x8d), w(0x9d), w(0x84),\ + w(0x90), w(0xd8), w(0xab), w(0x00), w(0x8c), w(0xbc), w(0xd3), w(0x0a),\ + w(0xf7), w(0xe4), w(0x58), w(0x05), w(0xb8), w(0xb3), w(0x45), w(0x06),\ + w(0xd0), w(0x2c), w(0x1e), w(0x8f), w(0xca), w(0x3f), w(0x0f), w(0x02),\ + w(0xc1), w(0xaf), w(0xbd), w(0x03), w(0x01), w(0x13), w(0x8a), w(0x6b),\ + w(0x3a), w(0x91), w(0x11), w(0x41), w(0x4f), w(0x67), w(0xdc), w(0xea),\ + w(0x97), w(0xf2), w(0xcf), w(0xce), w(0xf0), w(0xb4), w(0xe6), w(0x73),\ + w(0x96), w(0xac), w(0x74), w(0x22), w(0xe7), w(0xad), w(0x35), w(0x85),\ + w(0xe2), w(0xf9), w(0x37), w(0xe8), w(0x1c), w(0x75), w(0xdf), w(0x6e),\ + w(0x47), w(0xf1), w(0x1a), w(0x71), w(0x1d), w(0x29), w(0xc5), w(0x89),\ + w(0x6f), w(0xb7), w(0x62), w(0x0e), w(0xaa), w(0x18), w(0xbe), w(0x1b),\ + w(0xfc), w(0x56), w(0x3e), w(0x4b), w(0xc6), w(0xd2), w(0x79), w(0x20),\ + w(0x9a), w(0xdb), w(0xc0), w(0xfe), w(0x78), w(0xcd), w(0x5a), w(0xf4),\ + w(0x1f), w(0xdd), w(0xa8), w(0x33), w(0x88), w(0x07), w(0xc7), w(0x31),\ + w(0xb1), w(0x12), w(0x10), w(0x59), w(0x27), w(0x80), w(0xec), w(0x5f),\ + w(0x60), w(0x51), w(0x7f), w(0xa9), w(0x19), w(0xb5), w(0x4a), w(0x0d),\ + w(0x2d), w(0xe5), w(0x7a), w(0x9f), w(0x93), w(0xc9), w(0x9c), w(0xef),\ + w(0xa0), w(0xe0), w(0x3b), w(0x4d), w(0xae), w(0x2a), w(0xf5), w(0xb0),\ + w(0xc8), w(0xeb), w(0xbb), w(0x3c), w(0x83), w(0x53), w(0x99), w(0x61),\ + w(0x17), w(0x2b), w(0x04), w(0x7e), w(0xba), w(0x77), w(0xd6), w(0x26),\ + w(0xe1), w(0x69), w(0x14), w(0x63), w(0x55), w(0x21), w(0x0c), w(0x7d) } + +#define mm_data(w) {\ + w(0x00), w(0x01), w(0x02), w(0x03), w(0x04), w(0x05), w(0x06), w(0x07),\ + w(0x08), w(0x09), w(0x0a), w(0x0b), w(0x0c), w(0x0d), w(0x0e), w(0x0f),\ + w(0x10), w(0x11), w(0x12), w(0x13), w(0x14), w(0x15), w(0x16), w(0x17),\ + w(0x18), w(0x19), w(0x1a), w(0x1b), w(0x1c), w(0x1d), w(0x1e), w(0x1f),\ + w(0x20), w(0x21), w(0x22), w(0x23), w(0x24), w(0x25), w(0x26), w(0x27),\ + w(0x28), w(0x29), w(0x2a), w(0x2b), w(0x2c), w(0x2d), w(0x2e), w(0x2f),\ + w(0x30), w(0x31), w(0x32), w(0x33), w(0x34), w(0x35), w(0x36), w(0x37),\ + w(0x38), w(0x39), w(0x3a), w(0x3b), w(0x3c), w(0x3d), w(0x3e), w(0x3f),\ + w(0x40), w(0x41), w(0x42), w(0x43), w(0x44), w(0x45), w(0x46), w(0x47),\ + w(0x48), w(0x49), w(0x4a), w(0x4b), w(0x4c), w(0x4d), w(0x4e), w(0x4f),\ + w(0x50), w(0x51), w(0x52), w(0x53), w(0x54), w(0x55), w(0x56), w(0x57),\ + w(0x58), w(0x59), w(0x5a), w(0x5b), w(0x5c), w(0x5d), w(0x5e), w(0x5f),\ + w(0x60), w(0x61), w(0x62), w(0x63), w(0x64), w(0x65), w(0x66), w(0x67),\ + w(0x68), w(0x69), w(0x6a), w(0x6b), w(0x6c), w(0x6d), w(0x6e), w(0x6f),\ + w(0x70), w(0x71), w(0x72), w(0x73), w(0x74), w(0x75), w(0x76), w(0x77),\ + w(0x78), w(0x79), w(0x7a), w(0x7b), w(0x7c), w(0x7d), w(0x7e), w(0x7f),\ + w(0x80), w(0x81), w(0x82), w(0x83), w(0x84), w(0x85), w(0x86), w(0x87),\ + w(0x88), w(0x89), w(0x8a), w(0x8b), w(0x8c), w(0x8d), w(0x8e), w(0x8f),\ + w(0x90), w(0x91), w(0x92), w(0x93), w(0x94), w(0x95), w(0x96), w(0x97),\ + w(0x98), w(0x99), w(0x9a), w(0x9b), w(0x9c), w(0x9d), w(0x9e), w(0x9f),\ + w(0xa0), w(0xa1), w(0xa2), w(0xa3), w(0xa4), w(0xa5), w(0xa6), w(0xa7),\ + w(0xa8), w(0xa9), w(0xaa), w(0xab), w(0xac), w(0xad), w(0xae), w(0xaf),\ + w(0xb0), w(0xb1), w(0xb2), w(0xb3), w(0xb4), w(0xb5), w(0xb6), w(0xb7),\ + w(0xb8), w(0xb9), w(0xba), w(0xbb), w(0xbc), w(0xbd), w(0xbe), w(0xbf),\ + w(0xc0), w(0xc1), w(0xc2), w(0xc3), w(0xc4), w(0xc5), w(0xc6), w(0xc7),\ + w(0xc8), w(0xc9), w(0xca), w(0xcb), w(0xcc), w(0xcd), w(0xce), w(0xcf),\ + w(0xd0), w(0xd1), w(0xd2), w(0xd3), w(0xd4), w(0xd5), w(0xd6), w(0xd7),\ + w(0xd8), w(0xd9), w(0xda), w(0xdb), w(0xdc), w(0xdd), w(0xde), w(0xdf),\ + w(0xe0), w(0xe1), w(0xe2), w(0xe3), w(0xe4), w(0xe5), w(0xe6), w(0xe7),\ + w(0xe8), w(0xe9), w(0xea), w(0xeb), w(0xec), w(0xed), w(0xee), w(0xef),\ + w(0xf0), w(0xf1), w(0xf2), w(0xf3), w(0xf4), w(0xf5), w(0xf6), w(0xf7),\ + w(0xf8), w(0xf9), w(0xfa), w(0xfb), w(0xfc), w(0xfd), w(0xfe), w(0xff) } + +#define rc_data(w) {\ + w(0x01), w(0x02), w(0x04), w(0x08), w(0x10),w(0x20), w(0x40), w(0x80),\ + w(0x1b), w(0x36) } + +#define h0(x) (x) + +#define w0(p) bytes2word(p, 0, 0, 0) +#define w1(p) bytes2word(0, p, 0, 0) +#define w2(p) bytes2word(0, 0, p, 0) +#define w3(p) bytes2word(0, 0, 0, p) + +#define u0(p) bytes2word(f2(p), p, p, f3(p)) +#define u1(p) bytes2word(f3(p), f2(p), p, p) +#define u2(p) bytes2word(p, f3(p), f2(p), p) +#define u3(p) bytes2word(p, p, f3(p), f2(p)) + +#define v0(p) bytes2word(fe(p), f9(p), fd(p), fb(p)) +#define v1(p) bytes2word(fb(p), fe(p), f9(p), fd(p)) +#define v2(p) bytes2word(fd(p), fb(p), fe(p), f9(p)) +#define v3(p) bytes2word(f9(p), fd(p), fb(p), fe(p)) + +#endif + +#if defined(FIXED_TABLES) || !defined(FF_TABLES) + +#define f2(x) ((x<<1) ^ (((x>>7) & 1) * WPOLY)) +#define f4(x) ((x<<2) ^ (((x>>6) & 1) * WPOLY) ^ (((x>>6) & 2) * WPOLY)) +#define f8(x) ((x<<3) ^ (((x>>5) & 1) * WPOLY) ^ (((x>>5) & 2) * WPOLY) \ + ^ (((x>>5) & 4) * WPOLY)) +#define f3(x) (f2(x) ^ x) +#define f9(x) (f8(x) ^ x) +#define fb(x) (f8(x) ^ f2(x) ^ x) +#define fd(x) (f8(x) ^ f4(x) ^ x) +#define fe(x) (f8(x) ^ f4(x) ^ f2(x)) + +#else + +#define f2(x) ((x) ? pow[log[x] + 0x19] : 0) +#define f3(x) ((x) ? pow[log[x] + 0x01] : 0) +#define f9(x) ((x) ? pow[log[x] + 0xc7] : 0) +#define fb(x) ((x) ? pow[log[x] + 0x68] : 0) +#define fd(x) ((x) ? pow[log[x] + 0xee] : 0) +#define fe(x) ((x) ? pow[log[x] + 0xdf] : 0) + +#endif + +#include "aestab.h" + +#if defined(__cplusplus) +extern "C" +{ +#endif + +#if defined(FIXED_TABLES) + +/* implemented in case of wrong call for fixed tables */ + +AES_RETURN aes_init(void) +{ + return EXIT_SUCCESS; +} + +#else /* Generate the tables for the dynamic table option */ + +#if defined(FF_TABLES) + +#define gf_inv(x) ((x) ? pow[ 255 - log[x]] : 0) + +#else + +/* It will generally be sensible to use tables to compute finite + field multiplies and inverses but where memory is scarse this + code might sometimes be better. But it only has effect during + initialisation so its pretty unimportant in overall terms. +*/ + +/* return 2 ^ (n - 1) where n is the bit number of the highest bit + set in x with x in the range 1 < x < 0x00000200. This form is + used so that locals within fi can be bytes rather than words +*/ + +static uint_8t hibit(const uint_32t x) +{ uint_8t r = (uint_8t)((x >> 1) | (x >> 2)); + + r |= (r >> 2); + r |= (r >> 4); + return (r + 1) >> 1; +} + +/* return the inverse of the finite field element x */ + +static uint_8t gf_inv(const uint_8t x) +{ uint_8t p1 = x, p2 = BPOLY, n1 = hibit(x), n2 = 0x80, v1 = 1, v2 = 0; + + if(x < 2) + return x; + + for( ; ; ) + { + if(n1) + while(n2 >= n1) /* divide polynomial p2 by p1 */ + { + n2 /= n1; /* shift smaller polynomial left */ + p2 ^= (p1 * n2) & 0xff; /* and remove from larger one */ + v2 ^= v1 * n2; /* shift accumulated value and */ + n2 = hibit(p2); /* add into result */ + } + else + return v1; + + if(n2) /* repeat with values swapped */ + while(n1 >= n2) + { + n1 /= n2; + p1 ^= p2 * n1; + v1 ^= v2 * n1; + n1 = hibit(p1); + } + else + return v2; + } +} + +#endif + +/* The forward and inverse affine transformations used in the S-box */ +uint_8t fwd_affine(const uint_8t x) +{ uint_32t w = x; + w ^= (w << 1) ^ (w << 2) ^ (w << 3) ^ (w << 4); + return 0x63 ^ ((w ^ (w >> 8)) & 0xff); +} + +uint_8t inv_affine(const uint_8t x) +{ uint_32t w = x; + w = (w << 1) ^ (w << 3) ^ (w << 6); + return 0x05 ^ ((w ^ (w >> 8)) & 0xff); +} + +static int init = 0; + +AES_RETURN aes_init(void) +{ uint_32t i, w; + +#if defined(FF_TABLES) + + uint_8t pow[512], log[256]; + + if(init) + return EXIT_SUCCESS; + /* log and power tables for GF(2^8) finite field with + WPOLY as modular polynomial - the simplest primitive + root is 0x03, used here to generate the tables + */ + + i = 0; w = 1; + do + { + pow[i] = (uint_8t)w; + pow[i + 255] = (uint_8t)w; + log[w] = (uint_8t)i++; + w ^= (w << 1) ^ (w & 0x80 ? WPOLY : 0); + } + while (w != 1); + +#else + if(init) + return EXIT_SUCCESS; +#endif + + for(i = 0, w = 1; i < RC_LENGTH; ++i) + { + t_set(r,c)[i] = bytes2word(w, 0, 0, 0); + w = f2(w); + } + + for(i = 0; i < 256; ++i) + { uint_8t b; + + b = fwd_affine(gf_inv((uint_8t)i)); + w = bytes2word(f2(b), b, b, f3(b)); + +#if defined( SBX_SET ) + t_set(s,box)[i] = b; +#endif + +#if defined( FT1_SET ) /* tables for a normal encryption round */ + t_set(f,n)[i] = w; +#endif +#if defined( FT4_SET ) + t_set(f,n)[0][i] = w; + t_set(f,n)[1][i] = upr(w,1); + t_set(f,n)[2][i] = upr(w,2); + t_set(f,n)[3][i] = upr(w,3); +#endif + w = bytes2word(b, 0, 0, 0); + +#if defined( FL1_SET ) /* tables for last encryption round (may also */ + t_set(f,l)[i] = w; /* be used in the key schedule) */ +#endif +#if defined( FL4_SET ) + t_set(f,l)[0][i] = w; + t_set(f,l)[1][i] = upr(w,1); + t_set(f,l)[2][i] = upr(w,2); + t_set(f,l)[3][i] = upr(w,3); +#endif + +#if defined( LS1_SET ) /* table for key schedule if t_set(f,l) above is*/ + t_set(l,s)[i] = w; /* not of the required form */ +#endif +#if defined( LS4_SET ) + t_set(l,s)[0][i] = w; + t_set(l,s)[1][i] = upr(w,1); + t_set(l,s)[2][i] = upr(w,2); + t_set(l,s)[3][i] = upr(w,3); +#endif + + b = gf_inv(inv_affine((uint_8t)i)); + w = bytes2word(fe(b), f9(b), fd(b), fb(b)); + +#if defined( IM1_SET ) /* tables for the inverse mix column operation */ + t_set(i,m)[b] = w; +#endif +#if defined( IM4_SET ) + t_set(i,m)[0][b] = w; + t_set(i,m)[1][b] = upr(w,1); + t_set(i,m)[2][b] = upr(w,2); + t_set(i,m)[3][b] = upr(w,3); +#endif + +#if defined( ISB_SET ) + t_set(i,box)[i] = b; +#endif +#if defined( IT1_SET ) /* tables for a normal decryption round */ + t_set(i,n)[i] = w; +#endif +#if defined( IT4_SET ) + t_set(i,n)[0][i] = w; + t_set(i,n)[1][i] = upr(w,1); + t_set(i,n)[2][i] = upr(w,2); + t_set(i,n)[3][i] = upr(w,3); +#endif + w = bytes2word(b, 0, 0, 0); +#if defined( IL1_SET ) /* tables for last decryption round */ + t_set(i,l)[i] = w; +#endif +#if defined( IL4_SET ) + t_set(i,l)[0][i] = w; + t_set(i,l)[1][i] = upr(w,1); + t_set(i,l)[2][i] = upr(w,2); + t_set(i,l)[3][i] = upr(w,3); +#endif + } + init = 1; + return EXIT_SUCCESS; +} + +#endif + +#if defined(__cplusplus) +} +#endif + diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aestab.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aestab.h new file mode 100755 index 0000000..21fc736 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/aestab.h @@ -0,0 +1,173 @@ +/* +--------------------------------------------------------------------------- +Copyright (c) 1998-2010, Brian Gladman, Worcester, UK. All rights reserved. + +The redistribution and use of this software (with or without changes) +is allowed without the payment of fees or royalties provided that: + + source code distributions include the above copyright notice, this + list of conditions and the following disclaimer; + + binary distributions include the above copyright notice, this list + of conditions and the following disclaimer in their documentation. + +This software is provided 'as is' with no explicit or implied warranties +in respect of its operation, including, but not limited to, correctness +and fitness for purpose. +--------------------------------------------------------------------------- +Issue Date: 20/12/2007 + + This file contains the code for declaring the tables needed to implement + AES. The file aesopt.h is assumed to be included before this header file. + If there are no global variables, the definitions here can be used to put + the AES tables in a structure so that a pointer can then be added to the + AES context to pass them to the AES routines that need them. If this + facility is used, the calling program has to ensure that this pointer is + managed appropriately. In particular, the value of the t_dec(in,it) item + in the table structure must be set to zero in order to ensure that the + tables are initialised. In practice the three code sequences in aeskey.c + that control the calls to aes_init() and the aes_init() routine itself will + have to be changed for a specific implementation. If global variables are + available it will generally be preferable to use them with the precomputed + FIXED_TABLES option that uses static global tables. + + The following defines can be used to control the way the tables + are defined, initialised and used in embedded environments that + require special features for these purposes + + the 't_dec' construction is used to declare fixed table arrays + the 't_set' construction is used to set fixed table values + the 't_use' construction is used to access fixed table values + + 256 byte tables: + + t_xxx(s,box) => forward S box + t_xxx(i,box) => inverse S box + + 256 32-bit word OR 4 x 256 32-bit word tables: + + t_xxx(f,n) => forward normal round + t_xxx(f,l) => forward last round + t_xxx(i,n) => inverse normal round + t_xxx(i,l) => inverse last round + t_xxx(l,s) => key schedule table + t_xxx(i,m) => key schedule table + + Other variables and tables: + + t_xxx(r,c) => the rcon table +*/ + +#if !defined( _AESTAB_H ) +#define _AESTAB_H + +#if defined(__cplusplus) +extern "C" { +#endif + +#define t_dec(m,n) t_##m##n +#define t_set(m,n) t_##m##n +#define t_use(m,n) t_##m##n + +#if defined(FIXED_TABLES) +# if !defined( __GNUC__ ) && (defined( __MSDOS__ ) || defined( __WIN16__ )) +/* make tables far data to avoid using too much DGROUP space (PG) */ +# define CONST const far +# else +# define CONST const +# endif +#else +# define CONST +#endif + +#if defined(DO_TABLES) +# define EXTERN +#else +# define EXTERN extern +#endif + +#if defined(_MSC_VER) && defined(TABLE_ALIGN) +#define ALIGN __declspec(align(TABLE_ALIGN)) +#else +#define ALIGN +#endif + +#if defined( __WATCOMC__ ) && ( __WATCOMC__ >= 1100 ) +# define XP_DIR __cdecl +#else +# define XP_DIR +#endif + +#if defined(DO_TABLES) && defined(FIXED_TABLES) +#define d_1(t,n,b,e) EXTERN ALIGN CONST XP_DIR t n[256] = b(e) +#define d_4(t,n,b,e,f,g,h) EXTERN ALIGN CONST XP_DIR t n[4][256] = { b(e), b(f), b(g), b(h) } +EXTERN ALIGN CONST uint_32t t_dec(r,c)[RC_LENGTH] = rc_data(w0); +#else +#define d_1(t,n,b,e) EXTERN ALIGN CONST XP_DIR t n[256] +#define d_4(t,n,b,e,f,g,h) EXTERN ALIGN CONST XP_DIR t n[4][256] +EXTERN ALIGN CONST uint_32t t_dec(r,c)[RC_LENGTH]; +#endif + +#if defined( SBX_SET ) + d_1(uint_8t, t_dec(s,box), sb_data, h0); +#endif +#if defined( ISB_SET ) + d_1(uint_8t, t_dec(i,box), isb_data, h0); +#endif + +#if defined( FT1_SET ) + d_1(uint_32t, t_dec(f,n), sb_data, u0); +#endif +#if defined( FT4_SET ) + d_4(uint_32t, t_dec(f,n), sb_data, u0, u1, u2, u3); +#endif + +#if defined( FL1_SET ) + d_1(uint_32t, t_dec(f,l), sb_data, w0); +#endif +#if defined( FL4_SET ) + d_4(uint_32t, t_dec(f,l), sb_data, w0, w1, w2, w3); +#endif + +#if defined( IT1_SET ) + d_1(uint_32t, t_dec(i,n), isb_data, v0); +#endif +#if defined( IT4_SET ) + d_4(uint_32t, t_dec(i,n), isb_data, v0, v1, v2, v3); +#endif + +#if defined( IL1_SET ) + d_1(uint_32t, t_dec(i,l), isb_data, w0); +#endif +#if defined( IL4_SET ) + d_4(uint_32t, t_dec(i,l), isb_data, w0, w1, w2, w3); +#endif + +#if defined( LS1_SET ) +#if defined( FL1_SET ) +#undef LS1_SET +#else + d_1(uint_32t, t_dec(l,s), sb_data, w0); +#endif +#endif + +#if defined( LS4_SET ) +#if defined( FL4_SET ) +#undef LS4_SET +#else + d_4(uint_32t, t_dec(l,s), sb_data, w0, w1, w2, w3); +#endif +#endif + +#if defined( IM1_SET ) + d_1(uint_32t, t_dec(i,m), mm_data, v0); +#endif +#if defined( IM4_SET ) + d_4(uint_32t, t_dec(i,m), mm_data, v0, v1, v2, v3); +#endif + +#if defined(__cplusplus) +} +#endif + +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/brg_endian.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/brg_endian.h new file mode 100755 index 0000000..82e48f0 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/brg_endian.h @@ -0,0 +1,126 @@ +/* +--------------------------------------------------------------------------- +Copyright (c) 1998-2010, Brian Gladman, Worcester, UK. All rights reserved. + +The redistribution and use of this software (with or without changes) +is allowed without the payment of fees or royalties provided that: + + source code distributions include the above copyright notice, this + list of conditions and the following disclaimer; + + binary distributions include the above copyright notice, this list + of conditions and the following disclaimer in their documentation. + +This software is provided 'as is' with no explicit or implied warranties +in respect of its operation, including, but not limited to, correctness +and fitness for purpose. +--------------------------------------------------------------------------- +Issue Date: 20/12/2007 +*/ + +#ifndef _BRG_ENDIAN_H +#define _BRG_ENDIAN_H + +#define IS_BIG_ENDIAN 4321 /* byte 0 is most significant (mc68k) */ +#define IS_LITTLE_ENDIAN 1234 /* byte 0 is least significant (i386) */ + +/* Include files where endian defines and byteswap functions may reside */ +#if defined( __sun ) +# include +#elif defined( __FreeBSD__ ) || defined( __OpenBSD__ ) || defined( __NetBSD__ ) +# include +#elif defined( BSD ) && ( BSD >= 199103 ) || defined( __APPLE__ ) || \ + defined( __CYGWIN32__ ) || defined( __DJGPP__ ) || defined( __osf__ ) +# include +#elif defined( __linux__ ) || defined( __GNUC__ ) || defined( __GNU_LIBRARY__ ) +# if !defined( __MINGW32__ ) && !defined( _AIX ) +# include +# if !defined( __BEOS__ ) +# include +# endif +# endif +#endif + +/* Now attempt to set the define for platform byte order using any */ +/* of the four forms SYMBOL, _SYMBOL, __SYMBOL & __SYMBOL__, which */ +/* seem to encompass most endian symbol definitions */ + +#if defined( BIG_ENDIAN ) && defined( LITTLE_ENDIAN ) +# if defined( BYTE_ORDER ) && BYTE_ORDER == BIG_ENDIAN +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN +# elif defined( BYTE_ORDER ) && BYTE_ORDER == LITTLE_ENDIAN +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN +# endif +#elif defined( BIG_ENDIAN ) +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN +#elif defined( LITTLE_ENDIAN ) +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN +#endif + +#if defined( _BIG_ENDIAN ) && defined( _LITTLE_ENDIAN ) +# if defined( _BYTE_ORDER ) && _BYTE_ORDER == _BIG_ENDIAN +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN +# elif defined( _BYTE_ORDER ) && _BYTE_ORDER == _LITTLE_ENDIAN +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN +# endif +#elif defined( _BIG_ENDIAN ) +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN +#elif defined( _LITTLE_ENDIAN ) +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN +#endif + +#if defined( __BIG_ENDIAN ) && defined( __LITTLE_ENDIAN ) +# if defined( __BYTE_ORDER ) && __BYTE_ORDER == __BIG_ENDIAN +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN +# elif defined( __BYTE_ORDER ) && __BYTE_ORDER == __LITTLE_ENDIAN +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN +# endif +#elif defined( __BIG_ENDIAN ) +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN +#elif defined( __LITTLE_ENDIAN ) +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN +#endif + +#if defined( __BIG_ENDIAN__ ) && defined( __LITTLE_ENDIAN__ ) +# if defined( __BYTE_ORDER__ ) && __BYTE_ORDER__ == __BIG_ENDIAN__ +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN +# elif defined( __BYTE_ORDER__ ) && __BYTE_ORDER__ == __LITTLE_ENDIAN__ +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN +# endif +#elif defined( __BIG_ENDIAN__ ) +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN +#elif defined( __LITTLE_ENDIAN__ ) +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN +#endif + +/* if the platform byte order could not be determined, then try to */ +/* set this define using common machine defines */ +#if !defined(PLATFORM_BYTE_ORDER) + +#if defined( __alpha__ ) || defined( __alpha ) || defined( i386 ) || \ + defined( __i386__ ) || defined( _M_I86 ) || defined( _M_IX86 ) || \ + defined( __OS2__ ) || defined( sun386 ) || defined( __TURBOC__ ) || \ + defined( vax ) || defined( vms ) || defined( VMS ) || \ + defined( __VMS ) || defined( _M_X64 ) +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN + +#elif defined( AMIGA ) || defined( applec ) || defined( __AS400__ ) || \ + defined( _CRAY ) || defined( __hppa ) || defined( __hp9000 ) || \ + defined( ibm370 ) || defined( mc68000 ) || defined( m68k ) || \ + defined( __MRC__ ) || defined( __MVS__ ) || defined( __MWERKS__ ) || \ + defined( sparc ) || defined( __sparc) || defined( SYMANTEC_C ) || \ + defined( __VOS__ ) || defined( __TIGCC__ ) || defined( __TANDEM ) || \ + defined( THINK_C ) || defined( __VMCMS__ ) || defined( _AIX ) +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN + +#elif 0 /* **** EDIT HERE IF NECESSARY **** */ +# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN +#elif 0 /* **** EDIT HERE IF NECESSARY **** */ +# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN +#else +# error Please edit lines 126 or 128 in brg_endian.h to set the platform byte order +#endif + +#endif + +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/brg_types.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/brg_types.h new file mode 100755 index 0000000..40d4af5 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/brg_types.h @@ -0,0 +1,219 @@ +/* +--------------------------------------------------------------------------- +Copyright (c) 1998-2010, Brian Gladman, Worcester, UK. All rights reserved. + +The redistribution and use of this software (with or without changes) +is allowed without the payment of fees or royalties provided that: + + source code distributions include the above copyright notice, this + list of conditions and the following disclaimer; + + binary distributions include the above copyright notice, this list + of conditions and the following disclaimer in their documentation. + +This software is provided 'as is' with no explicit or implied warranties +in respect of its operation, including, but not limited to, correctness +and fitness for purpose. +--------------------------------------------------------------------------- +Issue Date: 20/12/2007 + + The unsigned integer types defined here are of the form uint_t where + is the length of the type; for example, the unsigned 32-bit type is + 'uint_32t'. These are NOT the same as the 'C99 integer types' that are + defined in the inttypes.h and stdint.h headers since attempts to use these + types have shown that support for them is still highly variable. However, + since the latter are of the form uint_t, a regular expression search + and replace (in VC++ search on 'uint_{:z}t' and replace with 'uint\1_t') + can be used to convert the types used here to the C99 standard types. +*/ + +#ifndef _BRG_TYPES_H +#define _BRG_TYPES_H + +#if defined(__cplusplus) +extern "C" { +#endif + +#include + +#if defined( _MSC_VER ) && ( _MSC_VER >= 1300 ) +# include +# define ptrint_t intptr_t +#elif defined( __ECOS__ ) +# define intptr_t unsigned int +# define ptrint_t intptr_t +#elif defined( __GNUC__ ) && ( __GNUC__ >= 3 ) +# include +# define ptrint_t intptr_t +#else +# define ptrint_t int +#endif + +#ifndef BRG_UI8 +# define BRG_UI8 +# if UCHAR_MAX == 255u + typedef unsigned char uint_8t; +# else +# error Please define uint_8t as an 8-bit unsigned integer type in brg_types.h +# endif +#endif + +#ifndef BRG_UI16 +# define BRG_UI16 +# if USHRT_MAX == 65535u + typedef unsigned short uint_16t; +# else +# error Please define uint_16t as a 16-bit unsigned short type in brg_types.h +# endif +#endif + +#ifndef BRG_UI32 +# define BRG_UI32 +# if UINT_MAX == 4294967295u +# define li_32(h) 0x##h##u + typedef unsigned int uint_32t; +# elif ULONG_MAX == 4294967295u +# define li_32(h) 0x##h##ul + typedef unsigned long uint_32t; +# elif defined( _CRAY ) +# error This code needs 32-bit data types, which Cray machines do not provide +# else +# error Please define uint_32t as a 32-bit unsigned integer type in brg_types.h +# endif +#endif + +#ifndef BRG_UI64 +# if defined( __BORLANDC__ ) && !defined( __MSDOS__ ) +# define BRG_UI64 +# define li_64(h) 0x##h##ui64 + typedef unsigned __int64 uint_64t; +# elif defined( _MSC_VER ) && ( _MSC_VER < 1300 ) /* 1300 == VC++ 7.0 */ +# define BRG_UI64 +# define li_64(h) 0x##h##ui64 + typedef unsigned __int64 uint_64t; +# elif defined( __sun ) && defined( ULONG_MAX ) && ULONG_MAX == 0xfffffffful +# define BRG_UI64 +# define li_64(h) 0x##h##ull + typedef unsigned long long uint_64t; +# elif defined( __MVS__ ) +# define BRG_UI64 +# define li_64(h) 0x##h##ull + typedef unsigned int long long uint_64t; +# elif defined( UINT_MAX ) && UINT_MAX > 4294967295u +# if UINT_MAX == 18446744073709551615u +# define BRG_UI64 +# define li_64(h) 0x##h##u + typedef unsigned int uint_64t; +# endif +# elif defined( ULONG_MAX ) && ULONG_MAX > 4294967295u +# if ULONG_MAX == 18446744073709551615ul +# define BRG_UI64 +# define li_64(h) 0x##h##ul + typedef unsigned long uint_64t; +# endif +# elif defined( ULLONG_MAX ) && ULLONG_MAX > 4294967295u +# if ULLONG_MAX == 18446744073709551615ull +# define BRG_UI64 +# define li_64(h) 0x##h##ull + typedef unsigned long long uint_64t; +# endif +# elif defined( ULONG_LONG_MAX ) && ULONG_LONG_MAX > 4294967295u +# if ULONG_LONG_MAX == 18446744073709551615ull +# define BRG_UI64 +# define li_64(h) 0x##h##ull + typedef unsigned long long uint_64t; +# endif +# endif +#endif + +#if !defined( BRG_UI64 ) +# if defined( NEED_UINT_64T ) +# error Please define uint_64t as an unsigned 64 bit type in brg_types.h +# endif +#endif + +#ifndef RETURN_VALUES +# define RETURN_VALUES +# if defined( DLL_EXPORT ) +# if defined( _MSC_VER ) || defined ( __INTEL_COMPILER ) +# define VOID_RETURN __declspec( dllexport ) void __stdcall +# define INT_RETURN __declspec( dllexport ) int __stdcall +# elif defined( __GNUC__ ) +# define VOID_RETURN __declspec( __dllexport__ ) void +# define INT_RETURN __declspec( __dllexport__ ) int +# else +# error Use of the DLL is only available on the Microsoft, Intel and GCC compilers +# endif +# elif defined( DLL_IMPORT ) +# if defined( _MSC_VER ) || defined ( __INTEL_COMPILER ) +# define VOID_RETURN __declspec( dllimport ) void __stdcall +# define INT_RETURN __declspec( dllimport ) int __stdcall +# elif defined( __GNUC__ ) +# define VOID_RETURN __declspec( __dllimport__ ) void +# define INT_RETURN __declspec( __dllimport__ ) int +# else +# error Use of the DLL is only available on the Microsoft, Intel and GCC compilers +# endif +# elif defined( __WATCOMC__ ) +# define VOID_RETURN void __cdecl +# define INT_RETURN int __cdecl +# else +# define VOID_RETURN void +# define INT_RETURN int +# endif +#endif + +/* These defines are used to detect and set the memory alignment of pointers. + Note that offsets are in bytes. + + ALIGN_OFFSET(x,n) return the positive or zero offset of + the memory addressed by the pointer 'x' + from an address that is aligned on an + 'n' byte boundary ('n' is a power of 2) + + ALIGN_FLOOR(x,n) return a pointer that points to memory + that is aligned on an 'n' byte boundary + and is not higher than the memory address + pointed to by 'x' ('n' is a power of 2) + + ALIGN_CEIL(x,n) return a pointer that points to memory + that is aligned on an 'n' byte boundary + and is not lower than the memory address + pointed to by 'x' ('n' is a power of 2) +*/ + +#define ALIGN_OFFSET(x,n) (((ptrint_t)(x)) & ((n) - 1)) +#define ALIGN_FLOOR(x,n) ((uint_8t*)(x) - ( ((ptrint_t)(x)) & ((n) - 1))) +#define ALIGN_CEIL(x,n) ((uint_8t*)(x) + (-((ptrint_t)(x)) & ((n) - 1))) + +/* These defines are used to declare buffers in a way that allows + faster operations on longer variables to be used. In all these + defines 'size' must be a power of 2 and >= 8. NOTE that the + buffer size is in bytes but the type length is in bits + + UNIT_TYPEDEF(x,size) declares a variable 'x' of length + 'size' bits + + BUFR_TYPEDEF(x,size,bsize) declares a buffer 'x' of length 'bsize' + bytes defined as an array of variables + each of 'size' bits (bsize must be a + multiple of size / 8) + + UNIT_CAST(x,size) casts a variable to a type of + length 'size' bits + + UPTR_CAST(x,size) casts a pointer to a pointer to a + varaiable of length 'size' bits +*/ + +#define UI_TYPE(size) uint_##size##t +#define UNIT_TYPEDEF(x,size) typedef UI_TYPE(size) x +#define BUFR_TYPEDEF(x,size,bsize) typedef UI_TYPE(size) x[bsize / (size >> 3)] +#define UNIT_CAST(x,size) ((UI_TYPE(size) )(x)) +#define UPTR_CAST(x,size) ((UI_TYPE(size)*)(x)) + +#if defined(__cplusplus) +} +#endif + +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/entropy.c b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/entropy.c new file mode 100755 index 0000000..5840a97 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/entropy.c @@ -0,0 +1,54 @@ +#ifdef _WIN32 +#include +#else +#include +#include +#include +#endif + +#if defined(__cplusplus) +extern "C" +{ +#endif + +#ifdef _WIN32 +int entropy_fun(unsigned char buf[], unsigned int len) +{ + HCRYPTPROV provider; + unsigned __int64 pentium_tsc[1]; + unsigned int i; + int result = 0; + + + if (CryptAcquireContext(&provider, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) + { + result = CryptGenRandom(provider, len, buf); + CryptReleaseContext(provider, 0); + if (result) + return len; + } + + QueryPerformanceCounter((LARGE_INTEGER *)pentium_tsc); + + for(i = 0; i < 8 && i < len; ++i) + buf[i] = ((unsigned char*)pentium_tsc)[i]; + + return i; +} +#else +int entropy_fun(unsigned char buf[], unsigned int len) +{ + int frand = open("/dev/random", O_RDONLY); + int rlen = 0; + if (frand != -1) + { + rlen = (int)read(frand, buf, len); + close(frand); + } + return rlen; +} +#endif + +#if defined(__cplusplus) +} +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/entropy.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/entropy.h new file mode 100755 index 0000000..306620c --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/entropy.h @@ -0,0 +1,16 @@ + +#ifndef _ENTROPY_FUN_H +#define _ENTROPY_FUN_H + +#if defined(__cplusplus) +extern "C" +{ +#endif + +int entropy_fun(unsigned char buf[], unsigned int len); + +#if defined(__cplusplus) +} +#endif + +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/fileenc.c b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/fileenc.c new file mode 100755 index 0000000..5057036 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/fileenc.c @@ -0,0 +1,144 @@ +/* + --------------------------------------------------------------------------- + Copyright (c) 2002, Dr Brian Gladman < >, Worcester, UK. + All rights reserved. + + LICENSE TERMS + + The free distribution and use of this software in both source and binary + form is allowed (with or without changes) provided that: + + 1. distributions of this source code include the above copyright + notice, this list of conditions and the following disclaimer; + + 2. distributions in binary form include the above copyright + notice, this list of conditions and the following disclaimer + in the documentation and/or other associated materials; + + 3. the copyright holder's name is not used to endorse products + built using this software without specific written permission. + + ALTERNATIVELY, provided that this notice is retained in full, this product + may be distributed under the terms of the GNU General Public License (GPL), + in which case the provisions of the GPL apply INSTEAD OF those given above. + + DISCLAIMER + + This software is provided 'as is' with no explicit or implied warranties + in respect of its properties, including, but not limited to, correctness + and/or fitness for purpose. + ------------------------------------------------------------------------- + Issue Date: 24/01/2003 + + This file implements password based file encryption and authentication + using AES in CTR mode, HMAC-SHA1 authentication and RFC2898 password + based key derivation. + + */ + +#include + +#include "fileenc.h" + +#if defined(__cplusplus) +extern "C" +{ +#endif + +/* subroutine for data encryption/decryption */ +/* this could be speeded up a lot by aligning */ +/* buffers and using 32 bit operations */ + +static void encr_data(unsigned char data[], unsigned long d_len, fcrypt_ctx cx[1]) +{ + unsigned long i = 0, pos = cx->encr_pos; + + while (i < d_len) { + if (pos == AES_BLOCK_SIZE) { + unsigned int j = 0; + /* increment encryption nonce */ + while (j < 8 && !++cx->nonce[j]) + ++j; + /* encrypt the nonce to form next xor buffer */ + aes_encrypt(cx->nonce, cx->encr_bfr, cx->encr_ctx); + pos = 0; + } + + data[i++] ^= cx->encr_bfr[pos++]; + } + + cx->encr_pos = (unsigned int)pos; +} + +int fcrypt_init( + int mode, /* the mode to be used (input) */ + const unsigned char pwd[], /* the user specified password (input) */ + unsigned int pwd_len, /* the length of the password (input) */ + const unsigned char salt[], /* the salt (input) */ +#ifdef PASSWORD_VERIFIER + unsigned char pwd_ver[PWD_VER_LENGTH], /* 2 byte password verifier (output) */ +#endif + fcrypt_ctx cx[1]) /* the file encryption context (output) */ +{ + unsigned char kbuf[2 * MAX_KEY_LENGTH + PWD_VER_LENGTH]; + + if (pwd_len > MAX_PWD_LENGTH) + return PASSWORD_TOO_LONG; + + if (mode < 1 || mode > 3) + return BAD_MODE; + + cx->mode = mode; + cx->pwd_len = pwd_len; + + /* derive the encryption and authentication keys and the password verifier */ + derive_key(pwd, pwd_len, salt, SALT_LENGTH(mode), KEYING_ITERATIONS, + kbuf, 2 * KEY_LENGTH(mode) + PWD_VER_LENGTH); + + /* initialise the encryption nonce and buffer pos */ + cx->encr_pos = AES_BLOCK_SIZE; + /* if we need a random component in the encryption */ + /* nonce, this is where it would have to be set */ + memset(cx->nonce, 0, AES_BLOCK_SIZE * sizeof(unsigned char)); + + /* initialise for encryption using key 1 */ + aes_encrypt_key(kbuf, KEY_LENGTH(mode), cx->encr_ctx); + + /* initialise for authentication using key 2 */ + hmac_sha_begin(cx->auth_ctx); + hmac_sha_key(kbuf + KEY_LENGTH(mode), KEY_LENGTH(mode), cx->auth_ctx); + +#ifdef PASSWORD_VERIFIER + memcpy(pwd_ver, kbuf + 2 * KEY_LENGTH(mode), PWD_VER_LENGTH); +#endif + + return GOOD_RETURN; +} + +/* perform 'in place' encryption and authentication */ + +void fcrypt_encrypt(unsigned char data[], unsigned int data_len, fcrypt_ctx cx[1]) +{ + encr_data(data, data_len, cx); + hmac_sha_data(data, data_len, cx->auth_ctx); +} + +/* perform 'in place' authentication and decryption */ + +void fcrypt_decrypt(unsigned char data[], unsigned int data_len, fcrypt_ctx cx[1]) +{ + hmac_sha_data(data, data_len, cx->auth_ctx); + encr_data(data, data_len, cx); +} + +/* close encryption/decryption and return the MAC value */ + +int fcrypt_end(unsigned char mac[], fcrypt_ctx cx[1]) +{ + hmac_sha_end(mac, MAC_LENGTH(cx->mode), cx->auth_ctx); + return MAC_LENGTH(cx->mode); /* return MAC length in bytes */ +} + +#if defined(__cplusplus) +} +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/fileenc.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/fileenc.h new file mode 100755 index 0000000..ba64a7c --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/fileenc.h @@ -0,0 +1,121 @@ +/* + --------------------------------------------------------------------------- + Copyright (c) 2002, Dr Brian Gladman < >, Worcester, UK. + All rights reserved. + + LICENSE TERMS + + The free distribution and use of this software in both source and binary + form is allowed (with or without changes) provided that: + + 1. distributions of this source code include the above copyright + notice, this list of conditions and the following disclaimer; + + 2. distributions in binary form include the above copyright + notice, this list of conditions and the following disclaimer + in the documentation and/or other associated materials; + + 3. the copyright holder's name is not used to endorse products + built using this software without specific written permission. + + ALTERNATIVELY, provided that this notice is retained in full, this product + may be distributed under the terms of the GNU General Public License (GPL), + in which case the provisions of the GPL apply INSTEAD OF those given above. + + DISCLAIMER + + This software is provided 'as is' with no explicit or implied warranties + in respect of its properties, including, but not limited to, correctness + and/or fitness for purpose. + --------------------------------------------------------------------------- + Issue Date: 24/01/2003 + + This file contains the header file for fileenc.c, which implements password + based file encryption and authentication using AES in CTR mode, HMAC-SHA1 + authentication and RFC2898 password based key derivation. +*/ + +#ifndef _FENC_H +#define _FENC_H + +#include "aes.h" +#include "hmac.h" +#include "pwd2key.h" + +#define PASSWORD_VERIFIER + +#define MAX_KEY_LENGTH 32 +#define MAX_PWD_LENGTH 128 +#define MAX_SALT_LENGTH 16 +#define KEYING_ITERATIONS 1000 + +#ifdef PASSWORD_VERIFIER +#define PWD_VER_LENGTH 2 +#else +#define PWD_VER_LENGTH 0 +#endif + +#define GOOD_RETURN 0 +#define PASSWORD_TOO_LONG -100 +#define BAD_MODE -101 + +/* + Field lengths (in bytes) versus File Encryption Mode (0 < mode < 4) + + Mode Key Salt MAC Overhead + 1 16 8 10 18 + 2 24 12 10 22 + 3 32 16 10 26 + + The following macros assume that the mode value is correct. +*/ + +#define KEY_LENGTH(mode) (8 * (mode & 3) + 8) +#define SALT_LENGTH(mode) (4 * (mode & 3) + 4) +#define MAC_LENGTH(mode) (10) + +/* the context for file encryption */ + +#if defined(__cplusplus) +extern "C" +{ +#endif + +typedef struct +{ unsigned char nonce[AES_BLOCK_SIZE]; /* the CTR nonce */ + unsigned char encr_bfr[AES_BLOCK_SIZE]; /* encrypt buffer */ + aes_encrypt_ctx encr_ctx[1]; /* encryption context */ + hmac_ctx auth_ctx[1]; /* authentication context */ + unsigned int encr_pos; /* block position (enc) */ + unsigned int pwd_len; /* password length */ + unsigned int mode; /* File encryption mode */ +} fcrypt_ctx; + +/* initialise file encryption or decryption */ + +int fcrypt_init( + int mode, /* the mode to be used (input) */ + const unsigned char pwd[], /* the user specified password (input) */ + unsigned int pwd_len, /* the length of the password (input) */ + const unsigned char salt[], /* the salt (input) */ +#ifdef PASSWORD_VERIFIER + unsigned char pwd_ver[PWD_VER_LENGTH], /* 2 byte password verifier (output) */ +#endif + fcrypt_ctx cx[1]); /* the file encryption context (output) */ + +/* perform 'in place' encryption or decryption and authentication */ + +void fcrypt_encrypt(unsigned char data[], unsigned int data_len, fcrypt_ctx cx[1]); +void fcrypt_decrypt(unsigned char data[], unsigned int data_len, fcrypt_ctx cx[1]); + +/* close encryption/decryption and return the MAC value */ +/* the return value is the length of the MAC */ + +int fcrypt_end(unsigned char mac[], /* the MAC value (output) */ + fcrypt_ctx cx[1]); /* the context (input) */ + +#if defined(__cplusplus) +} +#endif + +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/hmac.c b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/hmac.c new file mode 100755 index 0000000..c71b14e --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/hmac.c @@ -0,0 +1,145 @@ +/* + --------------------------------------------------------------------------- + Copyright (c) 2002, Dr Brian Gladman, Worcester, UK. All rights reserved. + + LICENSE TERMS + + The free distribution and use of this software in both source and binary + form is allowed (with or without changes) provided that: + + 1. distributions of this source code include the above copyright + notice, this list of conditions and the following disclaimer; + + 2. distributions in binary form include the above copyright + notice, this list of conditions and the following disclaimer + in the documentation and/or other associated materials; + + 3. the copyright holder's name is not used to endorse products + built using this software without specific written permission. + + ALTERNATIVELY, provided that this notice is retained in full, this product + may be distributed under the terms of the GNU General Public License (GPL), + in which case the provisions of the GPL apply INSTEAD OF those given above. + + DISCLAIMER + + This software is provided 'as is' with no explicit or implied warranties + in respect of its properties, including, but not limited to, correctness + and/or fitness for purpose. + --------------------------------------------------------------------------- + Issue Date: 26/08/2003 + + This is an implementation of HMAC, the FIPS standard keyed hash function +*/ + +#include "hmac.h" +#include "brg_types.h" + +#if defined(__cplusplus) +extern "C" +{ +#endif + +/* initialise the HMAC context to zero */ +void hmac_sha_begin(hmac_ctx cx[1]) +{ + memset(cx, 0, sizeof(hmac_ctx)); +} + +/* input the HMAC key (can be called multiple times) */ +int hmac_sha_key(const unsigned char key[], unsigned long key_len, hmac_ctx cx[1]) +{ + if(cx->klen == HMAC_IN_DATA) /* error if further key input */ + return HMAC_BAD_MODE; /* is attempted in data mode */ + + if(cx->klen + key_len > HASH_INPUT_SIZE) /* if the key has to be hashed */ + { + if(cx->klen <= HASH_INPUT_SIZE) /* if the hash has not yet been */ + { /* started, initialise it and */ + sha_begin(cx->ctx); /* hash stored key characters */ + sha_hash(cx->key, cx->klen, cx->ctx); + } + + sha_hash(key, key_len, cx->ctx); /* hash long key data into hash */ + } + else /* otherwise store key data */ + memcpy(cx->key + cx->klen, key, key_len); + + cx->klen += key_len; /* update the key length count */ + return HMAC_OK; +} + +/* input the HMAC data (can be called multiple times) - */ +/* note that this call terminates the key input phase */ +void hmac_sha_data(const unsigned char data[], unsigned long data_len, hmac_ctx cx[1]) +{ unsigned int i; + + if(cx->klen != HMAC_IN_DATA) /* if not yet in data phase */ + { + if(cx->klen > HASH_INPUT_SIZE) /* if key is being hashed */ + { /* complete the hash and */ + sha_end(cx->key, cx->ctx); /* store the result as the */ + cx->klen = HASH_OUTPUT_SIZE; /* key and set new length */ + } + + /* pad the key if necessary */ + memset(cx->key + cx->klen, 0, HASH_INPUT_SIZE - cx->klen); + + /* xor ipad into key value */ + for(i = 0; i < (HASH_INPUT_SIZE >> 2); ++i) + ((uint_32t*)cx->key)[i] ^= 0x36363636; + + /* and start hash operation */ + sha_begin(cx->ctx); + sha_hash(cx->key, HASH_INPUT_SIZE, cx->ctx); + + /* mark as now in data mode */ + cx->klen = HMAC_IN_DATA; + } + + /* hash the data (if any) */ + if(data_len) + sha_hash(data, data_len, cx->ctx); +} + +/* compute and output the MAC value */ +void hmac_sha_end(unsigned char mac[], unsigned long mac_len, hmac_ctx cx[1]) +{ unsigned char dig[HASH_OUTPUT_SIZE]; + unsigned int i; + + /* if no data has been entered perform a null data phase */ + if(cx->klen != HMAC_IN_DATA) + hmac_sha_data((const unsigned char*)0, 0, cx); + + sha_end(dig, cx->ctx); /* complete the inner hash */ + + /* set outer key value using opad and removing ipad */ + for(i = 0; i < (HASH_INPUT_SIZE >> 2); ++i) + ((uint_32t*)cx->key)[i] ^= 0x36363636 ^ 0x5c5c5c5c; + + /* perform the outer hash operation */ + sha_begin(cx->ctx); + sha_hash(cx->key, HASH_INPUT_SIZE, cx->ctx); + sha_hash(dig, HASH_OUTPUT_SIZE, cx->ctx); + sha_end(dig, cx->ctx); + + /* output the hash value */ + for(i = 0; i < mac_len; ++i) + mac[i] = dig[i]; +} + +/* 'do it all in one go' subroutine */ +void hmac_sha(const unsigned char key[], unsigned long key_len, + const unsigned char data[], unsigned long data_len, + unsigned char mac[], unsigned long mac_len) +{ hmac_ctx cx[1]; + + hmac_sha_begin(cx); + hmac_sha_key(key, key_len, cx); + hmac_sha_data(data, data_len, cx); + hmac_sha_end(mac, mac_len, cx); +} + +#if defined(__cplusplus) +} +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/hmac.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/hmac.h new file mode 100755 index 0000000..643037c --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/hmac.h @@ -0,0 +1,103 @@ +/* + --------------------------------------------------------------------------- + Copyright (c) 2002, Dr Brian Gladman, Worcester, UK. All rights reserved. + + LICENSE TERMS + + The free distribution and use of this software in both source and binary + form is allowed (with or without changes) provided that: + + 1. distributions of this source code include the above copyright + notice, this list of conditions and the following disclaimer; + + 2. distributions in binary form include the above copyright + notice, this list of conditions and the following disclaimer + in the documentation and/or other associated materials; + + 3. the copyright holder's name is not used to endorse products + built using this software without specific written permission. + + ALTERNATIVELY, provided that this notice is retained in full, this product + may be distributed under the terms of the GNU General Public License (GPL), + in which case the provisions of the GPL apply INSTEAD OF those given above. + + DISCLAIMER + + This software is provided 'as is' with no explicit or implied warranties + in respect of its properties, including, but not limited to, correctness + and/or fitness for purpose. + --------------------------------------------------------------------------- + Issue Date: 26/08/2003 + + This is an implementation of HMAC, the FIPS standard keyed hash function +*/ + +#ifndef _HMAC_H +#define _HMAC_H + +#include + +#if defined(__cplusplus) +extern "C" +{ +#endif + +#define USE_SHA1 + +#if !defined(USE_SHA1) && !defined(USE_SHA256) +#error define USE_SHA1 or USE_SHA256 to set the HMAC hash algorithm +#endif + +#ifdef USE_SHA1 + +#include "sha1.h" + +#define HASH_INPUT_SIZE SHA1_BLOCK_SIZE +#define HASH_OUTPUT_SIZE SHA1_DIGEST_SIZE +#define sha_ctx sha1_ctx +#define sha_begin sha1_begin +#define sha_hash sha1_hash +#define sha_end sha1_end + +#endif + +#ifdef USE_SHA256 + +#include "sha2.h" + +#define HASH_INPUT_SIZE SHA256_BLOCK_SIZE +#define HASH_OUTPUT_SIZE SHA256_DIGEST_SIZE +#define sha_ctx sha256_ctx +#define sha_begin sha256_begin +#define sha_hash sha256_hash +#define sha_end sha256_end + +#endif + +#define HMAC_OK 0 +#define HMAC_BAD_MODE -1 +#define HMAC_IN_DATA 0xffffffff + +typedef struct +{ unsigned char key[HASH_INPUT_SIZE]; + sha_ctx ctx[1]; + unsigned long klen; +} hmac_ctx; + +void hmac_sha_begin(hmac_ctx cx[1]); + +int hmac_sha_key(const unsigned char key[], unsigned long key_len, hmac_ctx cx[1]); + +void hmac_sha_data(const unsigned char data[], unsigned long data_len, hmac_ctx cx[1]); + +void hmac_sha_end(unsigned char mac[], unsigned long mac_len, hmac_ctx cx[1]); + +void hmac_sha(const unsigned char key[], unsigned long key_len, + const unsigned char data[], unsigned long data_len, + unsigned char mac[], unsigned long mac_len); + +#if defined(__cplusplus) +} +#endif + +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/prng.c b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/prng.c new file mode 100755 index 0000000..2f91090 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/prng.c @@ -0,0 +1,155 @@ +/* + --------------------------------------------------------------------------- + Copyright (c) 2002, Dr Brian Gladman < >, Worcester, UK. + All rights reserved. + + LICENSE TERMS + + The free distribution and use of this software in both source and binary + form is allowed (with or without changes) provided that: + + 1. distributions of this source code include the above copyright + notice, this list of conditions and the following disclaimer; + + 2. distributions in binary form include the above copyright + notice, this list of conditions and the following disclaimer + in the documentation and/or other associated materials; + + 3. the copyright holder's name is not used to endorse products + built using this software without specific written permission. + + ALTERNATIVELY, provided that this notice is retained in full, this product + may be distributed under the terms of the GNU General Public License (GPL), + in which case the provisions of the GPL apply INSTEAD OF those given above. + + DISCLAIMER + + This software is provided 'as is' with no explicit or implied warranties + in respect of its properties, including, but not limited to, correctness + and/or fitness for purpose. + --------------------------------------------------------------------------- + Issue Date: 24/01/2003 + + This file implements a random data pool based on the use of an external + entropy function. It is based on the ideas advocated by Peter Gutmann in + his work on pseudo random sequence generators. It is not a 'paranoid' + random sequence generator and no attempt is made to protect the pool + from prying eyes either by memory locking or by techniques to obscure + its location in memory. +*/ + +#include +#include "prng.h" + +#if defined(__cplusplus) +extern "C" +{ +#endif + +/* mix a random data pool using the SHA1 compression function (as */ +/* suggested by Peter Gutmann in his paper on random pools) */ + +static void prng_mix(unsigned char buf[]) +{ unsigned int i, len; + sha1_ctx ctx[1]; + + /*lint -e{663} unusual array to pointer conversion */ + for(i = 0; i < PRNG_POOL_SIZE; i += SHA1_DIGEST_SIZE) + { + /* copy digest size pool block into SHA1 hash block */ + memcpy(ctx->hash, buf + (i ? i : PRNG_POOL_SIZE) + - SHA1_DIGEST_SIZE, SHA1_DIGEST_SIZE); + + /* copy data from pool into the SHA1 data buffer */ + len = PRNG_POOL_SIZE - i; + memcpy(ctx->wbuf, buf + i, (len > SHA1_BLOCK_SIZE ? SHA1_BLOCK_SIZE : len)); + + if(len < SHA1_BLOCK_SIZE) + memcpy(((char*)ctx->wbuf) + len, buf, SHA1_BLOCK_SIZE - len); + + /* compress using the SHA1 compression function */ + sha1_compile(ctx); + + /* put digest size block back into the random pool */ + memcpy(buf + i, ctx->hash, SHA1_DIGEST_SIZE); + } +} + +/* refresh the output buffer and update the random pool by adding */ +/* entropy and remixing */ + +static void update_pool(prng_ctx ctx[1]) +{ unsigned int i = 0; + + /* transfer random pool data to the output buffer */ + memcpy(ctx->obuf, ctx->rbuf, PRNG_POOL_SIZE); + + /* enter entropy data into the pool */ + while(i < PRNG_POOL_SIZE) + i += ctx->entropy(ctx->rbuf + i, PRNG_POOL_SIZE - i); + + /* invert and xor the original pool data into the pool */ + for(i = 0; i < PRNG_POOL_SIZE; ++i) + ctx->rbuf[i] ^= ~ctx->obuf[i]; + + /* mix the pool and the output buffer */ + prng_mix(ctx->rbuf); + prng_mix(ctx->obuf); +} + +void prng_init(prng_entropy_fn fun, prng_ctx ctx[1]) +{ int i; + + /* clear the buffers and the counter in the context */ + memset(ctx, 0, sizeof(prng_ctx)); + + /* set the pointer to the entropy collection function */ + ctx->entropy = fun; + + /* initialise the random data pool */ + update_pool(ctx); + + /* mix the pool a minimum number of times */ + for(i = 0; i < PRNG_MIN_MIX; ++i) + prng_mix(ctx->rbuf); + + /* update the pool to prime the pool output buffer */ + update_pool(ctx); +} + +/* provide random bytes from the random data pool */ + +void prng_rand(unsigned char data[], unsigned int data_len, prng_ctx ctx[1]) +{ unsigned char *rp = data; + unsigned int len, pos = ctx->pos; + + while(data_len) + { + /* transfer 'data_len' bytes (or the number of bytes remaining */ + /* the pool output buffer if less) into the output */ + len = (data_len < PRNG_POOL_SIZE - pos ? data_len : PRNG_POOL_SIZE - pos); + memcpy(rp, ctx->obuf + pos, len); + rp += len; /* update ouput buffer position pointer */ + pos += len; /* update pool output buffer pointer */ + data_len -= len; /* update the remaining data count */ + + /* refresh the random pool if necessary */ + if(pos == PRNG_POOL_SIZE) + { + update_pool(ctx); pos = 0; + } + } + + ctx->pos = pos; +} + +void prng_end(prng_ctx ctx[1]) +{ + /* ensure the data in the context is destroyed */ + memset(ctx, 0, sizeof(prng_ctx)); +} + +#if defined(__cplusplus) +} +#endif + diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/prng.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/prng.h new file mode 100755 index 0000000..f934b51 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/prng.h @@ -0,0 +1,82 @@ +/* + --------------------------------------------------------------------------- + Copyright (c) 2002, Dr Brian Gladman < >, Worcester, UK. + All rights reserved. + + LICENSE TERMS + + The free distribution and use of this software in both source and binary + form is allowed (with or without changes) provided that: + + 1. distributions of this source code include the above copyright + notice, this list of conditions and the following disclaimer; + + 2. distributions in binary form include the above copyright + notice, this list of conditions and the following disclaimer + in the documentation and/or other associated materials; + + 3. the copyright holder's name is not used to endorse products + built using this software without specific written permission. + + ALTERNATIVELY, provided that this notice is retained in full, this product + may be distributed under the terms of the GNU General Public License (GPL), + in which case the provisions of the GPL apply INSTEAD OF those given above. + + DISCLAIMER + + This software is provided 'as is' with no explicit or implied warranties + in respect of its properties, including, but not limited to, correctness + and/or fitness for purpose. + --------------------------------------------------------------------------- + Issue Date: 24/01/2003 + + This is the header file for an implementation of a random data pool based on + the use of an external entropy function (inspired by Peter Gutmann's work). +*/ + +#ifndef _PRNG_H +#define _PRNG_H + +#include "sha1.h" + +#define PRNG_POOL_LEN 256 /* minimum random pool size */ +#define PRNG_MIN_MIX 20 /* min initial pool mixing iterations */ + +/* ensure that pool length is a multiple of the SHA1 digest size */ + +#define PRNG_POOL_SIZE (SHA1_DIGEST_SIZE * (1 + (PRNG_POOL_LEN - 1) / SHA1_DIGEST_SIZE)) + +#if defined(__cplusplus) +extern "C" +{ +#endif + +/* A function for providing entropy is a parameter in the prng_init() */ +/* call. This function has the following form and returns a maximum */ +/* of 'len' bytes of pseudo random data in the buffer 'buf'. It can */ +/* return less than 'len' bytes but will be repeatedly called for more */ +/* data in this case. */ + +typedef int (*prng_entropy_fn)(unsigned char buf[], unsigned int len); + +typedef struct +{ unsigned char rbuf[PRNG_POOL_SIZE]; /* the random pool */ + unsigned char obuf[PRNG_POOL_SIZE]; /* pool output buffer */ + unsigned int pos; /* output buffer position */ + prng_entropy_fn entropy; /* entropy function pointer */ +} prng_ctx; + +/* initialise the random stream generator */ +void prng_init(prng_entropy_fn fun, prng_ctx ctx[1]); + +/* obtain random bytes from the generator */ +void prng_rand(unsigned char data[], unsigned int data_len, prng_ctx ctx[1]); + +/* close the random stream generator */ +void prng_end(prng_ctx ctx[1]); + +#if defined(__cplusplus) +} +#endif + +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/pwd2key.c b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/pwd2key.c new file mode 100755 index 0000000..80a4760 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/pwd2key.c @@ -0,0 +1,193 @@ +/* + --------------------------------------------------------------------------- + Copyright (c) 2002, Dr Brian Gladman, Worcester, UK. All rights reserved. + + LICENSE TERMS + + The free distribution and use of this software in both source and binary + form is allowed (with or without changes) provided that: + + 1. distributions of this source code include the above copyright + notice, this list of conditions and the following disclaimer; + + 2. distributions in binary form include the above copyright + notice, this list of conditions and the following disclaimer + in the documentation and/or other associated materials; + + 3. the copyright holder's name is not used to endorse products + built using this software without specific written permission. + + ALTERNATIVELY, provided that this notice is retained in full, this product + may be distributed under the terms of the GNU General Public License (GPL), + in which case the provisions of the GPL apply INSTEAD OF those given above. + + DISCLAIMER + + This software is provided 'as is' with no explicit or implied warranties + in respect of its properties, including, but not limited to, correctness + and/or fitness for purpose. + --------------------------------------------------------------------------- + Issue Date: 26/08/2003 + + This is an implementation of RFC2898, which specifies key derivation from + a password and a salt value. +*/ + +#include +#include "hmac.h" + +#if defined(__cplusplus) +extern "C" +{ +#endif + +void derive_key(const unsigned char pwd[], /* the PASSWORD */ + unsigned int pwd_len, /* and its length */ + const unsigned char salt[], /* the SALT and its */ + unsigned int salt_len, /* length */ + unsigned int iter, /* the number of iterations */ + unsigned char key[], /* space for the output key */ + unsigned int key_len)/* and its required length */ +{ + unsigned int i, j, k, n_blk; + unsigned char uu[HASH_OUTPUT_SIZE], ux[HASH_OUTPUT_SIZE]; + hmac_ctx c1[1], c2[1], c3[1]; + + /* set HMAC context (c1) for password */ + hmac_sha_begin(c1); + hmac_sha_key(pwd, pwd_len, c1); + + /* set HMAC context (c2) for password and salt */ + memcpy(c2, c1, sizeof(hmac_ctx)); + hmac_sha_data(salt, salt_len, c2); + + /* find the number of SHA blocks in the key */ + n_blk = 1 + (key_len - 1) / HASH_OUTPUT_SIZE; + + for(i = 0; i < n_blk; ++i) /* for each block in key */ + { + /* ux[] holds the running xor value */ + memset(ux, 0, HASH_OUTPUT_SIZE); + + /* set HMAC context (c3) for password and salt */ + memcpy(c3, c2, sizeof(hmac_ctx)); + + /* enter additional data for 1st block into uu */ + uu[0] = (unsigned char)((i + 1) >> 24); + uu[1] = (unsigned char)((i + 1) >> 16); + uu[2] = (unsigned char)((i + 1) >> 8); + uu[3] = (unsigned char)(i + 1); + + /* this is the key mixing iteration */ + for(j = 0, k = 4; j < iter; ++j) + { + /* add previous round data to HMAC */ + hmac_sha_data(uu, k, c3); + + /* obtain HMAC for uu[] */ + hmac_sha_end(uu, HASH_OUTPUT_SIZE, c3); + + /* xor into the running xor block */ + for(k = 0; k < HASH_OUTPUT_SIZE; ++k) + ux[k] ^= uu[k]; + + /* set HMAC context (c3) for password */ + memcpy(c3, c1, sizeof(hmac_ctx)); + } + + /* compile key blocks into the key output */ + j = 0; k = i * HASH_OUTPUT_SIZE; + while(j < HASH_OUTPUT_SIZE && k < key_len) + key[k++] = ux[j++]; + } +} + +#ifdef TEST + +#include + +struct +{ unsigned int pwd_len; + unsigned int salt_len; + unsigned int it_count; + unsigned char *pwd; + unsigned char salt[32]; + unsigned char key[32]; +} tests[] = +{ + { 8, 4, 5, (unsigned char*)"password", + { + 0x12, 0x34, 0x56, 0x78 + }, + { + 0x5c, 0x75, 0xce, 0xf0, 0x1a, 0x96, 0x0d, 0xf7, + 0x4c, 0xb6, 0xb4, 0x9b, 0x9e, 0x38, 0xe6, 0xb5 + } + }, + { 8, 8, 5, (unsigned char*)"password", + { + 0x12, 0x34, 0x56, 0x78, 0x78, 0x56, 0x34, 0x12 + }, + { + 0xd1, 0xda, 0xa7, 0x86, 0x15, 0xf2, 0x87, 0xe6, + 0xa1, 0xc8, 0xb1, 0x20, 0xd7, 0x06, 0x2a, 0x49 + } + }, + { 8, 21, 1, (unsigned char*)"password", + { + "ATHENA.MIT.EDUraeburn" + }, + { + 0xcd, 0xed, 0xb5, 0x28, 0x1b, 0xb2, 0xf8, 0x01, + 0x56, 0x5a, 0x11, 0x22, 0xb2, 0x56, 0x35, 0x15 + } + }, + { 8, 21, 2, (unsigned char*)"password", + { + "ATHENA.MIT.EDUraeburn" + }, + { + 0x01, 0xdb, 0xee, 0x7f, 0x4a, 0x9e, 0x24, 0x3e, + 0x98, 0x8b, 0x62, 0xc7, 0x3c, 0xda, 0x93, 0x5d + } + }, + { 8, 21, 1200, (unsigned char*)"password", + { + "ATHENA.MIT.EDUraeburn" + }, + { + 0x5c, 0x08, 0xeb, 0x61, 0xfd, 0xf7, 0x1e, 0x4e, + 0x4e, 0xc3, 0xcf, 0x6b, 0xa1, 0xf5, 0x51, 0x2b + } + } +}; + +int main() +{ unsigned int i, j, key_len = 256; + unsigned char key[256]; + + printf("\nTest of RFC2898 Password Based Key Derivation"); + for(i = 0; i < 5; ++i) + { + derive_key(tests[i].pwd, tests[i].pwd_len, tests[i].salt, + tests[i].salt_len, tests[i].it_count, key, key_len); + + printf("\ntest %i: ", i + 1); + printf("key %s", memcmp(tests[i].key, key, 16) ? "is bad" : "is good"); + for(j = 0; j < key_len && j < 64; j += 4) + { + if(j % 16 == 0) + printf("\n"); + printf("0x%02x%02x%02x%02x ", key[j], key[j + 1], key[j + 2], key[j + 3]); + } + printf(j < key_len ? " ... \n" : "\n"); + } + printf("\n"); + return 0; +} + +#if defined(__cplusplus) +} +#endif + +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/pwd2key.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/pwd2key.h new file mode 100755 index 0000000..99c1ecc --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/pwd2key.h @@ -0,0 +1,57 @@ +/* + --------------------------------------------------------------------------- + Copyright (c) 2002, Dr Brian Gladman, Worcester, UK. All rights reserved. + + LICENSE TERMS + + The free distribution and use of this software in both source and binary + form is allowed (with or without changes) provided that: + + 1. distributions of this source code include the above copyright + notice, this list of conditions and the following disclaimer; + + 2. distributions in binary form include the above copyright + notice, this list of conditions and the following disclaimer + in the documentation and/or other associated materials; + + 3. the copyright holder's name is not used to endorse products + built using this software without specific written permission. + + ALTERNATIVELY, provided that this notice is retained in full, this product + may be distributed under the terms of the GNU General Public License (GPL), + in which case the provisions of the GPL apply INSTEAD OF those given above. + + DISCLAIMER + + This software is provided 'as is' with no explicit or implied warranties + in respect of its properties, including, but not limited to, correctness + and/or fitness for purpose. + --------------------------------------------------------------------------- + Issue Date: 26/08/2003 + + This is an implementation of RFC2898, which specifies key derivation from + a password and a salt value. +*/ + +#ifndef PWD2KEY_H +#define PWD2KEY_H + +#if defined(__cplusplus) +extern "C" +{ +#endif + +void derive_key( + const unsigned char pwd[], /* the PASSWORD, and */ + unsigned int pwd_len, /* its length */ + const unsigned char salt[], /* the SALT and its */ + unsigned int salt_len, /* length */ + unsigned int iter, /* the number of iterations */ + unsigned char key[], /* space for the output key */ + unsigned int key_len); /* and its required length */ + +#if defined(__cplusplus) +} +#endif + +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/sha1.c b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/sha1.c new file mode 100755 index 0000000..0fbf05e --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/sha1.c @@ -0,0 +1,258 @@ +/* + --------------------------------------------------------------------------- + Copyright (c) 2002, Dr Brian Gladman, Worcester, UK. All rights reserved. + + LICENSE TERMS + + The free distribution and use of this software in both source and binary + form is allowed (with or without changes) provided that: + + 1. distributions of this source code include the above copyright + notice, this list of conditions and the following disclaimer; + + 2. distributions in binary form include the above copyright + notice, this list of conditions and the following disclaimer + in the documentation and/or other associated materials; + + 3. the copyright holder's name is not used to endorse products + built using this software without specific written permission. + + ALTERNATIVELY, provided that this notice is retained in full, this product + may be distributed under the terms of the GNU General Public License (GPL), + in which case the provisions of the GPL apply INSTEAD OF those given above. + + DISCLAIMER + + This software is provided 'as is' with no explicit or implied warranties + in respect of its properties, including, but not limited to, correctness + and/or fitness for purpose. + --------------------------------------------------------------------------- + Issue Date: 01/08/2005 + + This is a byte oriented version of SHA1 that operates on arrays of bytes + stored in memory. +*/ + +#include /* for memcpy() etc. */ + +#include "sha1.h" +#include "brg_endian.h" + +#if defined(__cplusplus) +extern "C" +{ +#endif + +#if defined( _MSC_VER ) && ( _MSC_VER > 800 ) +#pragma intrinsic(memcpy) +#endif + +#if 0 && defined(_MSC_VER) +#define rotl32 _lrotl +#define rotr32 _lrotr +#else +#define rotl32(x,n) (((x) << n) | ((x) >> (32 - n))) +#define rotr32(x,n) (((x) >> n) | ((x) << (32 - n))) +#endif + +#if !defined(bswap_32) +#define bswap_32(x) ((rotr32((x), 24) & 0x00ff00ff) | (rotr32((x), 8) & 0xff00ff00)) +#endif + +#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN) +#define SWAP_BYTES +#else +#undef SWAP_BYTES +#endif + +#if defined(SWAP_BYTES) +#define bsw_32(p,n) \ + { int _i = (n); while(_i--) ((uint_32t*)p)[_i] = bswap_32(((uint_32t*)p)[_i]); } +#else +#define bsw_32(p,n) +#endif + +#define SHA1_MASK (SHA1_BLOCK_SIZE - 1) + +#if 0 + +#define ch(x,y,z) (((x) & (y)) ^ (~(x) & (z))) +#define parity(x,y,z) ((x) ^ (y) ^ (z)) +#define maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z))) + +#else /* Discovered by Rich Schroeppel and Colin Plumb */ + +#define ch(x,y,z) ((z) ^ ((x) & ((y) ^ (z)))) +#define parity(x,y,z) ((x) ^ (y) ^ (z)) +#define maj(x,y,z) (((x) & (y)) | ((z) & ((x) ^ (y)))) + +#endif + +/* Compile 64 bytes of hash data into SHA1 context. Note */ +/* that this routine assumes that the byte order in the */ +/* ctx->wbuf[] at this point is in such an order that low */ +/* address bytes in the ORIGINAL byte stream will go in */ +/* this buffer to the high end of 32-bit words on BOTH big */ +/* and little endian systems */ + +#ifdef ARRAY +#define q(v,n) v[n] +#else +#define q(v,n) v##n +#endif + +#define one_cycle(v,a,b,c,d,e,f,k,h) \ + q(v,e) += rotr32(q(v,a),27) + \ + f(q(v,b),q(v,c),q(v,d)) + k + h; \ + q(v,b) = rotr32(q(v,b), 2) + +#define five_cycle(v,f,k,i) \ + one_cycle(v, 0,1,2,3,4, f,k,hf(i )); \ + one_cycle(v, 4,0,1,2,3, f,k,hf(i+1)); \ + one_cycle(v, 3,4,0,1,2, f,k,hf(i+2)); \ + one_cycle(v, 2,3,4,0,1, f,k,hf(i+3)); \ + one_cycle(v, 1,2,3,4,0, f,k,hf(i+4)) + +VOID_RETURN sha1_compile(sha1_ctx ctx[1]) +{ uint_32t *w = ctx->wbuf; + +#ifdef ARRAY + uint_32t v[5]; + memcpy(v, ctx->hash, 5 * sizeof(uint_32t)); +#else + uint_32t v0, v1, v2, v3, v4; + v0 = ctx->hash[0]; v1 = ctx->hash[1]; + v2 = ctx->hash[2]; v3 = ctx->hash[3]; + v4 = ctx->hash[4]; +#endif + +#define hf(i) w[i] + + five_cycle(v, ch, 0x5a827999, 0); + five_cycle(v, ch, 0x5a827999, 5); + five_cycle(v, ch, 0x5a827999, 10); + one_cycle(v,0,1,2,3,4, ch, 0x5a827999, hf(15)); \ + +#undef hf +#define hf(i) (w[(i) & 15] = rotl32( \ + w[((i) + 13) & 15] ^ w[((i) + 8) & 15] \ + ^ w[((i) + 2) & 15] ^ w[(i) & 15], 1)) + + one_cycle(v,4,0,1,2,3, ch, 0x5a827999, hf(16)); + one_cycle(v,3,4,0,1,2, ch, 0x5a827999, hf(17)); + one_cycle(v,2,3,4,0,1, ch, 0x5a827999, hf(18)); + one_cycle(v,1,2,3,4,0, ch, 0x5a827999, hf(19)); + + five_cycle(v, parity, 0x6ed9eba1, 20); + five_cycle(v, parity, 0x6ed9eba1, 25); + five_cycle(v, parity, 0x6ed9eba1, 30); + five_cycle(v, parity, 0x6ed9eba1, 35); + + five_cycle(v, maj, 0x8f1bbcdc, 40); + five_cycle(v, maj, 0x8f1bbcdc, 45); + five_cycle(v, maj, 0x8f1bbcdc, 50); + five_cycle(v, maj, 0x8f1bbcdc, 55); + + five_cycle(v, parity, 0xca62c1d6, 60); + five_cycle(v, parity, 0xca62c1d6, 65); + five_cycle(v, parity, 0xca62c1d6, 70); + five_cycle(v, parity, 0xca62c1d6, 75); + +#ifdef ARRAY + ctx->hash[0] += v[0]; ctx->hash[1] += v[1]; + ctx->hash[2] += v[2]; ctx->hash[3] += v[3]; + ctx->hash[4] += v[4]; +#else + ctx->hash[0] += v0; ctx->hash[1] += v1; + ctx->hash[2] += v2; ctx->hash[3] += v3; + ctx->hash[4] += v4; +#endif +} + +VOID_RETURN sha1_begin(sha1_ctx ctx[1]) +{ + ctx->count[0] = ctx->count[1] = 0; + ctx->hash[0] = 0x67452301; + ctx->hash[1] = 0xefcdab89; + ctx->hash[2] = 0x98badcfe; + ctx->hash[3] = 0x10325476; + ctx->hash[4] = 0xc3d2e1f0; +} + +/* SHA1 hash data in an array of bytes into hash buffer and */ +/* call the hash_compile function as required. */ + +VOID_RETURN sha1_hash(const unsigned char data[], unsigned long len, sha1_ctx ctx[1]) +{ uint_32t pos = (uint_32t)(ctx->count[0] & SHA1_MASK), + space = SHA1_BLOCK_SIZE - pos; + const unsigned char *sp = data; + + if((ctx->count[0] += len) < len) + ++(ctx->count[1]); + + while(len >= space) /* tranfer whole blocks if possible */ + { + memcpy(((unsigned char*)ctx->wbuf) + pos, sp, space); + sp += space; len -= space; space = SHA1_BLOCK_SIZE; pos = 0; + bsw_32(ctx->wbuf, SHA1_BLOCK_SIZE >> 2); + sha1_compile(ctx); + } + + memcpy(((unsigned char*)ctx->wbuf) + pos, sp, len); +} + +/* SHA1 final padding and digest calculation */ + +VOID_RETURN sha1_end(unsigned char hval[], sha1_ctx ctx[1]) +{ uint_32t i = (uint_32t)(ctx->count[0] & SHA1_MASK); + + /* put bytes in the buffer in an order in which references to */ + /* 32-bit words will put bytes with lower addresses into the */ + /* top of 32 bit words on BOTH big and little endian machines */ + bsw_32(ctx->wbuf, (i + 3) >> 2); + + /* we now need to mask valid bytes and add the padding which is */ + /* a single 1 bit and as many zero bits as necessary. Note that */ + /* we can always add the first padding byte here because the */ + /* buffer always has at least one empty slot */ + ctx->wbuf[i >> 2] &= 0xffffff80 << 8 * (~i & 3); + ctx->wbuf[i >> 2] |= 0x00000080 << 8 * (~i & 3); + + /* we need 9 or more empty positions, one for the padding byte */ + /* (above) and eight for the length count. If there is not */ + /* enough space, pad and empty the buffer */ + if(i > SHA1_BLOCK_SIZE - 9) + { + if(i < 60) ctx->wbuf[15] = 0; + sha1_compile(ctx); + i = 0; + } + else /* compute a word index for the empty buffer positions */ + i = (i >> 2) + 1; + + while(i < 14) /* and zero pad all but last two positions */ + ctx->wbuf[i++] = 0; + + /* the following 32-bit length fields are assembled in the */ + /* wrong byte order on little endian machines but this is */ + /* corrected later since they are only ever used as 32-bit */ + /* word values. */ + ctx->wbuf[14] = (ctx->count[1] << 3) | (ctx->count[0] >> 29); + ctx->wbuf[15] = ctx->count[0] << 3; + sha1_compile(ctx); + + /* extract the hash value as bytes in case the hash buffer is */ + /* misaligned for 32-bit words */ + for(i = 0; i < SHA1_DIGEST_SIZE; ++i) + hval[i] = (unsigned char)(ctx->hash[i >> 2] >> (8 * (~i & 3))); +} + +VOID_RETURN sha1(unsigned char hval[], const unsigned char data[], unsigned long len) +{ sha1_ctx cx[1]; + + sha1_begin(cx); sha1_hash(data, len, cx); sha1_end(hval, cx); +} + +#if defined(__cplusplus) +} +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/sha1.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/sha1.h new file mode 100755 index 0000000..bace6af --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/aes/sha1.h @@ -0,0 +1,73 @@ +/* + --------------------------------------------------------------------------- + Copyright (c) 2002, Dr Brian Gladman, Worcester, UK. All rights reserved. + + LICENSE TERMS + + The free distribution and use of this software in both source and binary + form is allowed (with or without changes) provided that: + + 1. distributions of this source code include the above copyright + notice, this list of conditions and the following disclaimer; + + 2. distributions in binary form include the above copyright + notice, this list of conditions and the following disclaimer + in the documentation and/or other associated materials; + + 3. the copyright holder's name is not used to endorse products + built using this software without specific written permission. + + ALTERNATIVELY, provided that this notice is retained in full, this product + may be distributed under the terms of the GNU General Public License (GPL), + in which case the provisions of the GPL apply INSTEAD OF those given above. + + DISCLAIMER + + This software is provided 'as is' with no explicit or implied warranties + in respect of its properties, including, but not limited to, correctness + and/or fitness for purpose. + --------------------------------------------------------------------------- + Issue Date: 01/08/2005 +*/ + +#ifndef _SHA1_H +#define _SHA1_H + +#include +#include "brg_types.h" + +#define SHA1_BLOCK_SIZE 64 +#define SHA1_DIGEST_SIZE 20 + +#if defined(__cplusplus) +extern "C" +{ +#endif + +/* type to hold the SHA256 context */ + +typedef struct +{ uint_32t count[2]; + uint_32t hash[5]; + uint_32t wbuf[16]; +} sha1_ctx; + +/* Note that these prototypes are the same for both bit and */ +/* byte oriented implementations. However the length fields */ +/* are in bytes or bits as appropriate for the version used */ +/* and bit sequences are input as arrays of bytes in which */ +/* bit sequences run from the most to the least significant */ +/* end of each byte */ + +VOID_RETURN sha1_compile(sha1_ctx ctx[1]); + +VOID_RETURN sha1_begin(sha1_ctx ctx[1]); +VOID_RETURN sha1_hash(const unsigned char data[], unsigned long len, sha1_ctx ctx[1]); +VOID_RETURN sha1_end(unsigned char hval[], sha1_ctx ctx[1]); +VOID_RETURN sha1(unsigned char hval[], const unsigned char data[], unsigned long len); + +#if defined(__cplusplus) +} +#endif + +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/crypt.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/crypt.h new file mode 100755 index 0000000..46c63fb --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/crypt.h @@ -0,0 +1,130 @@ +/* crypt.h -- base code for traditional PKWARE encryption + Version 1.01e, February 12th, 2005 + + Copyright (C) 1998-2005 Gilles Vollant + Modifications for Info-ZIP crypting + Copyright (C) 2003 Terry Thorsen + + This code is a modified version of crypting code in Info-ZIP distribution + + Copyright (C) 1990-2000 Info-ZIP. All rights reserved. + + See the Info-ZIP LICENSE file version 2000-Apr-09 or later for terms of use + which also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html + + The encryption/decryption parts of this source code (as opposed to the + non-echoing password parts) were originally written in Europe. The + whole source package can be freely distributed, including from the USA. + (Prior to January 2000, re-export from the US was a violation of US law.) + + This encryption code is a direct transcription of the algorithm from + Roger Schlafly, described by Phil Katz in the file appnote.txt. This + file (appnote.txt) is distributed with the PKZIP program (even in the + version without encryption capabilities). + + If you don't need crypting in your application, just define symbols + NOCRYPT and NOUNCRYPT. +*/ + +#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8)) + +/*********************************************************************** + * Return the next byte in the pseudo-random sequence + */ +static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab) +{ + unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an + * unpredictable manner on 16-bit systems; not a problem + * with any known compiler so far, though */ + + temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2; + return (int)(((temp * (temp ^ 1)) >> 8) & 0xff); +} + +/*********************************************************************** + * Update the encryption keys with the next byte of plain text + */ +static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c) +{ + (*(pkeys+0)) = CRC32((*(pkeys+0)), c); + (*(pkeys+1)) += (*(pkeys+0)) & 0xff; + (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1; + { + register int keyshift = (int)((*(pkeys+1)) >> 24); + (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift); + } + return c; +} + + +/*********************************************************************** + * Initialize the encryption keys and the random header according to + * the given password. + */ +static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab) +{ + *(pkeys+0) = 305419896L; + *(pkeys+1) = 591751049L; + *(pkeys+2) = 878082192L; + while (*passwd != 0) { + update_keys(pkeys,pcrc_32_tab,(int)*passwd); + passwd++; + } +} + +#define zdecode(pkeys,pcrc_32_tab,c) \ + (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab))) + +#define zencode(pkeys,pcrc_32_tab,c,t) \ + (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c)) + +#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED + +#define RAND_HEAD_LEN 12 + /* "last resort" source for second part of crypt seed pattern */ +# ifndef ZCR_SEED2 +# define ZCR_SEED2 3141592654UL /* use PI as default pattern */ +# endif + +static int crypthead(const char* passwd, /* password string */ + unsigned char* buf, /* where to write header */ + int bufSize, + unsigned long* pkeys, + const unsigned long* pcrc_32_tab, + unsigned long crcForCrypting) +{ + int n; /* index in random header */ + int t; /* temporary */ + int c; /* random byte */ + unsigned char header[RAND_HEAD_LEN-2]; /* random header */ + static unsigned calls = 0; /* ensure different random header each time */ + + if (bufSize> 7) & 0xff; + header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t); + } + /* Encrypt random header (last two bytes is high word of crc) */ + init_keys(passwd, pkeys, pcrc_32_tab); + for (n = 0; n < RAND_HEAD_LEN-2; n++) + { + buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t); + } + buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t); + buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t); + return n; +} + +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/ioapi.c b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/ioapi.c new file mode 100755 index 0000000..857f7b9 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/ioapi.c @@ -0,0 +1,369 @@ +/* ioapi.h -- IO base function header for compress/uncompress .zip + part of the MiniZip project + + Copyright (C) 1998-2010 Gilles Vollant + http://www.winimage.com/zLibDll/minizip.html + Modifications for Zip64 support + Copyright (C) 2009-2010 Mathias Svensson + http://result42.com + + This program is distributed under the terms of the same license as zlib. + See the accompanying LICENSE file for the full text of the license. +*/ + +#include +#include + +#include "ioapi.h" + +#if defined(_WIN32) +# define snprintf _snprintf +#endif + +#ifdef __APPLE__ +/* In darwin and perhaps other BSD variants off_t is a 64 bit value, hence no need for specific 64 bit functions */ +# define FOPEN_FUNC(filename, mode) fopen(filename, mode) +# define FTELLO_FUNC(stream) ftello(stream) +# define FSEEKO_FUNC(stream, offset, origin) fseeko(stream, offset, origin) +#else +# define FOPEN_FUNC(filename, mode) fopen64(filename, mode) +# define FTELLO_FUNC(stream) ftello64(stream) +# define FSEEKO_FUNC(stream, offset, origin) fseeko64(stream, offset, origin) +#endif + +/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ +#ifndef SEEK_CUR +# define SEEK_CUR 1 +#endif +#ifndef SEEK_END +# define SEEK_END 2 +#endif +#ifndef SEEK_SET +# define SEEK_SET 0 +#endif + +voidpf call_zopen64 (const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode) +{ + if (pfilefunc->zfile_func64.zopen64_file != NULL) + return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque,filename,mode); + return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque,(const char*)filename,mode); +} + +voidpf call_zopendisk64 OF((const zlib_filefunc64_32_def* pfilefunc, voidpf filestream, int number_disk, int mode)) +{ + if (pfilefunc->zfile_func64.zopendisk64_file != NULL) + return (*(pfilefunc->zfile_func64.zopendisk64_file)) (pfilefunc->zfile_func64.opaque,filestream,number_disk,mode); + return (*(pfilefunc->zopendisk32_file))(pfilefunc->zfile_func64.opaque,filestream,number_disk,mode); +} + +long call_zseek64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin) +{ + uLong offsetTruncated; + if (pfilefunc->zfile_func64.zseek64_file != NULL) + return (*(pfilefunc->zfile_func64.zseek64_file)) (pfilefunc->zfile_func64.opaque,filestream,offset,origin); + offsetTruncated = (uLong)offset; + if (offsetTruncated != offset) + return -1; + return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream,offsetTruncated,origin); +} + +ZPOS64_T call_ztell64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream) +{ + uLong tell_uLong; + if (pfilefunc->zfile_func64.zseek64_file != NULL) + return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque,filestream); + tell_uLong = (*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque,filestream); + if ((tell_uLong) == 0xffffffff) + return (ZPOS64_T)-1; + return tell_uLong; +} + +void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32) +{ + p_filefunc64_32->zfile_func64.zopen64_file = NULL; + p_filefunc64_32->zfile_func64.zopendisk64_file = NULL; + p_filefunc64_32->zopen32_file = p_filefunc32->zopen_file; + p_filefunc64_32->zopendisk32_file = p_filefunc32->zopendisk_file; + p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file; + p_filefunc64_32->zfile_func64.zread_file = p_filefunc32->zread_file; + p_filefunc64_32->zfile_func64.zwrite_file = p_filefunc32->zwrite_file; + p_filefunc64_32->zfile_func64.ztell64_file = NULL; + p_filefunc64_32->zfile_func64.zseek64_file = NULL; + p_filefunc64_32->zfile_func64.zclose_file = p_filefunc32->zclose_file; + p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file; + p_filefunc64_32->zfile_func64.opaque = p_filefunc32->opaque; + p_filefunc64_32->zseek32_file = p_filefunc32->zseek_file; + p_filefunc64_32->ztell32_file = p_filefunc32->ztell_file; +} + +static voidpf ZCALLBACK fopen_file_func OF((voidpf opaque, const char* filename, int mode)); +static uLong ZCALLBACK fread_file_func OF((voidpf opaque, voidpf stream, void* buf, uLong size)); +static uLong ZCALLBACK fwrite_file_func OF((voidpf opaque, voidpf stream, const void* buf,uLong size)); +static ZPOS64_T ZCALLBACK ftell64_file_func OF((voidpf opaque, voidpf stream)); +static long ZCALLBACK fseek64_file_func OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin)); +static int ZCALLBACK fclose_file_func OF((voidpf opaque, voidpf stream)); +static int ZCALLBACK ferror_file_func OF((voidpf opaque, voidpf stream)); + +typedef struct +{ + FILE *file; + int filenameLength; + void *filename; +} FILE_IOPOSIX; + +static voidpf file_build_ioposix(FILE *file, const char *filename) +{ + FILE_IOPOSIX *ioposix = NULL; + if (file == NULL) + return NULL; + ioposix = (FILE_IOPOSIX*)malloc(sizeof(FILE_IOPOSIX)); + ioposix->file = file; + ioposix->filenameLength = (int)strlen(filename) + 1; + ioposix->filename = (char*)malloc(ioposix->filenameLength * sizeof(char)); + strncpy(ioposix->filename, filename, ioposix->filenameLength); + return (voidpf)ioposix; +} + +static voidpf ZCALLBACK fopen_file_func (voidpf opaque, const char* filename, int mode) +{ + FILE* file = NULL; + const char* mode_fopen = NULL; + if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ) + mode_fopen = "rb"; + else if (mode & ZLIB_FILEFUNC_MODE_EXISTING) + mode_fopen = "r+b"; + else if (mode & ZLIB_FILEFUNC_MODE_CREATE) + mode_fopen = "wb"; + + if ((filename != NULL) && (mode_fopen != NULL)) + { + file = fopen(filename, mode_fopen); + return file_build_ioposix(file, filename); + } + return file; +} + +static voidpf ZCALLBACK fopen64_file_func (voidpf opaque, const void* filename, int mode) +{ + FILE* file = NULL; + const char* mode_fopen = NULL; + if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ) + mode_fopen = "rb"; + else if (mode & ZLIB_FILEFUNC_MODE_EXISTING) + mode_fopen = "r+b"; + else if (mode & ZLIB_FILEFUNC_MODE_CREATE) + mode_fopen = "wb"; + + if ((filename != NULL) && (mode_fopen != NULL)) + { + file = FOPEN_FUNC((const char*)filename, mode_fopen); + return file_build_ioposix(file, (const char*)filename); + } + return file; +} + +static voidpf ZCALLBACK fopendisk64_file_func (voidpf opaque, voidpf stream, int number_disk, int mode) +{ + FILE_IOPOSIX *ioposix = NULL; + char *diskFilename = NULL; + voidpf ret = NULL; + int i = 0; + + if (stream == NULL) + return NULL; + ioposix = (FILE_IOPOSIX*)stream; + diskFilename = (char*)malloc(ioposix->filenameLength * sizeof(char)); + strncpy(diskFilename, ioposix->filename, ioposix->filenameLength); + for (i = ioposix->filenameLength - 1; i >= 0; i -= 1) + { + if (diskFilename[i] != '.') + continue; + snprintf(&diskFilename[i], ioposix->filenameLength - i, ".z%02d", number_disk + 1); + break; + } + if (i >= 0) + ret = fopen64_file_func(opaque, diskFilename, mode); + free(diskFilename); + return ret; +} + +static voidpf ZCALLBACK fopendisk_file_func (voidpf opaque, voidpf stream, int number_disk, int mode) +{ + FILE_IOPOSIX *ioposix = NULL; + char *diskFilename = NULL; + voidpf ret = NULL; + int i = 0; + + if (stream == NULL) + return NULL; + ioposix = (FILE_IOPOSIX*)stream; + diskFilename = (char*)malloc(ioposix->filenameLength * sizeof(char)); + strncpy(diskFilename, ioposix->filename, ioposix->filenameLength); + for (i = ioposix->filenameLength - 1; i >= 0; i -= 1) + { + if (diskFilename[i] != '.') + continue; + snprintf(&diskFilename[i], ioposix->filenameLength - i, ".z%02d", number_disk + 1); + break; + } + if (i >= 0) + ret = fopen_file_func(opaque, diskFilename, mode); + free(diskFilename); + return ret; +} + +static uLong ZCALLBACK fread_file_func (voidpf opaque, voidpf stream, void* buf, uLong size) +{ + FILE_IOPOSIX *ioposix = NULL; + uLong ret; + if (stream == NULL) + return -1; + ioposix = (FILE_IOPOSIX*)stream; + ret = (uLong)fread(buf, 1, (size_t)size, ioposix->file); + return ret; +} + +static uLong ZCALLBACK fwrite_file_func (voidpf opaque, voidpf stream, const void* buf, uLong size) +{ + FILE_IOPOSIX *ioposix = NULL; + uLong ret; + if (stream == NULL) + return -1; + ioposix = (FILE_IOPOSIX*)stream; + ret = (uLong)fwrite(buf, 1, (size_t)size, ioposix->file); + return ret; +} + +static long ZCALLBACK ftell_file_func (voidpf opaque, voidpf stream) +{ + FILE_IOPOSIX *ioposix = NULL; + long ret = -1; + if (stream == NULL) + return ret; + ioposix = (FILE_IOPOSIX*)stream; + ret = ftell(ioposix->file); + return ret; +} + +static ZPOS64_T ZCALLBACK ftell64_file_func (voidpf opaque, voidpf stream) +{ + FILE_IOPOSIX *ioposix = NULL; + ZPOS64_T ret = -1; + if (stream == NULL) + return ret; + ioposix = (FILE_IOPOSIX*)stream; + ret = FTELLO_FUNC(ioposix->file); + return ret; +} + +static long ZCALLBACK fseek_file_func (voidpf opaque, voidpf stream, uLong offset, int origin) +{ + FILE_IOPOSIX *ioposix = NULL; + int fseek_origin = 0; + long ret = 0; + + if (stream == NULL) + return -1; + ioposix = (FILE_IOPOSIX*)stream; + + switch (origin) + { + case ZLIB_FILEFUNC_SEEK_CUR: + fseek_origin = SEEK_CUR; + break; + case ZLIB_FILEFUNC_SEEK_END: + fseek_origin = SEEK_END; + break; + case ZLIB_FILEFUNC_SEEK_SET: + fseek_origin = SEEK_SET; + break; + default: + return -1; + } + if (fseek(ioposix->file, offset, fseek_origin) != 0) + ret = -1; + return ret; +} + +static long ZCALLBACK fseek64_file_func (voidpf opaque, voidpf stream, ZPOS64_T offset, int origin) +{ + FILE_IOPOSIX *ioposix = NULL; + int fseek_origin = 0; + long ret = 0; + + if (stream == NULL) + return -1; + ioposix = (FILE_IOPOSIX*)stream; + + switch (origin) + { + case ZLIB_FILEFUNC_SEEK_CUR: + fseek_origin = SEEK_CUR; + break; + case ZLIB_FILEFUNC_SEEK_END: + fseek_origin = SEEK_END; + break; + case ZLIB_FILEFUNC_SEEK_SET: + fseek_origin = SEEK_SET; + break; + default: + return -1; + } + + if(FSEEKO_FUNC(ioposix->file, offset, fseek_origin) != 0) + ret = -1; + + return ret; +} + + +static int ZCALLBACK fclose_file_func (voidpf opaque, voidpf stream) +{ + FILE_IOPOSIX *ioposix = NULL; + int ret = -1; + if (stream == NULL) + return ret; + ioposix = (FILE_IOPOSIX*)stream; + if (ioposix->filename != NULL) + free(ioposix->filename); + ret = fclose(ioposix->file); + free(ioposix); + return ret; +} + +static int ZCALLBACK ferror_file_func (voidpf opaque, voidpf stream) +{ + FILE_IOPOSIX *ioposix = NULL; + int ret = -1; + if (stream == NULL) + return ret; + ioposix = (FILE_IOPOSIX*)stream; + ret = ferror(ioposix->file); + return ret; +} + +void fill_fopen_filefunc (zlib_filefunc_def* pzlib_filefunc_def) +{ + pzlib_filefunc_def->zopen_file = fopen_file_func; + pzlib_filefunc_def->zopendisk_file = fopendisk_file_func; + pzlib_filefunc_def->zread_file = fread_file_func; + pzlib_filefunc_def->zwrite_file = fwrite_file_func; + pzlib_filefunc_def->ztell_file = ftell_file_func; + pzlib_filefunc_def->zseek_file = fseek_file_func; + pzlib_filefunc_def->zclose_file = fclose_file_func; + pzlib_filefunc_def->zerror_file = ferror_file_func; + pzlib_filefunc_def->opaque = NULL; +} + +void fill_fopen64_filefunc (zlib_filefunc64_def* pzlib_filefunc_def) +{ + pzlib_filefunc_def->zopen64_file = fopen64_file_func; + pzlib_filefunc_def->zopendisk64_file = fopendisk64_file_func; + pzlib_filefunc_def->zread_file = fread_file_func; + pzlib_filefunc_def->zwrite_file = fwrite_file_func; + pzlib_filefunc_def->ztell64_file = ftell64_file_func; + pzlib_filefunc_def->zseek64_file = fseek64_file_func; + pzlib_filefunc_def->zclose_file = fclose_file_func; + pzlib_filefunc_def->zerror_file = ferror_file_func; + pzlib_filefunc_def->opaque = NULL; +} diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/ioapi.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/ioapi.h new file mode 100755 index 0000000..742fae5 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/ioapi.h @@ -0,0 +1,175 @@ +/* ioapi.h -- IO base function header for compress/uncompress .zip + part of the MiniZip project + + Copyright (C) 1998-2010 Gilles Vollant + http://www.winimage.com/zLibDll/minizip.html + Modifications for Zip64 support + Copyright (C) 2009-2010 Mathias Svensson + http://result42.com + + This program is distributed under the terms of the same license as zlib. + See the accompanying LICENSE file for the full text of the license. +*/ + +#ifndef _ZLIBIOAPI64_H +#define _ZLIBIOAPI64_H + +#if (!defined(_WIN32)) && (!defined(WIN32)) && (!defined(__APPLE__)) +# ifndef __USE_FILE_OFFSET64 +# define __USE_FILE_OFFSET64 +# endif +# ifndef __USE_LARGEFILE64 +# define __USE_LARGEFILE64 +# endif +# ifndef _LARGEFILE64_SOURCE +# define _LARGEFILE64_SOURCE +# endif +# ifndef _FILE_OFFSET_BIT +# define _FILE_OFFSET_BIT 64 +# endif +#endif + +#include +#include +#include "zlib.h" + +#if defined(USE_FILE32API) +# define fopen64 fopen +# define ftello64 ftell +# define fseeko64 fseek +#else +# if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__DragonFly__) || defined(__OpenBSD__) +# define fopen64 fopen +# define ftello64 ftello +# define fseeko64 fseeko +# endif +# ifdef _MSC_VER +# define fopen64 fopen +# if (_MSC_VER >= 1400) && (!(defined(NO_MSCVER_FILE64_FUNC))) +# define ftello64 _ftelli64 +# define fseeko64 _fseeki64 +# else /* old MSC */ +# define ftello64 ftell +# define fseeko64 fseek +# endif +# endif +#endif + +/* a type choosen by DEFINE */ +#ifdef HAVE_64BIT_INT_CUSTOM +typedef 64BIT_INT_CUSTOM_TYPE ZPOS64_T; +#else +# ifdef HAS_STDINT_H +# include "stdint.h" + typedef uint64_t ZPOS64_T; +# else +# if defined(_MSC_VER) || defined(__BORLANDC__) + typedef unsigned __int64 ZPOS64_T; +# else + typedef unsigned long long int ZPOS64_T; +# endif +# endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#define ZLIB_FILEFUNC_SEEK_CUR (1) +#define ZLIB_FILEFUNC_SEEK_END (2) +#define ZLIB_FILEFUNC_SEEK_SET (0) + +#define ZLIB_FILEFUNC_MODE_READ (1) +#define ZLIB_FILEFUNC_MODE_WRITE (2) +#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3) +#define ZLIB_FILEFUNC_MODE_EXISTING (4) +#define ZLIB_FILEFUNC_MODE_CREATE (8) + +#ifndef ZCALLBACK +# if (defined(WIN32) || defined(_WIN32) || defined (WINDOWS) || \ + defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK) +# define ZCALLBACK CALLBACK +# else +# define ZCALLBACK +# endif +#endif + +typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode)); +typedef voidpf (ZCALLBACK *opendisk_file_func) OF((voidpf opaque, voidpf stream, int number_disk, int mode)); +typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size)); +typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size)); +typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream)); +typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream)); + +typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream)); +typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin)); + +/* here is the "old" 32 bits structure structure */ +typedef struct zlib_filefunc_def_s +{ + open_file_func zopen_file; + opendisk_file_func zopendisk_file; + read_file_func zread_file; + write_file_func zwrite_file; + tell_file_func ztell_file; + seek_file_func zseek_file; + close_file_func zclose_file; + testerror_file_func zerror_file; + voidpf opaque; +} zlib_filefunc_def; + +typedef ZPOS64_T (ZCALLBACK *tell64_file_func) OF((voidpf opaque, voidpf stream)); +typedef long (ZCALLBACK *seek64_file_func) OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin)); +typedef voidpf (ZCALLBACK *open64_file_func) OF((voidpf opaque, const void* filename, int mode)); +typedef voidpf (ZCALLBACK *opendisk64_file_func)OF((voidpf opaque, voidpf stream, int number_disk, int mode)); + +typedef struct zlib_filefunc64_def_s +{ + open64_file_func zopen64_file; + opendisk64_file_func zopendisk64_file; + read_file_func zread_file; + write_file_func zwrite_file; + tell64_file_func ztell64_file; + seek64_file_func zseek64_file; + close_file_func zclose_file; + testerror_file_func zerror_file; + voidpf opaque; +} zlib_filefunc64_def; + +void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); +void fill_fopen64_filefunc OF((zlib_filefunc64_def* pzlib_filefunc_def)); + +/* now internal definition, only for zip.c and unzip.h */ +typedef struct zlib_filefunc64_32_def_s +{ + zlib_filefunc64_def zfile_func64; + open_file_func zopen32_file; + opendisk_file_func zopendisk32_file; + tell_file_func ztell32_file; + seek_file_func zseek32_file; +} zlib_filefunc64_32_def; + +#define ZREAD64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zread_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size)) +#define ZWRITE64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zwrite_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size)) +/*#define ZTELL64(filefunc,filestream) ((*((filefunc).ztell64_file)) ((filefunc).opaque,filestream))*/ +/*#define ZSEEK64(filefunc,filestream,pos,mode) ((*((filefunc).zseek64_file)) ((filefunc).opaque,filestream,pos,mode))*/ +#define ZCLOSE64(filefunc,filestream) ((*((filefunc).zfile_func64.zclose_file)) ((filefunc).zfile_func64.opaque,filestream)) +#define ZERROR64(filefunc,filestream) ((*((filefunc).zfile_func64.zerror_file)) ((filefunc).zfile_func64.opaque,filestream)) + +voidpf call_zopen64 OF((const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode)); +voidpf call_zopendisk64 OF((const zlib_filefunc64_32_def* pfilefunc, voidpf filestream, int number_disk, int mode)); +long call_zseek64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin)); +ZPOS64_T call_ztell64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream)); + +void fill_zlib_filefunc64_32_def_from_filefunc32 OF((zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32)); + +#define ZOPEN64(filefunc,filename,mode) (call_zopen64((&(filefunc)),(filename),(mode))) +#define ZOPENDISK64(filefunc,filestream,diskn,mode) (call_zopendisk64((&(filefunc)),(filestream),(diskn),(mode))) +#define ZTELL64(filefunc,filestream) (call_ztell64((&(filefunc)),(filestream))) +#define ZSEEK64(filefunc,filestream,pos,mode) (call_zseek64((&(filefunc)),(filestream),(pos),(mode))) + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/mztools.c b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/mztools.c new file mode 100755 index 0000000..80d50e0 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/mztools.c @@ -0,0 +1,284 @@ +/* + Additional tools for Minizip + Code: Xavier Roche '2004 + License: Same as ZLIB (www.gzip.org) +*/ + +/* Code */ +#include +#include +#include +#include "zlib.h" +#include "unzip.h" +#include "mztools.h" + +#define READ_8(adr) ((unsigned char)*(adr)) +#define READ_16(adr) ( READ_8(adr) | (READ_8(adr+1) << 8) ) +#define READ_32(adr) ( READ_16(adr) | (READ_16((adr)+2) << 16) ) + +#define WRITE_8(buff, n) do { \ + *((unsigned char*)(buff)) = (unsigned char) ((n) & 0xff); \ +} while(0) +#define WRITE_16(buff, n) do { \ + WRITE_8((unsigned char*)(buff), n); \ + WRITE_8(((unsigned char*)(buff)) + 1, (n) >> 8); \ +} while(0) +#define WRITE_32(buff, n) do { \ + WRITE_16((unsigned char*)(buff), (n) & 0xffff); \ + WRITE_16((unsigned char*)(buff) + 2, (n) >> 16); \ +} while(0) + +extern int ZEXPORT unzRepair(file, fileOut, fileOutTmp, nRecovered, bytesRecovered) +const char* file; +const char* fileOut; +const char* fileOutTmp; +uLong* nRecovered; +uLong* bytesRecovered; +{ + int err = Z_OK; + FILE* fpZip = fopen(file, "rb"); + FILE* fpOut = fopen(fileOut, "wb"); + FILE* fpOutCD = fopen(fileOutTmp, "wb"); + if (fpZip != NULL && fpOut != NULL) { + int entries = 0; + uLong totalBytes = 0; + char header[30]; + char filename[256]; + char extra[1024]; + int offset = 0; + int offsetCD = 0; + while ( fread(header, 1, 30, fpZip) == 30 ) { + int currentOffset = offset; + + /* File entry */ + if (READ_32(header) == 0x04034b50) { + unsigned int version = READ_16(header + 4); + unsigned int gpflag = READ_16(header + 6); + unsigned int method = READ_16(header + 8); + unsigned int filetime = READ_16(header + 10); + unsigned int filedate = READ_16(header + 12); + unsigned int crc = READ_32(header + 14); /* crc */ + unsigned int cpsize = READ_32(header + 18); /* compressed size */ + unsigned int uncpsize = READ_32(header + 22); /* uncompressed sz */ + unsigned int fnsize = READ_16(header + 26); /* file name length */ + unsigned int extsize = READ_16(header + 28); /* extra field length */ + filename[0] = extra[0] = '\0'; + + /* Header */ + if (fwrite(header, 1, 30, fpOut) == 30) { + offset += 30; + } else { + err = Z_ERRNO; + break; + } + + /* Filename */ + if (fnsize > 0) { + if (fread(filename, 1, fnsize, fpZip) == fnsize) { + if (fwrite(filename, 1, fnsize, fpOut) == fnsize) { + offset += fnsize; + } else { + err = Z_ERRNO; + break; + } + } else { + err = Z_ERRNO; + break; + } + } else { + err = Z_STREAM_ERROR; + break; + } + + /* Extra field */ + if (extsize > 0) { + if (fread(extra, 1, extsize, fpZip) == extsize) { + if (fwrite(extra, 1, extsize, fpOut) == extsize) { + offset += extsize; + } else { + err = Z_ERRNO; + break; + } + } else { + err = Z_ERRNO; + break; + } + } + + /* Data */ + { + int dataSize = cpsize; + if (dataSize == 0) { + dataSize = uncpsize; + } + if (dataSize > 0) { + char* data = malloc(dataSize); + if (data != NULL) { + if ((int)fread(data, 1, dataSize, fpZip) == dataSize) { + if ((int)fwrite(data, 1, dataSize, fpOut) == dataSize) { + offset += dataSize; + totalBytes += dataSize; + } else { + err = Z_ERRNO; + } + } else { + err = Z_ERRNO; + } + free(data); + if (err != Z_OK) { + break; + } + } else { + err = Z_MEM_ERROR; + break; + } + } + } + + /* Central directory entry */ + { + char centralDirectoryEntryHeader[46]; + //char* comment = ""; + //int comsize = (int) strlen(comment); + WRITE_32(centralDirectoryEntryHeader, 0x02014b50); + WRITE_16(centralDirectoryEntryHeader + 4, version); + WRITE_16(centralDirectoryEntryHeader + 6, version); + WRITE_16(centralDirectoryEntryHeader + 8, gpflag); + WRITE_16(centralDirectoryEntryHeader + 10, method); + WRITE_16(centralDirectoryEntryHeader + 12, filetime); + WRITE_16(centralDirectoryEntryHeader + 14, filedate); + WRITE_32(centralDirectoryEntryHeader + 16, crc); + WRITE_32(centralDirectoryEntryHeader + 20, cpsize); + WRITE_32(centralDirectoryEntryHeader + 24, uncpsize); + WRITE_16(centralDirectoryEntryHeader + 28, fnsize); + WRITE_16(centralDirectoryEntryHeader + 30, extsize); + WRITE_16(centralDirectoryEntryHeader + 32, 0 /*comsize*/); + WRITE_16(centralDirectoryEntryHeader + 34, 0); /* disk # */ + WRITE_16(centralDirectoryEntryHeader + 36, 0); /* int attrb */ + WRITE_32(centralDirectoryEntryHeader + 38, 0); /* ext attrb */ + WRITE_32(centralDirectoryEntryHeader + 42, currentOffset); + /* Header */ + if (fwrite(centralDirectoryEntryHeader, 1, 46, fpOutCD) == 46) { + offsetCD += 46; + + /* Filename */ + if (fnsize > 0) { + if (fwrite(filename, 1, fnsize, fpOutCD) == fnsize) { + offsetCD += fnsize; + } else { + err = Z_ERRNO; + break; + } + } else { + err = Z_STREAM_ERROR; + break; + } + + /* Extra field */ + if (extsize > 0) { + if (fwrite(extra, 1, extsize, fpOutCD) == extsize) { + offsetCD += extsize; + } else { + err = Z_ERRNO; + break; + } + } + + /* Comment field */ + /* + if (comsize > 0) { + if ((int)fwrite(comment, 1, comsize, fpOutCD) == comsize) { + offsetCD += comsize; + } else { + err = Z_ERRNO; + break; + } + } + */ + + } else { + err = Z_ERRNO; + break; + } + } + + /* Success */ + entries++; + + } else { + break; + } + } + + /* Final central directory */ + { + int entriesZip = entries; + char finalCentralDirectoryHeader[22]; + //char* comment = ""; // "ZIP File recovered by zlib/minizip/mztools"; + //int comsize = (int) strlen(comment); + if (entriesZip > 0xffff) { + entriesZip = 0xffff; + } + WRITE_32(finalCentralDirectoryHeader, 0x06054b50); + WRITE_16(finalCentralDirectoryHeader + 4, 0); /* disk # */ + WRITE_16(finalCentralDirectoryHeader + 6, 0); /* disk # */ + WRITE_16(finalCentralDirectoryHeader + 8, entriesZip); /* hack */ + WRITE_16(finalCentralDirectoryHeader + 10, entriesZip); /* hack */ + WRITE_32(finalCentralDirectoryHeader + 12, offsetCD); /* size of CD */ + WRITE_32(finalCentralDirectoryHeader + 16, offset); /* offset to CD */ + WRITE_16(finalCentralDirectoryHeader + 20, 0 /*comsize*/); /* comment */ + + /* Header */ + if (fwrite(finalCentralDirectoryHeader, 1, 22, fpOutCD) == 22) { + + /* Comment field */ + /* + if (comsize > 0) { + if ((int)fwrite(comment, 1, comsize, fpOutCD) != comsize) { + err = Z_ERRNO; + } + } + */ + } else { + err = Z_ERRNO; + } + } + + /* Final merge (file + central directory) */ + fclose(fpOutCD); + if (err == Z_OK) { + fpOutCD = fopen(fileOutTmp, "rb"); + if (fpOutCD != NULL) { + int nRead; + char buffer[8192]; + while ( (nRead = (int)fread(buffer, 1, sizeof(buffer), fpOutCD)) > 0) { + if ((int)fwrite(buffer, 1, nRead, fpOut) != nRead) { + err = Z_ERRNO; + break; + } + } + fclose(fpOutCD); + } + } + + /* Close */ + fclose(fpZip); + fclose(fpOut); + + /* Wipe temporary file */ + (void)remove(fileOutTmp); + + /* Number of recovered entries */ + if (err == Z_OK) { + if (nRecovered != NULL) { + *nRecovered = entries; + } + if (bytesRecovered != NULL) { + *bytesRecovered = totalBytes; + } + } + } else { + err = Z_STREAM_ERROR; + } + return err; +} diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/mztools.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/mztools.h new file mode 100755 index 0000000..88b3459 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/mztools.h @@ -0,0 +1,31 @@ +/* + Additional tools for Minizip + Code: Xavier Roche '2004 + License: Same as ZLIB (www.gzip.org) +*/ + +#ifndef _zip_tools_H +#define _zip_tools_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _ZLIB_H +#include "zlib.h" +#endif + +#include "unzip.h" + +/* Repair a ZIP file (missing central directory) + file: file to recover + fileOut: output file after recovery + fileOutTmp: temporary file name used for recovery +*/ +extern int ZEXPORT unzRepair(const char* file, + const char* fileOut, + const char* fileOutTmp, + uLong* nRecovered, + uLong* bytesRecovered); + +#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/unzip.c b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/unzip.c new file mode 100755 index 0000000..4b8eabc --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/unzip.c @@ -0,0 +1,1839 @@ +/* unzip.c -- IO for uncompress .zip files using zlib + Version 1.1, February 14h, 2010 + part of the MiniZip project + + Copyright (C) 1998-2010 Gilles Vollant + http://www.winimage.com/zLibDll/minizip.html + Modifications of Unzip for Zip64 + Copyright (C) 2007-2008 Even Rouault + Modifications for Zip64 support on both zip and unzip + Copyright (C) 2009-2010 Mathias Svensson + http://result42.com + Modifications for AES, PKWARE disk spanning + Copyright (C) 2010-2014 Nathan Moinvaziri + + This program is distributed under the terms of the same license as zlib. + See the accompanying LICENSE file for the full text of the license. + */ + + +#include +#include +#include + +/*#ifndef NOUNCRYPT + # define NOUNCRYPT + #endif*/ + +#include "zlib.h" +#include "unzip.h" + +#include "SSZipCommon.h" + +#ifdef STDC +# include +# include +# include +#endif +#ifdef NO_ERRNO_H +extern int errno; +#else +# include +#endif + +#ifdef HAVE_AES +# define AES_METHOD (99) +# define AES_PWVERIFYSIZE (2) +# define AES_MAXSALTLENGTH (16) +# define AES_AUTHCODESIZE (10) +# define AES_HEADERSIZE (11) +# define AES_KEYSIZE(mode) (64 + (mode * 64)) + +# include "aes.h" +# include "fileenc.h" +#endif +#ifndef NOUNCRYPT +# include "crypt.h" +#endif + +#ifndef local +# define local static +#endif +/* compile with -Dlocal if your debugger can't find static symbols */ + +#define DISKHEADERMAGIC (0x08074b50) +#define LOCALHEADERMAGIC (0x04034b50) +#define CENTRALHEADERMAGIC (0x02014b50) +#define ENDHEADERMAGIC (0x06054b50) +#define ZIP64ENDHEADERMAGIC (0x06064b50) +#define ZIP64ENDLOCHEADERMAGIC (0x07064b50) + +#define SIZECENTRALDIRITEM (0x2e) +#define SIZECENTRALHEADERLOCATOR (0x14) /* 20 */ +#define SIZEZIPLOCALHEADER (0x1e) + +#ifndef BUFREADCOMMENT +# define BUFREADCOMMENT (0x400) +#endif + +#ifndef UNZ_BUFSIZE +# define UNZ_BUFSIZE (64 * 1024) +#endif +#ifndef UNZ_MAXFILENAMEINZIP +# define UNZ_MAXFILENAMEINZIP (256) +#endif + +#ifndef ALLOC +# define ALLOC(size) (malloc(size)) +#endif +#ifndef TRYFREE +# define TRYFREE(p) {if (p) free(p); } +#endif + +const char unz_copyright[] = + " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll"; + +/* unz_file_info_interntal contain internal info about a file in zipfile*/ +typedef struct unz_file_info64_internal_s { + ZPOS64_T offset_curfile; /* relative offset of local header 8 bytes */ + ZPOS64_T byte_before_the_zipfile; /* byte before the zipfile, (>0 for sfx) */ +#ifdef HAVE_AES + uLong aes_encryption_mode; + uLong aes_compression_method; + uLong aes_version; +#endif +} unz_file_info64_internal; + +/* file_in_zip_read_info_s contain internal information about a file in zipfile */ +typedef struct { + Bytef *read_buffer; /* internal buffer for compressed data */ + z_stream stream; /* zLib stream structure for inflate */ + +#ifdef HAVE_BZIP2 + bz_stream bstream; /* bzLib stream structure for bziped */ +#endif +#ifdef HAVE_AES + fcrypt_ctx aes_ctx; +#endif + + ZPOS64_T pos_in_zipfile; /* position in byte on the zipfile, for fseek */ + uLong stream_initialised; /* flag set if stream structure is initialised */ + + ZPOS64_T offset_local_extrafield; /* offset of the local extra field */ + uInt size_local_extrafield; /* size of the local extra field */ + ZPOS64_T pos_local_extrafield; /* position in the local extra field in read */ + ZPOS64_T total_out_64; + + uLong crc32; /* crc32 of all data uncompressed */ + uLong crc32_wait; /* crc32 we must obtain after decompress all */ + ZPOS64_T rest_read_compressed; /* number of byte to be decompressed */ + ZPOS64_T rest_read_uncompressed; /* number of byte to be obtained after decomp */ + + zlib_filefunc64_32_def z_filefunc; + + voidpf filestream; /* io structore of the zipfile */ + uLong compression_method; /* compression method (0==store) */ + ZPOS64_T byte_before_the_zipfile; /* byte before the zipfile, (>0 for sfx) */ + int raw; +} file_in_zip64_read_info_s; + +/* unz64_s contain internal information about the zipfile */ +typedef struct { + zlib_filefunc64_32_def z_filefunc; + voidpf filestream; /* io structure of the current zipfile */ + voidpf filestream_with_CD; /* io structure of the disk with the central directory */ + unz_global_info64 gi; /* public global information */ + ZPOS64_T byte_before_the_zipfile; /* byte before the zipfile, (>0 for sfx)*/ + ZPOS64_T num_file; /* number of the current file in the zipfile*/ + ZPOS64_T pos_in_central_dir; /* pos of the current file in the central dir*/ + ZPOS64_T current_file_ok; /* flag about the usability of the current file*/ + ZPOS64_T central_pos; /* position of the beginning of the central dir*/ + uLong number_disk; /* number of the current disk, used for spanning ZIP*/ + ZPOS64_T size_central_dir; /* size of the central directory */ + ZPOS64_T offset_central_dir; /* offset of start of central directory with + respect to the starting disk number */ + + unz_file_info64 cur_file_info; /* public info about the current file in zip*/ + unz_file_info64_internal cur_file_info_internal; + /* private info about it*/ + file_in_zip64_read_info_s *pfile_in_zip_read; + /* structure about the current file if we are decompressing it */ + int isZip64; /* is the current file zip64 */ +#ifndef NOUNCRYPT + unsigned long keys[3]; /* keys defining the pseudo-random sequence */ + const unsigned long *pcrc_32_tab; +#endif +} unz64_s; + +/* Translate date/time from Dos format to tm_unz (readable more easily) */ +local void unz64local_DosDateToTmuDate(ZPOS64_T ulDosDate, tm_unz *ptm) +{ + ZPOS64_T uDate = (ZPOS64_T)(ulDosDate >> 16); + + ptm->tm_mday = (uInt)(uDate & 0x1f); + ptm->tm_mon = (uInt)((((uDate) & 0x1E0) / 0x20) - 1); + ptm->tm_year = (uInt)(((uDate & 0x0FE00) / 0x0200) + 1980); + ptm->tm_hour = (uInt)((ulDosDate & 0xF800) / 0x800); + ptm->tm_min = (uInt)((ulDosDate & 0x7E0) / 0x20); + ptm->tm_sec = (uInt)(2 * (ulDosDate & 0x1f)); + +#define unz64local_in_range(min, max, value) ((min) <= (value) && (value) <= (max)) + if (!unz64local_in_range(0, 11, ptm->tm_mon) || + !unz64local_in_range(1, 31, ptm->tm_mday) || + !unz64local_in_range(0, 23, ptm->tm_hour) || + !unz64local_in_range(0, 59, ptm->tm_min) || + !unz64local_in_range(0, 59, ptm->tm_sec)) + /* Invalid date stored, so don't return it. */ + memset(ptm, 0, sizeof(tm_unz)); +#undef unz64local_in_range +} + +/* Read a byte from a gz_stream; Return EOF for end of file. */ +local int unz64local_getByte(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, int *pi) +{ + unsigned char c; + int err = (int)ZREAD64(*pzlib_filefunc_def, filestream, &c, 1); + if (err == 1) { + *pi = (int)c; + return UNZ_OK; + } + if (ZERROR64(*pzlib_filefunc_def, filestream)) + return UNZ_ERRNO; + return UNZ_EOF; +} + +local int unz64local_getShort OF((const zlib_filefunc64_32_def * pzlib_filefunc_def, voidpf filestream, uLong * pX)); +local int unz64local_getShort(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uLong *pX) +{ + uLong x; + int i = 0; + int err; + + err = unz64local_getByte(pzlib_filefunc_def, filestream, &i); + x = (uLong)i; + if (err == UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def, filestream, &i); + x |= ((uLong)i) << 8; + + if (err == UNZ_OK) + *pX = x; + else + *pX = 0; + return err; +} + +local int unz64local_getLong OF((const zlib_filefunc64_32_def * pzlib_filefunc_def, voidpf filestream, uLong * pX)); +local int unz64local_getLong(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uLong *pX) +{ + uLong x; + int i = 0; + int err; + + err = unz64local_getByte(pzlib_filefunc_def, filestream, &i); + x = (uLong)i; + if (err == UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def, filestream, &i); + x |= ((uLong)i) << 8; + if (err == UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def, filestream, &i); + x |= ((uLong)i) << 16; + if (err == UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def, filestream, &i); + x += ((uLong)i) << 24; + + if (err == UNZ_OK) + *pX = x; + else + *pX = 0; + return err; +} + +local int unz64local_getLong64 OF((const zlib_filefunc64_32_def * pzlib_filefunc_def, voidpf filestream, ZPOS64_T * pX)); +local int unz64local_getLong64(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX) +{ + ZPOS64_T x; + int i = 0; + int err; + + err = unz64local_getByte(pzlib_filefunc_def, filestream, &i); + x = (ZPOS64_T)i; + if (err == UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def, filestream, &i); + x |= ((ZPOS64_T)i) << 8; + if (err == UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def, filestream, &i); + x |= ((ZPOS64_T)i) << 16; + if (err == UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def, filestream, &i); + x |= ((ZPOS64_T)i) << 24; + if (err == UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def, filestream, &i); + x |= ((ZPOS64_T)i) << 32; + if (err == UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def, filestream, &i); + x |= ((ZPOS64_T)i) << 40; + if (err == UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def, filestream, &i); + x |= ((ZPOS64_T)i) << 48; + if (err == UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def, filestream, &i); + x |= ((ZPOS64_T)i) << 56; + + if (err == UNZ_OK) + *pX = x; + else + *pX = 0; + return err; +} + +/* Locate the Central directory of a zip file (at the end, just before the global comment) */ +local ZPOS64_T unz64local_SearchCentralDir OF((const zlib_filefunc64_32_def * pzlib_filefunc_def, voidpf filestream)); +local ZPOS64_T unz64local_SearchCentralDir(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream) +{ + unsigned char *buf; + ZPOS64_T file_size; + ZPOS64_T back_read = 4; + ZPOS64_T max_back = 0xffff; /* maximum size of global comment */ + ZPOS64_T pos_found = 0; + uLong read_size; + ZPOS64_T read_pos; + int i; + + buf = (unsigned char *)ALLOC(BUFREADCOMMENT + 4); + if (buf == NULL) + return 0; + + if (ZSEEK64(*pzlib_filefunc_def, filestream, 0, ZLIB_FILEFUNC_SEEK_END) != 0) { + TRYFREE(buf); + return 0; + } + + file_size = ZTELL64(*pzlib_filefunc_def, filestream); + + if (max_back > file_size) + max_back = file_size; + + while (back_read < max_back) { + if (back_read + BUFREADCOMMENT > max_back) + back_read = max_back; + else + back_read += BUFREADCOMMENT; + + read_pos = file_size - back_read; + read_size = ((BUFREADCOMMENT + 4) < (file_size - read_pos)) ? + (BUFREADCOMMENT + 4) : (uLong)(file_size - read_pos); + + if (ZSEEK64(*pzlib_filefunc_def, filestream, read_pos, ZLIB_FILEFUNC_SEEK_SET) != 0) + break; + if (ZREAD64(*pzlib_filefunc_def, filestream, buf, read_size) != read_size) + break; + + for (i = (int)read_size - 3; (i--) > 0; ) + if (((*(buf + i)) == (ENDHEADERMAGIC & 0xff)) && + ((*(buf + i + 1)) == (ENDHEADERMAGIC >> 8 & 0xff)) && + ((*(buf + i + 2)) == (ENDHEADERMAGIC >> 16 & 0xff)) && + ((*(buf + i + 3)) == (ENDHEADERMAGIC >> 24 & 0xff))) { + pos_found = read_pos + i; + break; + } + + if (pos_found != 0) + break; + } + TRYFREE(buf); + return pos_found; +} + +/* Locate the Central directory 64 of a zipfile (at the end, just before the global comment) */ +local ZPOS64_T unz64local_SearchCentralDir64 OF((const zlib_filefunc64_32_def * pzlib_filefunc_def, voidpf filestream, + const ZPOS64_T endcentraloffset)); +local ZPOS64_T unz64local_SearchCentralDir64(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, + const ZPOS64_T endcentraloffset) +{ + ZPOS64_T offset; + uLong uL; + + /* Zip64 end of central directory locator */ + if (ZSEEK64(*pzlib_filefunc_def, filestream, endcentraloffset - SIZECENTRALHEADERLOCATOR, ZLIB_FILEFUNC_SEEK_SET) != 0) + return 0; + + /* read locator signature */ + if (unz64local_getLong(pzlib_filefunc_def, filestream, &uL) != UNZ_OK) + return 0; + if (uL != ZIP64ENDLOCHEADERMAGIC) + return 0; + /* number of the disk with the start of the zip64 end of central directory */ + if (unz64local_getLong(pzlib_filefunc_def, filestream, &uL) != UNZ_OK) + return 0; + /* relative offset of the zip64 end of central directory record */ + if (unz64local_getLong64(pzlib_filefunc_def, filestream, &offset) != UNZ_OK) + return 0; + /* total number of disks */ + if (unz64local_getLong(pzlib_filefunc_def, filestream, &uL) != UNZ_OK) + return 0; + /* Goto end of central directory record */ + if (ZSEEK64(*pzlib_filefunc_def, filestream, offset, ZLIB_FILEFUNC_SEEK_SET) != 0) + return 0; + /* the signature */ + if (unz64local_getLong(pzlib_filefunc_def, filestream, &uL) != UNZ_OK) + return 0; + if (uL != ZIP64ENDHEADERMAGIC) + return 0; + + return offset; +} + +local unzFile unzOpenInternal(const void *path, zlib_filefunc64_32_def *pzlib_filefunc64_32_def) +{ + unz64_s us; + unz64_s *s; + ZPOS64_T central_pos; + uLong uL; + voidpf filestream = NULL; + ZPOS64_T number_entry_CD; + int err = UNZ_OK; + + if (unz_copyright[0] != ' ') + return NULL; + + us.filestream = NULL; + us.filestream_with_CD = NULL; + us.z_filefunc.zseek32_file = NULL; + us.z_filefunc.ztell32_file = NULL; + if (pzlib_filefunc64_32_def == NULL) + fill_fopen64_filefunc(&us.z_filefunc.zfile_func64); + else + us.z_filefunc = *pzlib_filefunc64_32_def; + + us.filestream = ZOPEN64(us.z_filefunc, path, ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_EXISTING); + + if (us.filestream == NULL) + return NULL; + + us.filestream_with_CD = us.filestream; + us.isZip64 = 0; + + /* Use unz64local_SearchCentralDir first. Only based on the result + is it necessary to locate the unz64local_SearchCentralDir64 */ + central_pos = unz64local_SearchCentralDir(&us.z_filefunc, us.filestream); + if (central_pos) { + if (ZSEEK64(us.z_filefunc, us.filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0) + err = UNZ_ERRNO; + + /* the signature, already checked */ + if (unz64local_getLong(&us.z_filefunc, us.filestream, &uL) != UNZ_OK) + err = UNZ_ERRNO; + /* number of this disk */ + if (unz64local_getShort(&us.z_filefunc, us.filestream, &uL) != UNZ_OK) + err = UNZ_ERRNO; + us.number_disk = uL; + /* number of the disk with the start of the central directory */ + if (unz64local_getShort(&us.z_filefunc, us.filestream, &uL) != UNZ_OK) + err = UNZ_ERRNO; + us.gi.number_disk_with_CD = uL; + /* total number of entries in the central directory on this disk */ + if (unz64local_getShort(&us.z_filefunc, us.filestream, &uL) != UNZ_OK) + err = UNZ_ERRNO; + us.gi.number_entry = uL; + /* total number of entries in the central directory */ + if (unz64local_getShort(&us.z_filefunc, us.filestream, &uL) != UNZ_OK) + err = UNZ_ERRNO; + number_entry_CD = uL; + if (number_entry_CD != us.gi.number_entry) + err = UNZ_BADZIPFILE; + /* size of the central directory */ + if (unz64local_getLong(&us.z_filefunc, us.filestream, &uL) != UNZ_OK) + err = UNZ_ERRNO; + us.size_central_dir = uL; + /* offset of start of central directory with respect to the starting disk number */ + if (unz64local_getLong(&us.z_filefunc, us.filestream, &uL) != UNZ_OK) + err = UNZ_ERRNO; + us.offset_central_dir = uL; + /* zipfile comment length */ + if (unz64local_getShort(&us.z_filefunc, us.filestream, &us.gi.size_comment) != UNZ_OK) + err = UNZ_ERRNO; + + if ((err == UNZ_OK) && + ((us.gi.number_entry == 0xffff) || (us.size_central_dir == 0xffff) || (us.offset_central_dir == 0xffffffff))) { + /* Format should be Zip64, as the central directory or file size is too large */ + central_pos = unz64local_SearchCentralDir64(&us.z_filefunc, us.filestream, central_pos); + if (central_pos) { + ZPOS64_T uL64; + + us.isZip64 = 1; + + if (ZSEEK64(us.z_filefunc, us.filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0) + err = UNZ_ERRNO; + + /* the signature, already checked */ + if (unz64local_getLong(&us.z_filefunc, us.filestream, &uL) != UNZ_OK) + err = UNZ_ERRNO; + /* size of zip64 end of central directory record */ + if (unz64local_getLong64(&us.z_filefunc, us.filestream, &uL64) != UNZ_OK) + err = UNZ_ERRNO; + /* version made by */ + if (unz64local_getShort(&us.z_filefunc, us.filestream, &uL) != UNZ_OK) + err = UNZ_ERRNO; + /* version needed to extract */ + if (unz64local_getShort(&us.z_filefunc, us.filestream, &uL) != UNZ_OK) + err = UNZ_ERRNO; + /* number of this disk */ + if (unz64local_getLong(&us.z_filefunc, us.filestream, &us.number_disk) != UNZ_OK) + err = UNZ_ERRNO; + /* number of the disk with the start of the central directory */ + if (unz64local_getLong(&us.z_filefunc, us.filestream, &us.gi.number_disk_with_CD) != UNZ_OK) + err = UNZ_ERRNO; + /* total number of entries in the central directory on this disk */ + if (unz64local_getLong64(&us.z_filefunc, us.filestream, &us.gi.number_entry) != UNZ_OK) + err = UNZ_ERRNO; + /* total number of entries in the central directory */ + if (unz64local_getLong64(&us.z_filefunc, us.filestream, &number_entry_CD) != UNZ_OK) + err = UNZ_ERRNO; + if (number_entry_CD != us.gi.number_entry) + err = UNZ_BADZIPFILE; + /* size of the central directory */ + if (unz64local_getLong64(&us.z_filefunc, us.filestream, &us.size_central_dir) != UNZ_OK) + err = UNZ_ERRNO; + /* offset of start of central directory with respect to the starting disk number */ + if (unz64local_getLong64(&us.z_filefunc, us.filestream, &us.offset_central_dir) != UNZ_OK) + err = UNZ_ERRNO; + } else + err = UNZ_BADZIPFILE; + } + } else + err = UNZ_ERRNO; + + if ((err == UNZ_OK) && (central_pos < us.offset_central_dir + us.size_central_dir)) + err = UNZ_BADZIPFILE; + + if (err != UNZ_OK) { + ZCLOSE64(us.z_filefunc, us.filestream); + return NULL; + } + + if (us.gi.number_disk_with_CD == 0) { + /* If there is only one disk open another stream so we don't have to seek between the CD + and the file headers constantly */ + filestream = ZOPEN64(us.z_filefunc, path, ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_EXISTING); + if (filestream != NULL) + us.filestream = filestream; + } + + /* Hack for zip files that have no respect for zip64 + if ((central_pos > 0xffffffff) && (us.offset_central_dir < 0xffffffff)) + us.offset_central_dir = central_pos - us.size_central_dir;*/ + + us.byte_before_the_zipfile = central_pos - (us.offset_central_dir + us.size_central_dir); + us.central_pos = central_pos; + us.pfile_in_zip_read = NULL; + + s = (unz64_s *)ALLOC(sizeof(unz64_s)); + if (s != NULL) { + *s = us; + unzGoToFirstFile((unzFile)s); + } + return (unzFile)s; +} + +extern unzFile ZEXPORT unzOpen2(const char *path, zlib_filefunc_def *pzlib_filefunc32_def) +{ + if (pzlib_filefunc32_def != NULL) { + zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; + fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill, pzlib_filefunc32_def); + return unzOpenInternal(path, &zlib_filefunc64_32_def_fill); + } + return unzOpenInternal(path, NULL); +} + +extern unzFile ZEXPORT unzOpen2_64(const void *path, zlib_filefunc64_def *pzlib_filefunc_def) +{ + if (pzlib_filefunc_def != NULL) { + zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; + zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def; + zlib_filefunc64_32_def_fill.ztell32_file = NULL; + zlib_filefunc64_32_def_fill.zseek32_file = NULL; + return unzOpenInternal(path, &zlib_filefunc64_32_def_fill); + } + return unzOpenInternal(path, NULL); +} + +extern unzFile ZEXPORT unzOpen(const char *path) +{ + return unzOpenInternal(path, NULL); +} + +extern unzFile ZEXPORT unzOpen64(const void *path) +{ + return unzOpenInternal(path, NULL); +} + +extern int ZEXPORT unzClose(unzFile file) +{ + unz64_s *s; + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_s *)file; + + if (s->pfile_in_zip_read != NULL) + unzCloseCurrentFile(file); + + if ((s->filestream != NULL) && (s->filestream != s->filestream_with_CD)) + ZCLOSE64(s->z_filefunc, s->filestream); + if (s->filestream_with_CD != NULL) + ZCLOSE64(s->z_filefunc, s->filestream_with_CD); + + s->filestream = NULL; + s->filestream_with_CD = NULL; + TRYFREE(s); + return UNZ_OK; +} + +/* Goto to the next available disk for spanned archives */ +local int unzGoToNextDisk OF((unzFile file)); +local int unzGoToNextDisk(unzFile file) +{ + unz64_s *s; + file_in_zip64_read_info_s *pfile_in_zip_read_info; + uLong number_disk_next = 0; + + s = (unz64_s *)file; + if (s == NULL) + return UNZ_PARAMERROR; + pfile_in_zip_read_info = s->pfile_in_zip_read; + number_disk_next = s->number_disk; + + if ((pfile_in_zip_read_info != NULL) && (pfile_in_zip_read_info->rest_read_uncompressed > 0)) + /* We are currently reading a file and we need the next sequential disk */ + number_disk_next += 1; + else + /* Goto the disk for the current file */ + number_disk_next = s->cur_file_info.disk_num_start; + + if (number_disk_next != s->number_disk) { + /* Switch disks */ + if ((s->filestream != NULL) && (s->filestream != s->filestream_with_CD)) + ZCLOSE64(s->z_filefunc, s->filestream); + + if (number_disk_next == s->gi.number_disk_with_CD) { + s->filestream = s->filestream_with_CD; + } else { + s->filestream = ZOPENDISK64(s->z_filefunc, s->filestream_with_CD, (unsigned int)number_disk_next, + ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_EXISTING); + } + + if (s->filestream == NULL) + return UNZ_ERRNO; + + s->number_disk = number_disk_next; + } + + return UNZ_OK; +} + +extern int ZEXPORT unzGetGlobalInfo(unzFile file, unz_global_info *pglobal_info32) +{ + unz64_s *s; + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_s *)file; + /* to do : check if number_entry is not truncated */ + pglobal_info32->number_entry = (uLong)s->gi.number_entry; + pglobal_info32->size_comment = s->gi.size_comment; + pglobal_info32->number_disk_with_CD = s->gi.number_disk_with_CD; + return UNZ_OK; +} + +extern int ZEXPORT unzGetGlobalInfo64(unzFile file, unz_global_info64 *pglobal_info) +{ + unz64_s *s; + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_s *)file; + *pglobal_info = s->gi; + return UNZ_OK; +} + +extern int ZEXPORT unzGetGlobalComment(unzFile file, char *comment, uLong comment_size) +{ + unz64_s *s; + uLong bytes_to_read = comment_size; + if (file == NULL) + return (int)UNZ_PARAMERROR; + s = (unz64_s *)file; + + if (bytes_to_read > s->gi.size_comment) + bytes_to_read = s->gi.size_comment; + + if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, s->central_pos + 22, ZLIB_FILEFUNC_SEEK_SET) != 0) + return UNZ_ERRNO; + + if (bytes_to_read > 0) { + *comment = 0; + if (ZREAD64(s->z_filefunc, s->filestream_with_CD, comment, bytes_to_read) != bytes_to_read) + return UNZ_ERRNO; + } + + if ((comment != NULL) && (comment_size > s->gi.size_comment)) + *(comment + s->gi.size_comment) = 0; + return (int)bytes_to_read; +} + +/* Get Info about the current file in the zipfile, with internal only info */ +local int unz64local_GetCurrentFileInfoInternal(unzFile file, unz_file_info64 *pfile_info, + unz_file_info64_internal *pfile_info_internal, char *filename, uLong filename_size, void *extrafield, + uLong extrafield_size, char *comment, uLong comment_size) +{ + unz64_s *s; + unz_file_info64 file_info; + unz_file_info64_internal file_info_internal; + ZPOS64_T bytes_to_read; + int err = UNZ_OK; + uLong uMagic; + long lSeek = 0; + ZPOS64_T current_pos = 0; + uLong acc = 0; + uLong uL; + ZPOS64_T uL64; + + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_s *)file; + + if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, + s->pos_in_central_dir + s->byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0) + err = UNZ_ERRNO; + + /* Check the magic */ + if (err == UNZ_OK) { + if (unz64local_getLong(&s->z_filefunc, s->filestream_with_CD, &uMagic) != UNZ_OK) + err = UNZ_ERRNO; + else if (uMagic != CENTRALHEADERMAGIC) + err = UNZ_BADZIPFILE; + } + + /* Read central directory header */ + if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &file_info.version) != UNZ_OK) + err = UNZ_ERRNO; + if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &file_info.version_needed) != UNZ_OK) + err = UNZ_ERRNO; + if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &file_info.flag) != UNZ_OK) + err = UNZ_ERRNO; + if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &file_info.compression_method) != UNZ_OK) + err = UNZ_ERRNO; + if (unz64local_getLong(&s->z_filefunc, s->filestream_with_CD, &file_info.dosDate) != UNZ_OK) + err = UNZ_ERRNO; + unz64local_DosDateToTmuDate(file_info.dosDate, &file_info.tmu_date); + if (unz64local_getLong(&s->z_filefunc, s->filestream_with_CD, &file_info.crc) != UNZ_OK) + err = UNZ_ERRNO; + if (unz64local_getLong(&s->z_filefunc, s->filestream_with_CD, &uL) != UNZ_OK) + err = UNZ_ERRNO; + file_info.compressed_size = uL; + if (unz64local_getLong(&s->z_filefunc, s->filestream_with_CD, &uL) != UNZ_OK) + err = UNZ_ERRNO; + file_info.uncompressed_size = uL; + if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &file_info.size_filename) != UNZ_OK) + err = UNZ_ERRNO; + if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &file_info.size_file_extra) != UNZ_OK) + err = UNZ_ERRNO; + if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &file_info.size_file_comment) != UNZ_OK) + err = UNZ_ERRNO; + if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &file_info.disk_num_start) != UNZ_OK) + err = UNZ_ERRNO; + if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &file_info.internal_fa) != UNZ_OK) + err = UNZ_ERRNO; + if (unz64local_getLong(&s->z_filefunc, s->filestream_with_CD, &file_info.external_fa) != UNZ_OK) + err = UNZ_ERRNO; + /* Relative offset of local header */ + if (unz64local_getLong(&s->z_filefunc, s->filestream_with_CD, &uL) != UNZ_OK) + err = UNZ_ERRNO; + + file_info.size_file_extra_internal = 0; + file_info.disk_offset = uL; + file_info_internal.offset_curfile = uL; +#ifdef HAVE_AES + file_info_internal.aes_compression_method = 0; + file_info_internal.aes_encryption_mode = 0; + file_info_internal.aes_version = 0; +#endif + + lSeek += file_info.size_filename; + + if ((err == UNZ_OK) && (filename != NULL)) { + if (file_info.size_filename < filename_size) { + *(filename + file_info.size_filename) = 0; + bytes_to_read = file_info.size_filename; + } else + bytes_to_read = filename_size; + + if ((file_info.size_filename > 0) && (filename_size > 0)) + if (ZREAD64(s->z_filefunc, s->filestream_with_CD, filename, (uLong)bytes_to_read) != bytes_to_read) + err = UNZ_ERRNO; + lSeek -= (uLong)bytes_to_read; + } + + /* Read extrafield */ + if ((err == UNZ_OK) && (extrafield != NULL)) { + if (file_info.size_file_extra < extrafield_size) + bytes_to_read = file_info.size_file_extra; + else + bytes_to_read = extrafield_size; + + if (lSeek != 0) { + if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, lSeek, ZLIB_FILEFUNC_SEEK_CUR) == 0) + lSeek = 0; + else + err = UNZ_ERRNO; + } + + if ((file_info.size_file_extra > 0) && (extrafield_size > 0)) + if (ZREAD64(s->z_filefunc, s->filestream_with_CD, extrafield, (uLong)bytes_to_read) != bytes_to_read) + err = UNZ_ERRNO; + lSeek += file_info.size_file_extra - (uLong)bytes_to_read; + } else + lSeek += file_info.size_file_extra; + + if ((err == UNZ_OK) && (file_info.size_file_extra != 0)) { + if (lSeek != 0) { + if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, lSeek, ZLIB_FILEFUNC_SEEK_CUR) == 0) + lSeek = 0; + else + err = UNZ_ERRNO; + } + + /* We are going to parse the extra field so we need to move back */ + current_pos = ZTELL64(s->z_filefunc, s->filestream_with_CD); + if (current_pos < file_info.size_file_extra) + err = UNZ_ERRNO; + current_pos -= file_info.size_file_extra; + if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, current_pos, ZLIB_FILEFUNC_SEEK_SET) != 0) + err = UNZ_ERRNO; + + while ((err != UNZ_ERRNO) && (acc < file_info.size_file_extra)) { + uLong headerid; + uLong datasize; + + if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &headerid) != UNZ_OK) + err = UNZ_ERRNO; + if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &datasize) != UNZ_OK) + err = UNZ_ERRNO; + + /* ZIP64 extra fields */ + if (headerid == 0x0001) { + /* Subtract size of ZIP64 field, since ZIP64 is handled internally */ + file_info.size_file_extra_internal += 2 + 2 + datasize; + + if (file_info.uncompressed_size == 0xffffffff) { + if (unz64local_getLong64(&s->z_filefunc, s->filestream_with_CD, &file_info.uncompressed_size) != UNZ_OK) + err = UNZ_ERRNO; + } + if (file_info.compressed_size == 0xffffffff) { + if (unz64local_getLong64(&s->z_filefunc, s->filestream_with_CD, &file_info.compressed_size) != UNZ_OK) + err = UNZ_ERRNO; + } + if (file_info_internal.offset_curfile == 0xffffffff) { + /* Relative Header offset */ + if (unz64local_getLong64(&s->z_filefunc, s->filestream_with_CD, &uL64) != UNZ_OK) + err = UNZ_ERRNO; + file_info_internal.offset_curfile = uL64; + file_info.disk_offset = uL64; + } + if (file_info.disk_num_start == 0xffffffff) { + /* Disk Start Number */ + if (unz64local_getLong(&s->z_filefunc, s->filestream_with_CD, &file_info.disk_num_start) != UNZ_OK) + err = UNZ_ERRNO; + } + } +#ifdef HAVE_AES + /* AES header */ + else if (headerid == 0x9901) { + /* Subtract size of AES field, since AES is handled internally */ + file_info.size_file_extra_internal += 2 + 2 + datasize; + + /* Verify version info */ + if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &uL) != UNZ_OK) + err = UNZ_ERRNO; + /* Support AE-1 and AE-2 */ + if (uL != 1 && uL != 2) + err = UNZ_ERRNO; + file_info_internal.aes_version = uL; + if (unz64local_getByte(&s->z_filefunc, s->filestream_with_CD, (int *)&uL) != UNZ_OK) + err = UNZ_ERRNO; + if ((char)uL != 'A') + err = UNZ_ERRNO; + if (unz64local_getByte(&s->z_filefunc, s->filestream_with_CD, (int *)&uL) != UNZ_OK) + err = UNZ_ERRNO; + if ((char)uL != 'E') + err = UNZ_ERRNO; + /* Get AES encryption strength and actual compression method */ + if (unz64local_getByte(&s->z_filefunc, s->filestream_with_CD, (int *)&uL) != UNZ_OK) + err = UNZ_ERRNO; + file_info_internal.aes_encryption_mode = uL; + if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &uL) != UNZ_OK) + err = UNZ_ERRNO; + file_info_internal.aes_compression_method = uL; + } +#endif + else { + if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, datasize, ZLIB_FILEFUNC_SEEK_CUR) != 0) + err = UNZ_ERRNO; + } + + acc += 2 + 2 + datasize; + } + } + + if (file_info.disk_num_start == s->gi.number_disk_with_CD) + file_info_internal.byte_before_the_zipfile = s->byte_before_the_zipfile; + else + file_info_internal.byte_before_the_zipfile = 0; + + if ((err == UNZ_OK) && (comment != NULL)) { + if (file_info.size_file_comment < comment_size) { + *(comment + file_info.size_file_comment) = 0; + bytes_to_read = file_info.size_file_comment; + } else + bytes_to_read = comment_size; + + if (lSeek != 0) { + if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, lSeek, ZLIB_FILEFUNC_SEEK_CUR) != 0) + err = UNZ_ERRNO; + } + + if ((file_info.size_file_comment > 0) && (comment_size > 0)) + if (ZREAD64(s->z_filefunc, s->filestream_with_CD, comment, (uLong)bytes_to_read) != bytes_to_read) + err = UNZ_ERRNO; + lSeek += file_info.size_file_comment - (uLong)bytes_to_read; + } else + lSeek += file_info.size_file_comment; + + if ((err == UNZ_OK) && (pfile_info != NULL)) + *pfile_info = file_info; + + if ((err == UNZ_OK) && (pfile_info_internal != NULL)) + *pfile_info_internal = file_info_internal; + + return err; +} + +extern int ZEXPORT unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filename, + uLong filename_size, void *extrafield, uLong extrafield_size, char *comment, uLong comment_size) +{ + unz_file_info64 file_info64; + int err; + + err = unz64local_GetCurrentFileInfoInternal(file, &file_info64, NULL, filename, filename_size, + extrafield, extrafield_size, comment, comment_size); + + if ((err == UNZ_OK) && (pfile_info != NULL)) { + pfile_info->version = file_info64.version; + pfile_info->version_needed = file_info64.version_needed; + pfile_info->flag = file_info64.flag; + pfile_info->compression_method = file_info64.compression_method; + pfile_info->dosDate = file_info64.dosDate; + pfile_info->crc = file_info64.crc; + + pfile_info->size_filename = file_info64.size_filename; + pfile_info->size_file_extra = file_info64.size_file_extra - file_info64.size_file_extra_internal; + pfile_info->size_file_comment = file_info64.size_file_comment; + + pfile_info->disk_num_start = file_info64.disk_num_start; + pfile_info->internal_fa = file_info64.internal_fa; + pfile_info->external_fa = file_info64.external_fa; + + pfile_info->tmu_date = file_info64.tmu_date, + + pfile_info->compressed_size = (uLong)file_info64.compressed_size; + pfile_info->uncompressed_size = (uLong)file_info64.uncompressed_size; + + } + return err; +} + +extern int ZEXPORT unzGetCurrentFileInfo64(unzFile file, unz_file_info64 *pfile_info, char *filename, + uLong filename_size, void *extrafield, uLong extrafield_size, char *comment, uLong comment_size) +{ + return unz64local_GetCurrentFileInfoInternal(file, pfile_info, NULL, filename, filename_size, + extrafield, extrafield_size, comment, comment_size); +} + +/* Read the local header of the current zipfile. Check the coherency of the local header and info in the + end of central directory about this file store in *piSizeVar the size of extra info in local header + (filename and size of extra field data) */ +local int unz64local_CheckCurrentFileCoherencyHeader(unz64_s *s, uInt *piSizeVar, ZPOS64_T *poffset_local_extrafield, + uInt *psize_local_extrafield) +{ + uLong uMagic, uL, uFlags; + uLong size_filename; + uLong size_extra_field; + int err = UNZ_OK; + int compression_method = 0; + + *piSizeVar = 0; + *poffset_local_extrafield = 0; + *psize_local_extrafield = 0; + + err = unzGoToNextDisk((unzFile)s); + if (err != UNZ_OK) + return err; + + if (ZSEEK64(s->z_filefunc, s->filestream, s->cur_file_info_internal.offset_curfile + + s->cur_file_info_internal.byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0) + return UNZ_ERRNO; + + if (err == UNZ_OK) { + if (unz64local_getLong(&s->z_filefunc, s->filestream, &uMagic) != UNZ_OK) + err = UNZ_ERRNO; + else if (uMagic != LOCALHEADERMAGIC) + err = UNZ_BADZIPFILE; + } + + if (unz64local_getShort(&s->z_filefunc, s->filestream, &uL) != UNZ_OK) + err = UNZ_ERRNO; + if (unz64local_getShort(&s->z_filefunc, s->filestream, &uFlags) != UNZ_OK) + err = UNZ_ERRNO; + if (unz64local_getShort(&s->z_filefunc, s->filestream, &uL) != UNZ_OK) + err = UNZ_ERRNO; + else if ((err == UNZ_OK) && (uL != s->cur_file_info.compression_method)) + err = UNZ_BADZIPFILE; + + compression_method = (int)s->cur_file_info.compression_method; +#ifdef HAVE_AES + if (compression_method == AES_METHOD) + compression_method = (int)s->cur_file_info_internal.aes_compression_method; +#endif + + if ((err == UNZ_OK) && (compression_method != 0) && +#ifdef HAVE_BZIP2 + (compression_method != Z_BZIP2ED) && +#endif + (compression_method != Z_DEFLATED)) + err = UNZ_BADZIPFILE; + + if (unz64local_getLong(&s->z_filefunc, s->filestream, &uL) != UNZ_OK) /* date/time */ + err = UNZ_ERRNO; + if (unz64local_getLong(&s->z_filefunc, s->filestream, &uL) != UNZ_OK) /* crc */ + err = UNZ_ERRNO; + else if ((err == UNZ_OK) && (uL != s->cur_file_info.crc) && ((uFlags & 8) == 0)) + err = UNZ_BADZIPFILE; + if (unz64local_getLong(&s->z_filefunc, s->filestream, &uL) != UNZ_OK) /* size compr */ + err = UNZ_ERRNO; + else if ((uL != 0xffffffff) && (err == UNZ_OK) && (uL != s->cur_file_info.compressed_size) && ((uFlags & 8) == 0)) + err = UNZ_BADZIPFILE; + if (unz64local_getLong(&s->z_filefunc, s->filestream, &uL) != UNZ_OK) /* size uncompr */ + err = UNZ_ERRNO; + else if ((uL != 0xffffffff) && (err == UNZ_OK) && (uL != s->cur_file_info.uncompressed_size) && ((uFlags & 8) == 0)) + err = UNZ_BADZIPFILE; + if (unz64local_getShort(&s->z_filefunc, s->filestream, &size_filename) != UNZ_OK) + err = UNZ_ERRNO; + else if ((err == UNZ_OK) && (size_filename != s->cur_file_info.size_filename)) + err = UNZ_BADZIPFILE; + + *piSizeVar += (uInt)size_filename; + + if (unz64local_getShort(&s->z_filefunc, s->filestream, &size_extra_field) != UNZ_OK) + err = UNZ_ERRNO; + *poffset_local_extrafield = s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + size_filename; + *psize_local_extrafield = (uInt)size_extra_field; + + *piSizeVar += (uInt)size_extra_field; + + return err; +} + +/* + Open for reading data the current file in the zipfile. + If there is no error and the file is opened, the return value is UNZ_OK. + */ +extern int ZEXPORT unzOpenCurrentFile3(unzFile file, int *method, int *level, int raw, const char *password) +{ + int err = UNZ_OK; + int compression_method; + uInt iSizeVar; + unz64_s *s; + file_in_zip64_read_info_s *pfile_in_zip_read_info; + ZPOS64_T offset_local_extrafield; + uInt size_local_extrafield; +#ifndef NOUNCRYPT + char source[12]; +#else + if (password != NULL) + return UNZ_PARAMERROR; +#endif + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_s *)file; + if (!s->current_file_ok) + return UNZ_PARAMERROR; + + if (s->pfile_in_zip_read != NULL) + unzCloseCurrentFile(file); + + if (unz64local_CheckCurrentFileCoherencyHeader(s, &iSizeVar, &offset_local_extrafield, &size_local_extrafield) != UNZ_OK) + return UNZ_BADZIPFILE; + + pfile_in_zip_read_info = (file_in_zip64_read_info_s *)ALLOC(sizeof(file_in_zip64_read_info_s)); + if (pfile_in_zip_read_info == NULL) + return UNZ_INTERNALERROR; + + pfile_in_zip_read_info->read_buffer = (Bytef *)ALLOC(UNZ_BUFSIZE); + pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield; + pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield; + pfile_in_zip_read_info->pos_local_extrafield = 0; + pfile_in_zip_read_info->raw = raw; + + if (pfile_in_zip_read_info->read_buffer == NULL) { + TRYFREE(pfile_in_zip_read_info); + return UNZ_INTERNALERROR; + } + + pfile_in_zip_read_info->stream_initialised = 0; + + compression_method = (int)s->cur_file_info.compression_method; +#ifdef HAVE_AES + if (compression_method == AES_METHOD) + compression_method = (int)s->cur_file_info_internal.aes_compression_method; +#endif + + if (method != NULL) + *method = compression_method; + + if (level != NULL) { + *level = 6; + switch (s->cur_file_info.flag & 0x06) { + case 6: *level = 1; break; + case 4: *level = 2; break; + case 2: *level = 9; break; + } + } + + if ((compression_method != 0) && +#ifdef HAVE_BZIP2 + (compression_method != Z_BZIP2ED) && +#endif + (compression_method != Z_DEFLATED)) + err = UNZ_BADZIPFILE; + + pfile_in_zip_read_info->crc32_wait = s->cur_file_info.crc; + pfile_in_zip_read_info->crc32 = 0; + pfile_in_zip_read_info->total_out_64 = 0; + pfile_in_zip_read_info->compression_method = compression_method; + pfile_in_zip_read_info->filestream = s->filestream; + pfile_in_zip_read_info->z_filefunc = s->z_filefunc; + if (s->number_disk == s->gi.number_disk_with_CD) + pfile_in_zip_read_info->byte_before_the_zipfile = s->byte_before_the_zipfile; + else + pfile_in_zip_read_info->byte_before_the_zipfile = 0; + pfile_in_zip_read_info->stream.total_out = 0; + pfile_in_zip_read_info->stream.total_in = 0; + pfile_in_zip_read_info->stream.next_in = NULL; + + if (!raw) { + if (compression_method == Z_BZIP2ED) { +#ifdef HAVE_BZIP2 + pfile_in_zip_read_info->bstream.bzalloc = (void *(*)(void *, int, int)) 0; + pfile_in_zip_read_info->bstream.bzfree = (free_func)0; + pfile_in_zip_read_info->bstream.opaque = (voidpf)0; + pfile_in_zip_read_info->bstream.state = (voidpf)0; + + pfile_in_zip_read_info->stream.zalloc = (alloc_func)0; + pfile_in_zip_read_info->stream.zfree = (free_func)0; + pfile_in_zip_read_info->stream.opaque = (voidpf)0; + pfile_in_zip_read_info->stream.next_in = (voidpf)0; + pfile_in_zip_read_info->stream.avail_in = 0; + + err = BZ2_bzDecompressInit(&pfile_in_zip_read_info->bstream, 0, 0); + if (err == Z_OK) + pfile_in_zip_read_info->stream_initialised = Z_BZIP2ED; + else { + TRYFREE(pfile_in_zip_read_info); + return err; + } +#else + pfile_in_zip_read_info->raw = 1; +#endif + } else if (compression_method == Z_DEFLATED) { + pfile_in_zip_read_info->stream.zalloc = (alloc_func)0; + pfile_in_zip_read_info->stream.zfree = (free_func)0; + pfile_in_zip_read_info->stream.opaque = (voidpf)s; + pfile_in_zip_read_info->stream.next_in = 0; + pfile_in_zip_read_info->stream.avail_in = 0; + + err = inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS); + if (err == Z_OK) + pfile_in_zip_read_info->stream_initialised = Z_DEFLATED; + else { + TRYFREE(pfile_in_zip_read_info); + return err; + } + /* windowBits is passed < 0 to tell that there is no zlib header. + * Note that in this case inflate *requires* an extra "dummy" byte + * after the compressed stream in order to complete decompression and + * return Z_STREAM_END. + * In unzip, i don't wait absolutely Z_STREAM_END because I known the + * size of both compressed and uncompressed data + */ + } + } + + pfile_in_zip_read_info->rest_read_compressed = s->cur_file_info.compressed_size; + pfile_in_zip_read_info->rest_read_uncompressed = s->cur_file_info.uncompressed_size; + pfile_in_zip_read_info->pos_in_zipfile = s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + iSizeVar; + pfile_in_zip_read_info->stream.avail_in = (uInt)0; + + s->pfile_in_zip_read = pfile_in_zip_read_info; + +#ifndef NOUNCRYPT + if ((password != NULL) && ((s->cur_file_info.flag & 1) != 0)) { + if (ZSEEK64(s->z_filefunc, s->filestream, + s->pfile_in_zip_read->pos_in_zipfile + s->pfile_in_zip_read->byte_before_the_zipfile, + ZLIB_FILEFUNC_SEEK_SET) != 0) + return UNZ_INTERNALERROR; +#ifdef HAVE_AES + if (s->cur_file_info.compression_method == AES_METHOD) { + unsigned char passverify[AES_PWVERIFYSIZE]; + unsigned char saltvalue[AES_MAXSALTLENGTH]; + uInt saltlength; + + if ((s->cur_file_info_internal.aes_encryption_mode < 1) || + (s->cur_file_info_internal.aes_encryption_mode > 3)) + return UNZ_INTERNALERROR; + + saltlength = SALT_LENGTH(s->cur_file_info_internal.aes_encryption_mode); + + if (ZREAD64(s->z_filefunc, s->filestream, saltvalue, saltlength) != saltlength) + return UNZ_INTERNALERROR; + if (ZREAD64(s->z_filefunc, s->filestream, passverify, AES_PWVERIFYSIZE) != AES_PWVERIFYSIZE) + return UNZ_INTERNALERROR; + + fcrypt_init((int)s->cur_file_info_internal.aes_encryption_mode, (unsigned char *)password, (unsigned int)strlen(password), saltvalue, + passverify, &s->pfile_in_zip_read->aes_ctx); + + pfile_in_zip_read_info->rest_read_compressed -= saltlength + AES_PWVERIFYSIZE; + pfile_in_zip_read_info->rest_read_compressed -= AES_AUTHCODESIZE; + + s->pfile_in_zip_read->pos_in_zipfile += saltlength + AES_PWVERIFYSIZE; + } else +#endif + { + int i; + s->pcrc_32_tab = (const unsigned long *)get_crc_table(); + init_keys(password, s->keys, s->pcrc_32_tab); + + if (ZREAD64(s->z_filefunc, s->filestream, source, 12) < 12) + return UNZ_INTERNALERROR; + + for (i = 0; i < 12; i++) + zdecode(s->keys, s->pcrc_32_tab, source[i]); + + pfile_in_zip_read_info->rest_read_compressed -= 12; + + s->pfile_in_zip_read->pos_in_zipfile += 12; + } + } +#endif + + return UNZ_OK; +} + +extern int ZEXPORT unzOpenCurrentFile(unzFile file) +{ + return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL); +} + +extern int ZEXPORT unzOpenCurrentFilePassword(unzFile file, const char *password) +{ + return unzOpenCurrentFile3(file, NULL, NULL, 0, password); +} + +extern int ZEXPORT unzOpenCurrentFile2(unzFile file, int *method, int *level, int raw) +{ + return unzOpenCurrentFile3(file, method, level, raw, NULL); +} + +/* Read bytes from the current file. + buf contain buffer where data must be copied + len the size of buf. + + return the number of byte copied if some bytes are copied + return 0 if the end of file was reached + return <0 with error code if there is an error (UNZ_ERRNO for IO error, or zLib error for uncompress error) */ +extern int ZEXPORT unzReadCurrentFile(unzFile file, voidp buf, unsigned len) +{ + int err = UNZ_OK; + uInt read = 0; + unz64_s *s; + file_in_zip64_read_info_s *pfile_in_zip_read_info; + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_s *)file; + pfile_in_zip_read_info = s->pfile_in_zip_read; + + if (pfile_in_zip_read_info == NULL) + return UNZ_PARAMERROR; + if (pfile_in_zip_read_info->read_buffer == NULL) + return UNZ_END_OF_LIST_OF_FILE; + if (len == 0) + return 0; + + pfile_in_zip_read_info->stream.next_out = (Bytef *)buf; + pfile_in_zip_read_info->stream.avail_out = (uInt)len; + + if (pfile_in_zip_read_info->raw) { + if (len > pfile_in_zip_read_info->rest_read_compressed + pfile_in_zip_read_info->stream.avail_in) + pfile_in_zip_read_info->stream.avail_out = (uInt)pfile_in_zip_read_info->rest_read_compressed + + pfile_in_zip_read_info->stream.avail_in; + } else { + + // NOTE: + // This bit of code seems to try to set the amount of space in the output buffer based on the + // value stored in the headers stored in the .zip file. However, if those values are incorrect + // it may result in a loss of data when uncompresssing that file. The compressed data is still + // legit and will deflate without knowing the uncompressed code so this tidbit is unnecessary and + // may cause issues for some .zip files. + // + // It's removed in here to fix those issues. + // + // See: https://github.com/ZipArchive/ziparchive/issues/16 + // + + /* + + + FIXME: Upgrading to minizip 1.1 caused issues here, Uncommented the code that was commented before. 11/24/2015 + */ + + if (len > pfile_in_zip_read_info->rest_read_uncompressed) + pfile_in_zip_read_info->stream.avail_out = (uInt)pfile_in_zip_read_info->rest_read_uncompressed; + + + + } + + while (pfile_in_zip_read_info->stream.avail_out > 0) { + if (pfile_in_zip_read_info->stream.avail_in == 0) { + uInt bytes_to_read = UNZ_BUFSIZE; + uInt bytes_not_read = 0; + uInt bytes_read = 0; + uInt total_bytes_read = 0; + + if (pfile_in_zip_read_info->stream.next_in != NULL) + bytes_not_read = (uInt)(pfile_in_zip_read_info->read_buffer + UNZ_BUFSIZE - + pfile_in_zip_read_info->stream.next_in); + bytes_to_read -= bytes_not_read; + if (bytes_not_read > 0) + memcpy(pfile_in_zip_read_info->read_buffer, pfile_in_zip_read_info->stream.next_in, bytes_not_read); + if (pfile_in_zip_read_info->rest_read_compressed < bytes_to_read) + bytes_to_read = (uInt)pfile_in_zip_read_info->rest_read_compressed; + + while (total_bytes_read != bytes_to_read) { + if (ZSEEK64(pfile_in_zip_read_info->z_filefunc, pfile_in_zip_read_info->filestream, + pfile_in_zip_read_info->pos_in_zipfile + pfile_in_zip_read_info->byte_before_the_zipfile, + ZLIB_FILEFUNC_SEEK_SET) != 0) + return UNZ_ERRNO; + + bytes_read = (int)ZREAD64(pfile_in_zip_read_info->z_filefunc, pfile_in_zip_read_info->filestream, + pfile_in_zip_read_info->read_buffer + bytes_not_read + total_bytes_read, + bytes_to_read - total_bytes_read); + + total_bytes_read += bytes_read; + pfile_in_zip_read_info->pos_in_zipfile += bytes_read; + + if (bytes_read == 0) { + if (ZERROR64(pfile_in_zip_read_info->z_filefunc, pfile_in_zip_read_info->filestream)) + return UNZ_ERRNO; + + err = unzGoToNextDisk(file); + if (err != UNZ_OK) + return err; + + pfile_in_zip_read_info->pos_in_zipfile = 0; + pfile_in_zip_read_info->filestream = s->filestream; + } + } + +#ifndef NOUNCRYPT + if ((s->cur_file_info.flag & 1) != 0) { +#ifdef HAVE_AES + if (s->cur_file_info.compression_method == AES_METHOD) { + fcrypt_decrypt(pfile_in_zip_read_info->read_buffer, bytes_to_read, &s->pfile_in_zip_read->aes_ctx); + } else +#endif + { + uInt i; + for (i = 0; i < total_bytes_read; i++) + pfile_in_zip_read_info->read_buffer[i] = + zdecode(s->keys, s->pcrc_32_tab, pfile_in_zip_read_info->read_buffer[i]); + } + } +#endif + + pfile_in_zip_read_info->rest_read_compressed -= total_bytes_read; + pfile_in_zip_read_info->stream.next_in = (Bytef *)pfile_in_zip_read_info->read_buffer; + pfile_in_zip_read_info->stream.avail_in = (uInt)bytes_not_read + total_bytes_read; + } + + if ((pfile_in_zip_read_info->compression_method == 0) || (pfile_in_zip_read_info->raw)) { + uInt copy, i; + + if ((pfile_in_zip_read_info->stream.avail_in == 0) && + (pfile_in_zip_read_info->rest_read_compressed == 0)) + return (read == 0) ? UNZ_EOF : read; + + if (pfile_in_zip_read_info->stream.avail_out < pfile_in_zip_read_info->stream.avail_in) + copy = pfile_in_zip_read_info->stream.avail_out; + else + copy = pfile_in_zip_read_info->stream.avail_in; + + for (i = 0; i < copy; i++) + *(pfile_in_zip_read_info->stream.next_out + i) = + *(pfile_in_zip_read_info->stream.next_in + i); + + pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + copy; + pfile_in_zip_read_info->rest_read_uncompressed -= copy; + pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32, + pfile_in_zip_read_info->stream.next_out, copy); + + pfile_in_zip_read_info->stream.avail_in -= copy; + pfile_in_zip_read_info->stream.avail_out -= copy; + pfile_in_zip_read_info->stream.next_out += copy; + pfile_in_zip_read_info->stream.next_in += copy; + pfile_in_zip_read_info->stream.total_out += copy; + read += copy; + } else if (pfile_in_zip_read_info->compression_method == Z_BZIP2ED) { +#ifdef HAVE_BZIP2 + uLong total_out_before, total_out_after; + const Bytef *buf_before; + uLong out_bytes; + + pfile_in_zip_read_info->bstream.next_in = (char *)pfile_in_zip_read_info->stream.next_in; + pfile_in_zip_read_info->bstream.avail_in = pfile_in_zip_read_info->stream.avail_in; + pfile_in_zip_read_info->bstream.total_in_lo32 = pfile_in_zip_read_info->stream.total_in; + pfile_in_zip_read_info->bstream.total_in_hi32 = 0; + pfile_in_zip_read_info->bstream.next_out = (char *)pfile_in_zip_read_info->stream.next_out; + pfile_in_zip_read_info->bstream.avail_out = pfile_in_zip_read_info->stream.avail_out; + pfile_in_zip_read_info->bstream.total_out_lo32 = pfile_in_zip_read_info->stream.total_out; + pfile_in_zip_read_info->bstream.total_out_hi32 = 0; + + total_out_before = pfile_in_zip_read_info->bstream.total_out_lo32; + buf_before = (const Bytef *)pfile_in_zip_read_info->bstream.next_out; + + err = BZ2_bzDecompress(&pfile_in_zip_read_info->bstream); + + total_out_after = pfile_in_zip_read_info->bstream.total_out_lo32; + out_bytes = total_out_after - total_out_before; + + pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + out_bytes; + pfile_in_zip_read_info->rest_read_uncompressed -= out_bytes; + pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32, buf_before, (uInt)(out_bytes)); + + read += (uInt)(total_out_after - total_out_before); + + pfile_in_zip_read_info->stream.next_in = (Bytef *)pfile_in_zip_read_info->bstream.next_in; + pfile_in_zip_read_info->stream.avail_in = pfile_in_zip_read_info->bstream.avail_in; + pfile_in_zip_read_info->stream.total_in = pfile_in_zip_read_info->bstream.total_in_lo32; + pfile_in_zip_read_info->stream.next_out = (Bytef *)pfile_in_zip_read_info->bstream.next_out; + pfile_in_zip_read_info->stream.avail_out = pfile_in_zip_read_info->bstream.avail_out; + pfile_in_zip_read_info->stream.total_out = pfile_in_zip_read_info->bstream.total_out_lo32; + + if (err == BZ_STREAM_END) + return (read == 0) ? UNZ_EOF : read; + if (err != BZ_OK) + break; +#endif + } else { + ZPOS64_T total_out_before, total_out_after; + const Bytef *buf_before; + ZPOS64_T out_bytes; + int flush = Z_SYNC_FLUSH; + + total_out_before = pfile_in_zip_read_info->stream.total_out; + buf_before = pfile_in_zip_read_info->stream.next_out; + + /* + if ((pfile_in_zip_read_info->rest_read_uncompressed == + pfile_in_zip_read_info->stream.avail_out) && + (pfile_in_zip_read_info->rest_read_compressed == 0)) + flush = Z_FINISH; + */ + err = inflate(&pfile_in_zip_read_info->stream, flush); + + if ((err >= 0) && (pfile_in_zip_read_info->stream.msg != NULL)) + err = Z_DATA_ERROR; + + total_out_after = pfile_in_zip_read_info->stream.total_out; + out_bytes = total_out_after - total_out_before; + + pfile_in_zip_read_info->total_out_64 += out_bytes; + pfile_in_zip_read_info->rest_read_uncompressed -= out_bytes; + pfile_in_zip_read_info->crc32 = + crc32(pfile_in_zip_read_info->crc32, buf_before, (uInt)(out_bytes)); + + read += (uInt)(total_out_after - total_out_before); + + if (err == Z_STREAM_END) + return (read == 0) ? UNZ_EOF : read; + if (err != Z_OK) + break; + } + } + + if (err == Z_OK) + return read; + return err; +} + +extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64(unzFile file) +{ + unz64_s *s; + file_in_zip64_read_info_s *pfile_in_zip_read_info; + s = (unz64_s *)file; + if (file == NULL) + return 0; /* UNZ_PARAMERROR */ + pfile_in_zip_read_info = s->pfile_in_zip_read; + if (pfile_in_zip_read_info == NULL) + return 0; /* UNZ_PARAMERROR */ + return pfile_in_zip_read_info->pos_in_zipfile + pfile_in_zip_read_info->byte_before_the_zipfile; +} + +extern int ZEXPORT unzGetLocalExtrafield(unzFile file, voidp buf, unsigned len) +{ + unz64_s *s; + file_in_zip64_read_info_s *pfile_in_zip_read_info; + uInt read_now; + ZPOS64_T size_to_read; + + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_s *)file; + pfile_in_zip_read_info = s->pfile_in_zip_read; + + if (pfile_in_zip_read_info == NULL) + return UNZ_PARAMERROR; + + size_to_read = pfile_in_zip_read_info->size_local_extrafield - pfile_in_zip_read_info->pos_local_extrafield; + + if (buf == NULL) + return (int)size_to_read; + + if (len > size_to_read) + read_now = (uInt)size_to_read; + else + read_now = (uInt)len; + + if (read_now == 0) + return 0; + + if (ZSEEK64(pfile_in_zip_read_info->z_filefunc, pfile_in_zip_read_info->filestream, + pfile_in_zip_read_info->offset_local_extrafield + pfile_in_zip_read_info->pos_local_extrafield, + ZLIB_FILEFUNC_SEEK_SET) != 0) + return UNZ_ERRNO; + + if (ZREAD64(pfile_in_zip_read_info->z_filefunc, pfile_in_zip_read_info->filestream, buf, read_now) != read_now) + return UNZ_ERRNO; + + return (int)read_now; +} + +extern int ZEXPORT unzCloseCurrentFile(unzFile file) +{ + int err = UNZ_OK; + + unz64_s *s; + file_in_zip64_read_info_s *pfile_in_zip_read_info; + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_s *)file; + pfile_in_zip_read_info = s->pfile_in_zip_read; + + if (pfile_in_zip_read_info == NULL) + return UNZ_PARAMERROR; + +#ifdef HAVE_AES + if (s->cur_file_info.compression_method == AES_METHOD) { + unsigned char authcode[AES_AUTHCODESIZE]; + unsigned char rauthcode[AES_AUTHCODESIZE]; + + if (ZREAD64(s->z_filefunc, s->filestream, authcode, AES_AUTHCODESIZE) != AES_AUTHCODESIZE) + return UNZ_ERRNO; + + if (fcrypt_end(rauthcode, &s->pfile_in_zip_read->aes_ctx) != AES_AUTHCODESIZE) + err = UNZ_CRCERROR; + if (memcmp(authcode, rauthcode, AES_AUTHCODESIZE) != 0) + err = UNZ_CRCERROR; + } + /* AES zip version AE-1 will expect a valid crc as well */ + if ((s->cur_file_info.compression_method != AES_METHOD) || + (s->cur_file_info_internal.aes_version == 0x0001)) +#endif + { + if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) && + (!pfile_in_zip_read_info->raw)) { + if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait) + err = UNZ_CRCERROR; + } + } + + TRYFREE(pfile_in_zip_read_info->read_buffer); + pfile_in_zip_read_info->read_buffer = NULL; + if (pfile_in_zip_read_info->stream_initialised == Z_DEFLATED) + inflateEnd(&pfile_in_zip_read_info->stream); +#ifdef HAVE_BZIP2 + else if (pfile_in_zip_read_info->stream_initialised == Z_BZIP2ED) + BZ2_bzDecompressEnd(&pfile_in_zip_read_info->bstream); +#endif + + pfile_in_zip_read_info->stream_initialised = 0; + TRYFREE(pfile_in_zip_read_info); + + s->pfile_in_zip_read = NULL; + + return err; +} + +extern int ZEXPORT unzGoToFirstFile2(unzFile file, unz_file_info64 *pfile_info, char *filename, + uLong filename_size, void *extrafield, uLong extrafield_size, char *comment, uLong comment_size) +{ + int err = UNZ_OK; + unz64_s *s; + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_s *)file; + s->pos_in_central_dir = s->offset_central_dir; + s->num_file = 0; + err = unz64local_GetCurrentFileInfoInternal(file, &s->cur_file_info, &s->cur_file_info_internal, + filename, filename_size, extrafield, extrafield_size, comment, comment_size); + s->current_file_ok = (err == UNZ_OK); + if ((err == UNZ_OK) && (pfile_info != NULL)) + memcpy(pfile_info, &s->cur_file_info, sizeof(unz_file_info64)); + return err; +} + +extern int ZEXPORT unzGoToFirstFile(unzFile file) +{ + return unzGoToFirstFile2(file, NULL, NULL, 0, NULL, 0, NULL, 0); +} + +extern int ZEXPORT unzGoToNextFile2(unzFile file, unz_file_info64 *pfile_info, char *filename, + uLong filename_size, void *extrafield, uLong extrafield_size, char *comment, uLong comment_size) +{ + unz64_s *s; + int err; + + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_s *)file; + if (!s->current_file_ok) + return UNZ_END_OF_LIST_OF_FILE; + if (s->gi.number_entry != 0xffff) /* 2^16 files overflow hack */ + if (s->num_file + 1 == s->gi.number_entry) + return UNZ_END_OF_LIST_OF_FILE; + s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename + + s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment; + s->num_file++; + err = unz64local_GetCurrentFileInfoInternal(file, &s->cur_file_info, &s->cur_file_info_internal, + filename, filename_size, extrafield, extrafield_size, comment, comment_size); + s->current_file_ok = (err == UNZ_OK); + if ((err == UNZ_OK) && (pfile_info != NULL)) + memcpy(pfile_info, &s->cur_file_info, sizeof(unz_file_info64)); + return err; +} + +extern int ZEXPORT unzGoToNextFile(unzFile file) +{ + return unzGoToNextFile2(file, NULL, NULL, 0, NULL, 0, NULL, 0); +} + +extern int ZEXPORT unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filename_compare_func) +{ + unz64_s *s; + int err; + unz_file_info64 cur_file_info_saved; + unz_file_info64_internal cur_file_info_internal_saved; + ZPOS64_T num_file_saved; + ZPOS64_T pos_in_central_dir_saved; + char current_filename[UNZ_MAXFILENAMEINZIP + 1]; + + if (file == NULL) + return UNZ_PARAMERROR; + if (strlen(filename) >= UNZ_MAXFILENAMEINZIP) + return UNZ_PARAMERROR; + s = (unz64_s *)file; + if (!s->current_file_ok) + return UNZ_END_OF_LIST_OF_FILE; + + /* Save the current state */ + num_file_saved = s->num_file; + pos_in_central_dir_saved = s->pos_in_central_dir; + cur_file_info_saved = s->cur_file_info; + cur_file_info_internal_saved = s->cur_file_info_internal; + + err = unzGoToFirstFile2(file, NULL, current_filename, sizeof(current_filename) - 1, NULL, 0, NULL, 0); + + while (err == UNZ_OK) { + if (filename_compare_func != NULL) + err = filename_compare_func(file, current_filename, filename); + else + err = strcmp(current_filename, filename); + if (err == 0) + return UNZ_OK; + err = unzGoToNextFile2(file, NULL, current_filename, sizeof(current_filename) - 1, NULL, 0, NULL, 0); + } + + /* We failed, so restore the state of the 'current file' to where we were. */ + s->num_file = num_file_saved; + s->pos_in_central_dir = pos_in_central_dir_saved; + s->cur_file_info = cur_file_info_saved; + s->cur_file_info_internal = cur_file_info_internal_saved; + return err; +} + +extern int ZEXPORT unzGetFilePos(unzFile file, unz_file_pos *file_pos) +{ + unz64_file_pos file_pos64; + int err = unzGetFilePos64(file, &file_pos64); + if (err == UNZ_OK) { + file_pos->pos_in_zip_directory = (uLong)file_pos64.pos_in_zip_directory; + file_pos->num_of_file = (uLong)file_pos64.num_of_file; + } + return err; +} + +extern int ZEXPORT unzGoToFilePos(unzFile file, unz_file_pos *file_pos) +{ + unz64_file_pos file_pos64; + + if (file_pos == NULL) + return UNZ_PARAMERROR; + file_pos64.pos_in_zip_directory = file_pos->pos_in_zip_directory; + file_pos64.num_of_file = file_pos->num_of_file; + return unzGoToFilePos64(file, &file_pos64); +} + +extern int ZEXPORT unzGetFilePos64(unzFile file, unz64_file_pos *file_pos) +{ + unz64_s *s; + + if (file == NULL || file_pos == NULL) + return UNZ_PARAMERROR; + s = (unz64_s *)file; + if (!s->current_file_ok) + return UNZ_END_OF_LIST_OF_FILE; + + file_pos->pos_in_zip_directory = s->pos_in_central_dir; + file_pos->num_of_file = s->num_file; + + return UNZ_OK; +} + +extern int ZEXPORT unzGoToFilePos64(unzFile file, const unz64_file_pos *file_pos) +{ + unz64_s *s; + int err; + + if (file == NULL || file_pos == NULL) + return UNZ_PARAMERROR; + s = (unz64_s *)file; + + /* jump to the right spot */ + s->pos_in_central_dir = file_pos->pos_in_zip_directory; + s->num_file = file_pos->num_of_file; + + /* set the current file */ + err = unz64local_GetCurrentFileInfoInternal(file, &s->cur_file_info, &s->cur_file_info_internal, NULL, 0, NULL, 0, NULL, 0); + /* return results */ + s->current_file_ok = (err == UNZ_OK); + return err; +} + +extern uLong ZEXPORT unzGetOffset(unzFile file) +{ + ZPOS64_T offset64; + + if (file == NULL) + return 0; /* UNZ_PARAMERROR; */ + offset64 = unzGetOffset64(file); + return (uLong)offset64; +} + +extern ZPOS64_T ZEXPORT unzGetOffset64(unzFile file) +{ + unz64_s *s; + + if (file == NULL) + return 0; /* UNZ_PARAMERROR; */ + s = (unz64_s *)file; + if (!s->current_file_ok) + return 0; + if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff) + if (s->num_file == s->gi.number_entry) + return 0; + return s->pos_in_central_dir; +} + +extern int ZEXPORT unzSetOffset(unzFile file, uLong pos) +{ + return unzSetOffset64(file, pos); +} + +extern int ZEXPORT unzSetOffset64(unzFile file, ZPOS64_T pos) +{ + unz64_s *s; + int err; + + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_s *)file; + + s->pos_in_central_dir = pos; + s->num_file = s->gi.number_entry; /* hack */ + err = unz64local_GetCurrentFileInfoInternal(file, &s->cur_file_info, &s->cur_file_info_internal, NULL, 0, NULL, 0, NULL, 0); + s->current_file_ok = (err == UNZ_OK); + return err; +} + +extern z_off_t ZEXPORT unztell(unzFile file) +{ + unz64_s *s; + file_in_zip64_read_info_s *pfile_in_zip_read_info; + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_s *)file; + pfile_in_zip_read_info = s->pfile_in_zip_read; + if (pfile_in_zip_read_info == NULL) + return UNZ_PARAMERROR; + return (z_off_t)pfile_in_zip_read_info->stream.total_out; +} + +extern ZPOS64_T ZEXPORT unztell64(unzFile file) +{ + + unz64_s *s; + file_in_zip64_read_info_s *pfile_in_zip_read_info; + if (file == NULL) + return (ZPOS64_T)-1; + s = (unz64_s *)file; + pfile_in_zip_read_info = s->pfile_in_zip_read; + + if (pfile_in_zip_read_info == NULL) + return (ZPOS64_T)-1; + + return pfile_in_zip_read_info->total_out_64; +} + +extern int ZEXPORT unzeof(unzFile file) +{ + unz64_s *s; + file_in_zip64_read_info_s *pfile_in_zip_read_info; + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_s *)file; + pfile_in_zip_read_info = s->pfile_in_zip_read; + + if (pfile_in_zip_read_info == NULL) + return UNZ_PARAMERROR; + + if (pfile_in_zip_read_info->rest_read_uncompressed == 0) + return 1; + return 0; +} + diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/unzip.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/unzip.h new file mode 100755 index 0000000..7b614ff --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/unzip.h @@ -0,0 +1,248 @@ +/* unzip.h -- IO for uncompress .zip files using zlib + Version 1.1, February 14h, 2010 + part of the MiniZip project + + Copyright (C) 1998-2010 Gilles Vollant + http://www.winimage.com/zLibDll/minizip.html + Modifications of Unzip for Zip64 + Copyright (C) 2007-2008 Even Rouault + Modifications for Zip64 support on both zip and unzip + Copyright (C) 2009-2010 Mathias Svensson + http://result42.com + + This program is distributed under the terms of the same license as zlib. + See the accompanying LICENSE file for the full text of the license. +*/ + +#include "SSZipCommon.h" + +#ifndef _UNZ_H +#define _UNZ_H + +#define HAVE_AES + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _ZLIB_H +#include "zlib.h" +#endif + +#ifndef _ZLIBIOAPI_H +#include "ioapi.h" +#endif + +#ifdef HAVE_BZIP2 +#include "bzlib.h" +#endif + +#define Z_BZIP2ED 12 + +#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP) +/* like the STRICT of WIN32, we define a pointer that cannot be converted + from (void*) without cast */ +typedef struct TagunzFile__ { int unused; } unzFile__; +typedef unzFile__ *unzFile; +#else +typedef voidp unzFile; +#endif + + +#define UNZ_OK (0) +#define UNZ_END_OF_LIST_OF_FILE (-100) +#define UNZ_ERRNO (Z_ERRNO) +#define UNZ_EOF (0) +#define UNZ_PARAMERROR (-102) +#define UNZ_BADZIPFILE (-103) +#define UNZ_INTERNALERROR (-104) +#define UNZ_CRCERROR (-105) + + +/***************************************************************************/ +/* Opening and close a zip file */ + +extern unzFile ZEXPORT unzOpen OF((const char *path)); +extern unzFile ZEXPORT unzOpen64 OF((const void *path)); +/* Open a Zip file. + + path should contain the full pathname (by example, on a Windows XP computer + "c:\\zlib\\zlib113.zip" or on an Unix computer "zlib/zlib113.zip". + return NULL if zipfile cannot be opened or doesn't exist + return unzFile handle if no error + + NOTE: The "64" function take a const void* pointer, because the path is just the value passed to the + open64_file_func callback. Under Windows, if UNICODE is defined, using fill_fopen64_filefunc, the path + is a pointer to a wide unicode string (LPCTSTR is LPCWSTR), so const char* does not describe the reality */ + +extern unzFile ZEXPORT unzOpen2 OF((const char *path, zlib_filefunc_def* pzlib_filefunc_def)); +/* Open a Zip file, like unzOpen, but provide a set of file low level API for read/write operations */ +extern unzFile ZEXPORT unzOpen2_64 OF((const void *path, zlib_filefunc64_def* pzlib_filefunc_def)); +/* Open a Zip file, like unz64Open, but provide a set of file low level API for read/write 64-bit operations */ + +extern int ZEXPORT unzClose OF((unzFile file)); +/* Close a ZipFile opened with unzipOpen. If there is files inside the .Zip opened with unzOpenCurrentFile, + these files MUST be closed with unzipCloseCurrentFile before call unzipClose. + + return UNZ_OK if there is no error */ + +extern int ZEXPORT unzGetGlobalInfo OF((unzFile file, unz_global_info *pglobal_info)); +extern int ZEXPORT unzGetGlobalInfo64 OF((unzFile file, unz_global_info64 *pglobal_info)); +/* Write info about the ZipFile in the *pglobal_info structure. + + return UNZ_OK if no error */ + +extern int ZEXPORT unzGetGlobalComment OF((unzFile file, char *comment, uLong comment_size)); +/* Get the global comment string of the ZipFile, in the comment buffer. + + uSizeBuf is the size of the szComment buffer. + return the number of byte copied or an error code <0 */ + +/***************************************************************************/ +/* Reading the content of the current zipfile, you can open it, read data from it, and close it + (you can close it before reading all the file) */ + +extern int ZEXPORT unzOpenCurrentFile OF((unzFile file)); +/* Open for reading data the current file in the zipfile. + + return UNZ_OK if no error */ + +extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file, const char* password)); +/* Open for reading data the current file in the zipfile. + password is a crypting password + + return UNZ_OK if no error */ + +extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file, int* method, int* level, int raw)); +/* Same as unzOpenCurrentFile, but open for read raw the file (not uncompress) + if raw==1 *method will receive method of compression, *level will receive level of compression + + NOTE: you can set level parameter as NULL (if you did not want known level, + but you CANNOT set method parameter as NULL */ + +extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file, int* method, int* level, int raw, const char* password)); +/* Same as unzOpenCurrentFile, but takes extra parameter password for encrypted files */ + +extern int ZEXPORT unzReadCurrentFile OF((unzFile file, voidp buf, unsigned len)); +/* Read bytes from the current file (opened by unzOpenCurrentFile) + buf contain buffer where data must be copied + len the size of buf. + + return the number of byte copied if somes bytes are copied + return 0 if the end of file was reached + return <0 with error code if there is an error (UNZ_ERRNO for IO error, or zLib error for uncompress error) */ + +extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file, unz_file_info *pfile_info, char *filename, + uLong filename_size, void *extrafield, uLong extrafield_size, char *comment, uLong comment_size)); +extern int ZEXPORT unzGetCurrentFileInfo64 OF((unzFile file, unz_file_info64 *pfile_info, char *filename, + uLong filename_size, void *extrafield, uLong extrafield_size, char *comment, uLong comment_size)); +/* Get Info about the current file + + pfile_info if != NULL, the *pfile_info structure will contain somes info about the current file + filename if != NULL, the file name string will be copied in filename + filename_size is the size of the filename buffer + extrafield if != NULL, the extra field information from the central header will be copied in to + extrafield_size is the size of the extraField buffer + comment if != NULL, the comment string of the file will be copied in to + comment_size is the size of the comment buffer */ + +extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64 OF((unzFile file)); + +extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file, voidp buf, unsigned len)); +/* Read extra field from the current file (opened by unzOpenCurrentFile) + This is the local-header version of the extra field (sometimes, there is + more info in the local-header version than in the central-header) + + if buf == NULL, it return the size of the local extra field + if buf != NULL, len is the size of the buffer, the extra header is copied in buf. + + return number of bytes copied in buf, or (if <0) the error code */ + +extern int ZEXPORT unzCloseCurrentFile OF((unzFile file)); +/* Close the file in zip opened with unzOpenCurrentFile + + return UNZ_CRCERROR if all the file was read but the CRC is not good */ + +/***************************************************************************/ +/* Browse the directory of the zipfile */ + +typedef int (*unzFileNameComparer)(unzFile file, const char *filename1, const char *filename2); +typedef int (*unzIteratorFunction)(unzFile file); +typedef int (*unzIteratorFunction2)(unzFile file, unz_file_info64 *pfile_info, char *filename, + uLong filename_size, void *extrafield, uLong extrafield_size, char *comment, uLong comment_size); + +extern int ZEXPORT unzGoToFirstFile OF((unzFile file)); +/* Set the current file of the zipfile to the first file. + + return UNZ_OK if no error */ + +extern int ZEXPORT unzGoToFirstFile2 OF((unzFile file, unz_file_info64 *pfile_info, char *filename, + uLong filename_size, void *extrafield, uLong extrafield_size, char *comment, uLong comment_size)); +/* Set the current file of the zipfile to the first file and retrieves the current info on success. + Not as seek intensive as unzGoToFirstFile + unzGetCurrentFileInfo. + + return UNZ_OK if no error */ + +extern int ZEXPORT unzGoToNextFile OF((unzFile file)); +/* Set the current file of the zipfile to the next file. + + return UNZ_OK if no error + return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest */ + +extern int ZEXPORT unzGoToNextFile2 OF((unzFile file, unz_file_info64 *pfile_info, char *filename, + uLong filename_size, void *extrafield, uLong extrafield_size, char *comment, uLong comment_size)); +/* Set the current file of the zipfile to the next file and retrieves the current + info on success. Does less seeking around than unzGotoNextFile + unzGetCurrentFileInfo. + + return UNZ_OK if no error + return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest */ + +extern int ZEXPORT unzLocateFile OF((unzFile file, const char *filename, unzFileNameComparer filename_compare_func)); +/* Try locate the file szFileName in the zipfile. For custom filename comparison pass in comparison function. + + return UNZ_OK if the file is found (it becomes the current file) + return UNZ_END_OF_LIST_OF_FILE if the file is not found */ + +/***************************************************************************/ +/* Raw access to zip file */ + +typedef struct unz_file_pos_s +{ + uLong pos_in_zip_directory; /* offset in zip file directory */ + uLong num_of_file; /* # of file */ +} unz_file_pos; + +extern int ZEXPORT unzGetFilePos OF((unzFile file, unz_file_pos* file_pos)); +extern int ZEXPORT unzGoToFilePos OF((unzFile file, unz_file_pos* file_pos)); + +typedef struct unz64_file_pos_s +{ + ZPOS64_T pos_in_zip_directory; /* offset in zip file directory */ + ZPOS64_T num_of_file; /* # of file */ +} unz64_file_pos; + +extern int ZEXPORT unzGetFilePos64 OF((unzFile file, unz64_file_pos* file_pos)); +extern int ZEXPORT unzGoToFilePos64 OF((unzFile file, const unz64_file_pos* file_pos)); + +extern uLong ZEXPORT unzGetOffset OF((unzFile file)); +extern ZPOS64_T ZEXPORT unzGetOffset64 OF((unzFile file)); +/* Get the current file offset */ + +extern int ZEXPORT unzSetOffset OF((unzFile file, uLong pos)); +extern int ZEXPORT unzSetOffset64 OF((unzFile file, ZPOS64_T pos)); +/* Set the current file offset */ + +extern z_off_t ZEXPORT unztell OF((unzFile file)); +extern ZPOS64_T ZEXPORT unztell64 OF((unzFile file)); +/* return current position in uncompressed data */ + +extern int ZEXPORT unzeof OF((unzFile file)); +/* return 1 if the end of file was reached, 0 elsewhere */ + +/***************************************************************************/ + +#ifdef __cplusplus +} +#endif + +#endif /* _UNZ_H */ diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/zip.c b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/zip.c new file mode 100755 index 0000000..b88bd88 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/zip.c @@ -0,0 +1,1915 @@ +/* zip.c -- IO on .zip files using zlib + Version 1.1, February 14h, 2010 + part of the MiniZip project + + Copyright (C) 1998-2010 Gilles Vollant + http://www.winimage.com/zLibDll/minizip.html + Modifications for Zip64 support + Copyright (C) 2009-2010 Mathias Svensson + http://result42.com + Modifications for AES, PKWARE disk spanning + Copyright (C) 2010-2014 Nathan Moinvaziri + + This program is distributed under the terms of the same license as zlib. + See the accompanying LICENSE file for the full text of the license. + */ + +#include +#include +#include +#include +#include "zlib.h" +#include "zip.h" + +#ifdef STDC +# include +# include +# include +#endif +#ifdef NO_ERRNO_H +extern int errno; +#else +# include +#endif + +#ifdef HAVE_AES +# define AES_METHOD (99) +# define AES_PWVERIFYSIZE (2) +# define AES_AUTHCODESIZE (10) +# define AES_MAXSALTLENGTH (16) +# define AES_VERSION (0x0001) +# define AES_ENCRYPTIONMODE (0x03) + +# include "aes.h" +# include "fileenc.h" +# include "prng.h" +# include "entropy.h" +#endif + +#ifndef NOCRYPT +# define INCLUDECRYPTINGCODE_IFCRYPTALLOWED +# include "crypt.h" +#endif + +#ifndef local +# define local static +#endif +/* compile with -Dlocal if your debugger can't find static symbols */ + +#define SIZEDATA_INDATABLOCK (4096 - (4 * 4)) + +#define DISKHEADERMAGIC (0x08074b50) +#define LOCALHEADERMAGIC (0x04034b50) +#define CENTRALHEADERMAGIC (0x02014b50) +#define ENDHEADERMAGIC (0x06054b50) +#define ZIP64ENDHEADERMAGIC (0x06064b50) +#define ZIP64ENDLOCHEADERMAGIC (0x07064b50) + +#define FLAG_LOCALHEADER_OFFSET (0x06) +#define CRC_LOCALHEADER_OFFSET (0x0e) + +#define SIZECENTRALHEADER (0x2e) /* 46 */ +#define SIZECENTRALHEADERLOCATOR (0x14) /* 20 */ +#define SIZECENTRALDIRITEM (0x2e) +#define SIZEZIPLOCALHEADER (0x1e) + +#ifndef BUFREADCOMMENT +# define BUFREADCOMMENT (0x400) +#endif +#ifndef VERSIONMADEBY +# define VERSIONMADEBY (0x0) /* platform dependent */ +#endif + +#ifndef Z_BUFSIZE +# define Z_BUFSIZE (64 * 1024) +#endif +#ifndef Z_MAXFILENAMEINZIP +# define Z_MAXFILENAMEINZIP (256) +#endif + +#ifndef ALLOC +# define ALLOC(size) (malloc(size)) +#endif +#ifndef TRYFREE +# define TRYFREE(p) {if (p) free(p); } +#endif + +/* NOT sure that this work on ALL platform */ +#define MAKEULONG64(a, b) ((ZPOS64_T)(((unsigned long)(a)) | ((ZPOS64_T)((unsigned long)(b))) << 32)) + +#ifndef DEF_MEM_LEVEL +# if MAX_MEM_LEVEL >= 8 +# define DEF_MEM_LEVEL 8 +# else +# define DEF_MEM_LEVEL MAX_MEM_LEVEL +# endif +#endif + +const char zip_copyright[] = " zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll"; + +typedef struct linkedlist_datablock_internal_s { + struct linkedlist_datablock_internal_s *next_datablock; + uLong avail_in_this_block; + uLong filled_in_this_block; + uLong unused; /* for future use and alignment */ + unsigned char data[SIZEDATA_INDATABLOCK]; +} linkedlist_datablock_internal; + +typedef struct linkedlist_data_s { + linkedlist_datablock_internal *first_block; + linkedlist_datablock_internal *last_block; +} linkedlist_data; + +typedef struct { + z_stream stream; /* zLib stream structure for inflate */ +#ifdef HAVE_BZIP2 + bz_stream bstream; /* bzLib stream structure for bziped */ +#endif +#ifdef HAVE_AES + fcrypt_ctx aes_ctx; + prng_ctx aes_rng[1]; +#endif + int stream_initialised; /* 1 is stream is initialized */ + uInt pos_in_buffered_data; /* last written byte in buffered_data */ + + ZPOS64_T pos_local_header; /* offset of the local header of the file currently writing */ + char *central_header; /* central header data for the current file */ + uLong size_centralextra; + uLong size_centralheader; /* size of the central header for cur file */ + uLong size_centralextrafree; /* Extra bytes allocated to the central header but that are not used */ + uLong size_comment; + uLong flag; /* flag of the file currently writing */ + + int method; /* compression method written to file.*/ + int compression_method; /* compression method to use */ + int raw; /* 1 for directly writing raw data */ + Byte buffered_data[Z_BUFSIZE]; /* buffer contain compressed data to be writ*/ + uLong dosDate; + uLong crc32; + int zip64; /* Add ZIP64 extended information in the extra field */ + uLong number_disk; /* number of current disk used for spanning ZIP */ + ZPOS64_T pos_zip64extrainfo; + ZPOS64_T total_compressed; + ZPOS64_T total_uncompressed; +#ifndef NOCRYPT + unsigned long keys[3]; /* keys defining the pseudo-random sequence */ + const unsigned long *pcrc_32_tab; + int crypt_header_size; +#endif +} curfile64_info; + +typedef struct { + zlib_filefunc64_32_def z_filefunc; + voidpf filestream; /* io structure of the zipfile */ + voidpf filestream_with_CD; /* io structure of the zipfile with the central dir */ + linkedlist_data central_dir; /* datablock with central dir in construction*/ + int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/ + int append; /* append mode */ + curfile64_info ci; /* info on the file currently writing */ + + ZPOS64_T begin_pos; /* position of the beginning of the zipfile */ + ZPOS64_T add_position_when_writting_offset; + ZPOS64_T number_entry; + ZPOS64_T disk_size; /* size of each disk */ + uLong number_disk; /* number of the current disk, used for spanning ZIP */ + uLong number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP */ +#ifndef NO_ADDFILEINEXISTINGZIP + char *globalcomment; +#endif +} zip64_internal; + +/* Allocate a new data block */ +local linkedlist_datablock_internal *allocate_new_datablock OF(()); +local linkedlist_datablock_internal *allocate_new_datablock() +{ + linkedlist_datablock_internal *ldi; + + ldi = (linkedlist_datablock_internal *)ALLOC(sizeof(linkedlist_datablock_internal)); + + if (ldi != NULL) { + ldi->next_datablock = NULL; + ldi->filled_in_this_block = 0; + ldi->avail_in_this_block = SIZEDATA_INDATABLOCK; + } + return ldi; +} + +/* Free data block in linked list */ +local void free_datablock OF((linkedlist_datablock_internal * ldi)); +local void free_datablock(linkedlist_datablock_internal *ldi) +{ + while (ldi != NULL) { + linkedlist_datablock_internal *ldinext = ldi->next_datablock; + TRYFREE(ldi); + ldi = ldinext; + } +} + +/* Initialize linked list */ +local void init_linkedlist OF((linkedlist_data * ll)); +local void init_linkedlist(linkedlist_data *ll) +{ + ll->first_block = ll->last_block = NULL; +} + +/* Free entire linked list and all data blocks */ +local void free_linkedlist OF((linkedlist_data * ll)); +local void free_linkedlist(linkedlist_data *ll) +{ + free_datablock(ll->first_block); + ll->first_block = ll->last_block = NULL; +} + +/* Add data to linked list data block */ +local int add_data_in_datablock OF((linkedlist_data * ll, const void *buf, uLong len)); +local int add_data_in_datablock(linkedlist_data *ll, const void *buf, uLong len) +{ + linkedlist_datablock_internal *ldi; + const unsigned char *from_copy; + + if (ll == NULL) + return ZIP_INTERNALERROR; + + if (ll->last_block == NULL) { + ll->first_block = ll->last_block = allocate_new_datablock(); + if (ll->first_block == NULL) + return ZIP_INTERNALERROR; + } + + ldi = ll->last_block; + from_copy = (unsigned char *)buf; + + while (len > 0) { + uInt copy_this; + uInt i; + unsigned char *to_copy; + + if (ldi->avail_in_this_block == 0) { + ldi->next_datablock = allocate_new_datablock(); + if (ldi->next_datablock == NULL) + return ZIP_INTERNALERROR; + ldi = ldi->next_datablock; + ll->last_block = ldi; + } + + if (ldi->avail_in_this_block < len) + copy_this = (uInt)ldi->avail_in_this_block; + else + copy_this = (uInt)len; + + to_copy = &(ldi->data[ldi->filled_in_this_block]); + + for (i = 0; i < copy_this; i++) + *(to_copy + i) = *(from_copy + i); + + ldi->filled_in_this_block += copy_this; + ldi->avail_in_this_block -= copy_this; + from_copy += copy_this; + len -= copy_this; + } + return ZIP_OK; +} + +local uLong zip64local_TmzDateToDosDate OF((const tm_zip * ptm)); +local uLong zip64local_TmzDateToDosDate(const tm_zip *ptm) +{ + uLong year; +#define zip64local_in_range(min, max, value) ((min) <= (value) && (value) <= (max)) + /* Years supported: + * [00, 79] (assumed to be between 2000 and 2079) + * [80, 207] (assumed to be between 1980 and 2107, typical output of old + software that does 'year-1900' to get a double digit year) + * [1980, 2107] + Due to the date format limitations, only years between 1980 and 2107 can be stored. + */ + if (!(zip64local_in_range(1980, 2107, ptm->tm_year) || zip64local_in_range(0, 207, ptm->tm_year)) || + !zip64local_in_range(0, 11, ptm->tm_mon) || + !zip64local_in_range(1, 31, ptm->tm_mday) || + !zip64local_in_range(0, 23, ptm->tm_hour) || + !zip64local_in_range(0, 59, ptm->tm_min) || + !zip64local_in_range(0, 59, ptm->tm_sec)) + return 0; +#undef zip64local_in_range + + year = (uLong)ptm->tm_year; + if (year >= 1980) /* range [1980, 2107] */ + year -= 1980; + else if (year >= 80) /* range [80, 99] */ + year -= 80; + else /* range [00, 79] */ + year += 20; + + return + (uLong)(((ptm->tm_mday) + (32 * (ptm->tm_mon + 1)) + (512 * year)) << 16) | + ((ptm->tm_sec / 2) + (32 * ptm->tm_min) + (2048 * (uLong)ptm->tm_hour)); +} + +/* Inputs a long in LSB order to the given file: nbByte == 1, 2 ,4 or 8 (byte, short or long, ZPOS64_T) */ +local int zip64local_putValue OF((const zlib_filefunc64_32_def * pzlib_filefunc_def, voidpf filestream, + ZPOS64_T x, int nbByte)); +local int zip64local_putValue(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, + ZPOS64_T x, int nbByte) +{ + unsigned char buf[8]; + int n; + for (n = 0; n < nbByte; n++) { + buf[n] = (unsigned char)(x & 0xff); + x >>= 8; + } + if (x != 0) { + /* data overflow - hack for ZIP64 (X Roche) */ + for (n = 0; n < nbByte; n++) { + buf[n] = 0xff; + } + } + + if (ZWRITE64(*pzlib_filefunc_def, filestream, buf, nbByte) != (uLong)nbByte) + return ZIP_ERRNO; + + return ZIP_OK; +} + +local void zip64local_putValue_inmemory OF((void *dest, ZPOS64_T x, int nbByte)); +local void zip64local_putValue_inmemory(void *dest, ZPOS64_T x, int nbByte) +{ + unsigned char *buf = (unsigned char *)dest; + int n; + for (n = 0; n < nbByte; n++) { + buf[n] = (unsigned char)(x & 0xff); + x >>= 8; + } + + if (x != 0) { + /* data overflow - hack for ZIP64 */ + for (n = 0; n < nbByte; n++) { + buf[n] = 0xff; + } + } +} + +local int zip64local_getByte OF((const zlib_filefunc64_32_def * pzlib_filefunc_def, voidpf filestream, int *pi)); +local int zip64local_getByte(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, int *pi) +{ + unsigned char c; + int err = (int)ZREAD64(*pzlib_filefunc_def, filestream, &c, 1); + if (err == 1) { + *pi = (int)c; + return ZIP_OK; + } + if (ZERROR64(*pzlib_filefunc_def, filestream)) + return ZIP_ERRNO; + return ZIP_EOF; +} + +local int zip64local_getShort OF((const zlib_filefunc64_32_def * pzlib_filefunc_def, voidpf filestream, uLong * pX)); +local int zip64local_getShort(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uLong *pX) +{ + uLong x; + int i = 0; + int err; + + err = zip64local_getByte(pzlib_filefunc_def, filestream, &i); + x = (uLong)i; + if (err == ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def, filestream, &i); + x += ((uLong)i) << 8; + + if (err == ZIP_OK) + *pX = x; + else + *pX = 0; + return err; +} + +local int zip64local_getLong OF((const zlib_filefunc64_32_def * pzlib_filefunc_def, voidpf filestream, uLong * pX)); +local int zip64local_getLong(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uLong *pX) +{ + uLong x; + int i = 0; + int err; + + err = zip64local_getByte(pzlib_filefunc_def, filestream, &i); + x = (uLong)i; + if (err == ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def, filestream, &i); + x += ((uLong)i) << 8; + if (err == ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def, filestream, &i); + x += ((uLong)i) << 16; + if (err == ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def, filestream, &i); + x += ((uLong)i) << 24; + + if (err == ZIP_OK) + *pX = x; + else + *pX = 0; + return err; +} + +local int zip64local_getLong64 OF((const zlib_filefunc64_32_def * pzlib_filefunc_def, voidpf filestream, ZPOS64_T * pX)); +local int zip64local_getLong64(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX) +{ + ZPOS64_T x; + int i = 0; + int err; + + err = zip64local_getByte(pzlib_filefunc_def, filestream, &i); + x = (ZPOS64_T)i; + if (err == ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def, filestream, &i); + x += ((ZPOS64_T)i) << 8; + if (err == ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def, filestream, &i); + x += ((ZPOS64_T)i) << 16; + if (err == ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def, filestream, &i); + x += ((ZPOS64_T)i) << 24; + if (err == ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def, filestream, &i); + x += ((ZPOS64_T)i) << 32; + if (err == ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def, filestream, &i); + x += ((ZPOS64_T)i) << 40; + if (err == ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def, filestream, &i); + x += ((ZPOS64_T)i) << 48; + if (err == ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def, filestream, &i); + x += ((ZPOS64_T)i) << 56; + + if (err == ZIP_OK) + *pX = x; + else + *pX = 0; + + return err; +} + +/* Gets the amount of bytes left to write to the current disk for spanning archives */ +local int zipGetDiskSizeAvailable OF((zipFile file, ZPOS64_T * size_available)); +local int zipGetDiskSizeAvailable(zipFile file, ZPOS64_T *size_available) +{ + zip64_internal *zi; + ZPOS64_T current_disk_size; + + zi = (zip64_internal *)file; + ZSEEK64(zi->z_filefunc, zi->filestream, 0, ZLIB_FILEFUNC_SEEK_END); + current_disk_size = ZTELL64(zi->z_filefunc, zi->filestream); + *size_available = zi->disk_size - current_disk_size; + return ZIP_OK; +} + +/* Goes to a specific disk number for spanning archives */ +local int zipGoToSpecificDisk OF((zipFile file, int number_disk, int open_existing)); +local int zipGoToSpecificDisk(zipFile file, int number_disk, int open_existing) +{ + zip64_internal *zi; + int err = ZIP_OK; + + zi = (zip64_internal *)file; + if (zi->disk_size == 0) + return err; + + if ((zi->filestream != NULL) && (zi->filestream != zi->filestream_with_CD)) + ZCLOSE64(zi->z_filefunc, zi->filestream); + + zi->filestream = ZOPENDISK64(zi->z_filefunc, zi->filestream_with_CD, number_disk, (open_existing == 1) ? + (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING) : + (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE)); + + if (zi->filestream == NULL) + err = ZIP_ERRNO; + + return err; +} + +/* Goes to the first disk in a spanned archive */ +local int zipGoToFirstDisk OF((zipFile file)); +local int zipGoToFirstDisk(zipFile file) +{ + zip64_internal *zi; + int number_disk_next; + int err = ZIP_OK; + + zi = (zip64_internal *)file; + + if (zi->disk_size == 0) + return err; + number_disk_next = 0; + if (zi->number_disk_with_CD > 0) + number_disk_next = (int)zi->number_disk_with_CD - 1; + err = zipGoToSpecificDisk(file, number_disk_next, (zi->append == APPEND_STATUS_ADDINZIP)); + if ((err == ZIP_ERRNO) && (zi->append == APPEND_STATUS_ADDINZIP)) + err = zipGoToSpecificDisk(file, number_disk_next, 0); + if (err == ZIP_OK) + zi->number_disk = number_disk_next; + ZSEEK64(zi->z_filefunc, zi->filestream, 0, ZLIB_FILEFUNC_SEEK_END); + return err; +} + +/* Goes to the next disk in a spanned archive */ +local int zipGoToNextDisk OF((zipFile file)); +local int zipGoToNextDisk(zipFile file) +{ + zip64_internal *zi; + ZPOS64_T size_available_in_disk; + int err = ZIP_OK; + int number_disk_next; + + zi = (zip64_internal *)file; + + if (zi->disk_size == 0) + return err; + + number_disk_next = (int)zi->number_disk + 1; + + do { + err = zipGoToSpecificDisk(file, number_disk_next, (zi->append == APPEND_STATUS_ADDINZIP)); + if ((err == ZIP_ERRNO) && (zi->append == APPEND_STATUS_ADDINZIP)) + err = zipGoToSpecificDisk(file, number_disk_next, 0); + if (err != ZIP_OK) + break; + err = zipGetDiskSizeAvailable(file, &size_available_in_disk); + if (err != ZIP_OK) + break; + zi->number_disk = number_disk_next; + zi->number_disk_with_CD = zi->number_disk + 1; + + number_disk_next += 1; + } while (size_available_in_disk <= 0); + + return err; +} + +/* Locate the Central directory of a zipfile (at the end, just before the global comment) */ +local ZPOS64_T zip64local_SearchCentralDir OF((const zlib_filefunc64_32_def * pzlib_filefunc_def, voidpf filestream)); +local ZPOS64_T zip64local_SearchCentralDir(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream) +{ + unsigned char *buf; + ZPOS64_T file_size; + ZPOS64_T back_read = 4; + ZPOS64_T max_back = 0xffff; /* maximum size of global comment */ + ZPOS64_T pos_found = 0; + uLong read_size; + ZPOS64_T read_pos; + int i; + + buf = (unsigned char *)ALLOC(BUFREADCOMMENT + 4); + if (buf == NULL) + return 0; + + if (ZSEEK64(*pzlib_filefunc_def, filestream, 0, ZLIB_FILEFUNC_SEEK_END) != 0) { + TRYFREE(buf); + return 0; + } + + file_size = ZTELL64(*pzlib_filefunc_def, filestream); + + if (max_back > file_size) + max_back = file_size; + + while (back_read < max_back) { + if (back_read + BUFREADCOMMENT > max_back) + back_read = max_back; + else + back_read += BUFREADCOMMENT; + + read_pos = file_size - back_read; + read_size = ((BUFREADCOMMENT + 4) < (file_size - read_pos)) ? + (BUFREADCOMMENT + 4) : (uLong)(file_size - read_pos); + + if (ZSEEK64(*pzlib_filefunc_def, filestream, read_pos, ZLIB_FILEFUNC_SEEK_SET) != 0) + break; + if (ZREAD64(*pzlib_filefunc_def, filestream, buf, read_size) != read_size) + break; + + for (i = (int)read_size - 3; (i--) > 0; ) + if ((*(buf + i)) == (ENDHEADERMAGIC & 0xff) && + (*(buf + i + 1)) == (ENDHEADERMAGIC >> 8 & 0xff) && + (*(buf + i + 2)) == (ENDHEADERMAGIC >> 16 & 0xff) && + (*(buf + i + 3)) == (ENDHEADERMAGIC >> 24 & 0xff)) { + pos_found = read_pos + i; + break; + } + + if (pos_found != 0) + break; + } + TRYFREE(buf); + return pos_found; +} + +/* Locate the Central directory 64 of a zipfile (at the end, just before the global comment) */ +local ZPOS64_T zip64local_SearchCentralDir64 OF((const zlib_filefunc64_32_def * pzlib_filefunc_def, voidpf filestream, + const ZPOS64_T endcentraloffset)); +local ZPOS64_T zip64local_SearchCentralDir64(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, + const ZPOS64_T endcentraloffset) +{ + ZPOS64_T offset; + uLong uL; + + /* Zip64 end of central directory locator */ + if (ZSEEK64(*pzlib_filefunc_def, filestream, endcentraloffset - SIZECENTRALHEADERLOCATOR, ZLIB_FILEFUNC_SEEK_SET) != 0) + return 0; + + /* read locator signature */ + if (zip64local_getLong(pzlib_filefunc_def, filestream, &uL) != ZIP_OK) + return 0; + if (uL != ZIP64ENDLOCHEADERMAGIC) + return 0; + /* number of the disk with the start of the zip64 end of central directory */ + if (zip64local_getLong(pzlib_filefunc_def, filestream, &uL) != ZIP_OK) + return 0; + /* relative offset of the zip64 end of central directory record */ + if (zip64local_getLong64(pzlib_filefunc_def, filestream, &offset) != ZIP_OK) + return 0; + /* total number of disks */ + if (zip64local_getLong(pzlib_filefunc_def, filestream, &uL) != ZIP_OK) + return 0; + /* Goto end of central directory record */ + if (ZSEEK64(*pzlib_filefunc_def, filestream, offset, ZLIB_FILEFUNC_SEEK_SET) != 0) + return 0; + /* the signature */ + if (zip64local_getLong(pzlib_filefunc_def, filestream, &uL) != ZIP_OK) + return 0; + if (uL != ZIP64ENDHEADERMAGIC) + return 0; + + return offset; +} + +extern zipFile ZEXPORT zipOpen4(const void *pathname, int append, ZPOS64_T disk_size, zipcharpc *globalcomment, + zlib_filefunc64_32_def *pzlib_filefunc64_32_def) +{ + zip64_internal ziinit; + zip64_internal *zi; +#ifndef NO_ADDFILEINEXISTINGZIP + ZPOS64_T byte_before_the_zipfile; /* byte before the zipfile, (>0 for sfx)*/ + ZPOS64_T size_central_dir = 0; /* size of the central directory */ + ZPOS64_T offset_central_dir = 0; /* offset of start of central directory */ + ZPOS64_T number_entry_CD = 0; /* total number of entries in the central dir */ + ZPOS64_T number_entry; + ZPOS64_T central_pos; + ZPOS64_T size_central_dir_to_read; + uLong uL; + uLong size_comment = 0; + size_t buf_size = SIZEDATA_INDATABLOCK; + void *buf_read; +#endif + int err = ZIP_OK; + int mode; + + ziinit.z_filefunc.zseek32_file = NULL; + ziinit.z_filefunc.ztell32_file = NULL; + if (pzlib_filefunc64_32_def == NULL) + fill_fopen64_filefunc(&ziinit.z_filefunc.zfile_func64); + else + ziinit.z_filefunc = *pzlib_filefunc64_32_def; + + if (append == APPEND_STATUS_CREATE) + mode = (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE); + else + mode = (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING); + + ziinit.filestream = ZOPEN64(ziinit.z_filefunc, pathname, mode); + if (ziinit.filestream == NULL) + return NULL; + + if (append == APPEND_STATUS_CREATEAFTER) { + /* Don't support spanning ZIP with APPEND_STATUS_CREATEAFTER */ + if (disk_size > 0) + return NULL; + + ZSEEK64(ziinit.z_filefunc, ziinit.filestream, 0, SEEK_END); + } + + ziinit.filestream_with_CD = ziinit.filestream; + ziinit.append = append; + ziinit.number_disk = 0; + ziinit.number_disk_with_CD = 0; + ziinit.disk_size = disk_size; + ziinit.begin_pos = ZTELL64(ziinit.z_filefunc, ziinit.filestream); + ziinit.in_opened_file_inzip = 0; + ziinit.ci.stream_initialised = 0; + ziinit.number_entry = 0; + ziinit.add_position_when_writting_offset = 0; + init_linkedlist(&(ziinit.central_dir)); + + zi = (zip64_internal *)ALLOC(sizeof(zip64_internal)); + if (zi == NULL) { + ZCLOSE64(ziinit.z_filefunc, ziinit.filestream); + return NULL; + } + +#ifndef NO_ADDFILEINEXISTINGZIP + /* Add file in a zipfile */ + ziinit.globalcomment = NULL; + if (append == APPEND_STATUS_ADDINZIP) { + /* Read and Cache Central Directory Records */ + central_pos = zip64local_SearchCentralDir(&ziinit.z_filefunc, ziinit.filestream); + /* disable to allow appending to empty ZIP archive (must be standard zip, not zip64) + if (central_pos == 0) + err = ZIP_ERRNO; + */ + + if (err == ZIP_OK) { + /* read end of central directory info */ + if (ZSEEK64(ziinit.z_filefunc, ziinit.filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0) + err = ZIP_ERRNO; + + /* the signature, already checked */ + if (zip64local_getLong(&ziinit.z_filefunc, ziinit.filestream, &uL) != ZIP_OK) + err = ZIP_ERRNO; + /* number of this disk */ + if (zip64local_getShort(&ziinit.z_filefunc, ziinit.filestream, &ziinit.number_disk) != ZIP_OK) + err = ZIP_ERRNO; + /* number of the disk with the start of the central directory */ + if (zip64local_getShort(&ziinit.z_filefunc, ziinit.filestream, &ziinit.number_disk_with_CD) != ZIP_OK) + err = ZIP_ERRNO; + /* total number of entries in the central dir on this disk */ + number_entry = 0; + if (zip64local_getShort(&ziinit.z_filefunc, ziinit.filestream, &uL) != ZIP_OK) + err = ZIP_ERRNO; + else + number_entry = uL; + /* total number of entries in the central dir */ + number_entry_CD = 0; + if (zip64local_getShort(&ziinit.z_filefunc, ziinit.filestream, &uL) != ZIP_OK) + err = ZIP_ERRNO; + else + number_entry_CD = uL; + if (number_entry_CD != number_entry) + err = ZIP_BADZIPFILE; + /* size of the central directory */ + size_central_dir = 0; + if (zip64local_getLong(&ziinit.z_filefunc, ziinit.filestream, &uL) != ZIP_OK) + err = ZIP_ERRNO; + else + size_central_dir = uL; + /* offset of start of central directory with respect to the starting disk number */ + offset_central_dir = 0; + if (zip64local_getLong(&ziinit.z_filefunc, ziinit.filestream, &uL) != ZIP_OK) + err = ZIP_ERRNO; + else + offset_central_dir = uL; + /* zipfile global comment length */ + if (zip64local_getShort(&ziinit.z_filefunc, ziinit.filestream, &size_comment) != ZIP_OK) + err = ZIP_ERRNO; + + if ((err == ZIP_OK) && ((number_entry_CD == 0xffff) || (offset_central_dir == 0xffffffff))) { + /* Format should be Zip64, as the central directory or file size is too large */ + central_pos = zip64local_SearchCentralDir64(&ziinit.z_filefunc, ziinit.filestream, central_pos); + + if (central_pos) { + ZPOS64_T sizeEndOfCentralDirectory; + + if (ZSEEK64(ziinit.z_filefunc, ziinit.filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0) + err = ZIP_ERRNO; + + /* the signature, already checked */ + if (zip64local_getLong(&ziinit.z_filefunc, ziinit.filestream, &uL) != ZIP_OK) + err = ZIP_ERRNO; + /* size of zip64 end of central directory record */ + if (zip64local_getLong64(&ziinit.z_filefunc, ziinit.filestream, &sizeEndOfCentralDirectory) != ZIP_OK) + err = ZIP_ERRNO; + /* version made by */ + if (zip64local_getShort(&ziinit.z_filefunc, ziinit.filestream, &uL) != ZIP_OK) + err = ZIP_ERRNO; + /* version needed to extract */ + if (zip64local_getShort(&ziinit.z_filefunc, ziinit.filestream, &uL) != ZIP_OK) + err = ZIP_ERRNO; + /* number of this disk */ + if (zip64local_getLong(&ziinit.z_filefunc, ziinit.filestream, &ziinit.number_disk) != ZIP_OK) + err = ZIP_ERRNO; + /* number of the disk with the start of the central directory */ + if (zip64local_getLong(&ziinit.z_filefunc, ziinit.filestream, &ziinit.number_disk_with_CD) != ZIP_OK) + err = ZIP_ERRNO; + /* total number of entries in the central directory on this disk */ + if (zip64local_getLong64(&ziinit.z_filefunc, ziinit.filestream, &number_entry) != ZIP_OK) + err = ZIP_ERRNO; + /* total number of entries in the central directory */ + if (zip64local_getLong64(&ziinit.z_filefunc, ziinit.filestream, &number_entry_CD) != ZIP_OK) + err = ZIP_ERRNO; + if (number_entry_CD != number_entry) + err = ZIP_BADZIPFILE; + /* size of the central directory */ + if (zip64local_getLong64(&ziinit.z_filefunc, ziinit.filestream, &size_central_dir) != ZIP_OK) + err = ZIP_ERRNO; + /* offset of start of central directory with respect to the starting disk number */ + if (zip64local_getLong64(&ziinit.z_filefunc, ziinit.filestream, &offset_central_dir) != ZIP_OK) + err = ZIP_ERRNO; + } else + err = ZIP_BADZIPFILE; + } + } + + if ((err == ZIP_OK) && (central_pos < offset_central_dir + size_central_dir)) + err = ZIP_BADZIPFILE; + + if (err != ZIP_OK) { + ZCLOSE64(ziinit.z_filefunc, ziinit.filestream); + TRYFREE(zi); + return NULL; + } + + if (size_comment > 0) { + ziinit.globalcomment = (char *)ALLOC(size_comment + 1); + if (ziinit.globalcomment) { + size_comment = ZREAD64(ziinit.z_filefunc, ziinit.filestream, ziinit.globalcomment, size_comment); + ziinit.globalcomment[size_comment] = 0; + } + } + + byte_before_the_zipfile = central_pos - (offset_central_dir + size_central_dir); + ziinit.add_position_when_writting_offset = byte_before_the_zipfile; + + /* Store central directory in memory */ + size_central_dir_to_read = size_central_dir; + buf_size = SIZEDATA_INDATABLOCK; + buf_read = (void *)ALLOC(buf_size); + if (buf_read == NULL) + err = ZIP_INTERNALERROR; + + if (ZSEEK64(ziinit.z_filefunc, ziinit.filestream, + offset_central_dir + byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0) + err = ZIP_ERRNO; + + while ((size_central_dir_to_read > 0) && (err == ZIP_OK)) { + ZPOS64_T read_this = SIZEDATA_INDATABLOCK; + if (read_this > size_central_dir_to_read) + read_this = size_central_dir_to_read; + + if (ZREAD64(ziinit.z_filefunc, ziinit.filestream, buf_read, (uLong)read_this) != read_this) + err = ZIP_ERRNO; + + if (err == ZIP_OK) + err = add_data_in_datablock(&ziinit.central_dir, buf_read, (uLong)read_this); + + size_central_dir_to_read -= read_this; + } + TRYFREE(buf_read); + + ziinit.begin_pos = byte_before_the_zipfile; + ziinit.number_entry = number_entry_CD; + + if (ZSEEK64(ziinit.z_filefunc, ziinit.filestream, + offset_central_dir + byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0) + err = ZIP_ERRNO; + } + + if (globalcomment) + *globalcomment = ziinit.globalcomment; +#endif + + if (err != ZIP_OK) { +#ifndef NO_ADDFILEINEXISTINGZIP + TRYFREE(ziinit.globalcomment); +#endif + TRYFREE(zi); + return NULL; + } + + *zi = ziinit; + zipGoToFirstDisk((zipFile)zi); + return (zipFile)zi; +} + +extern zipFile ZEXPORT zipOpen2(const char *pathname, int append, zipcharpc *globalcomment, + zlib_filefunc_def *pzlib_filefunc32_def) +{ + if (pzlib_filefunc32_def != NULL) { + zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; + fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill, pzlib_filefunc32_def); + return zipOpen4(pathname, append, 0, globalcomment, &zlib_filefunc64_32_def_fill); + } + return zipOpen4(pathname, append, 0, globalcomment, NULL); +} + +extern zipFile ZEXPORT zipOpen2_64(const void *pathname, int append, zipcharpc *globalcomment, + zlib_filefunc64_def *pzlib_filefunc_def) +{ + if (pzlib_filefunc_def != NULL) { + zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; + zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def; + zlib_filefunc64_32_def_fill.ztell32_file = NULL; + zlib_filefunc64_32_def_fill.zseek32_file = NULL; + return zipOpen4(pathname, append, 0, globalcomment, &zlib_filefunc64_32_def_fill); + } + return zipOpen4(pathname, append, 0, globalcomment, NULL); +} + +extern zipFile ZEXPORT zipOpen3(const char *pathname, int append, ZPOS64_T disk_size, zipcharpc *globalcomment, + zlib_filefunc_def *pzlib_filefunc32_def) +{ + if (pzlib_filefunc32_def != NULL) { + zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; + fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill, pzlib_filefunc32_def); + return zipOpen4(pathname, append, disk_size, globalcomment, &zlib_filefunc64_32_def_fill); + } + return zipOpen4(pathname, append, disk_size, globalcomment, NULL); +} + +extern zipFile ZEXPORT zipOpen3_64(const void *pathname, int append, ZPOS64_T disk_size, zipcharpc *globalcomment, + zlib_filefunc64_def *pzlib_filefunc_def) +{ + if (pzlib_filefunc_def != NULL) { + zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; + zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def; + zlib_filefunc64_32_def_fill.ztell32_file = NULL; + zlib_filefunc64_32_def_fill.zseek32_file = NULL; + return zipOpen4(pathname, append, disk_size, globalcomment, &zlib_filefunc64_32_def_fill); + } + return zipOpen4(pathname, append, disk_size, globalcomment, NULL); +} + +extern zipFile ZEXPORT zipOpen(const char *pathname, int append) +{ + return zipOpen3((const void *)pathname, append, 0, NULL, NULL); +} + +extern zipFile ZEXPORT zipOpen64(const void *pathname, int append) +{ + return zipOpen3(pathname, append, 0, NULL, NULL); +} + +extern int ZEXPORT zipOpenNewFileInZip4_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uInt size_extrafield_local, const void *extrafield_global, + uInt size_extrafield_global, const char *comment, int method, int level, int raw, int windowBits, int memLevel, + int strategy, const char *password, uLong crcForCrypting, uLong versionMadeBy, uLong flagBase, int zip64) +{ + zip64_internal *zi; + uInt size_filename; + uInt size_comment = 0; + uInt i; + int err = ZIP_OK; + ZPOS64_T size_available; + ZPOS64_T size_needed; + +#ifdef NOCRYPT + (crcForCrypting); + if (password != NULL) + return ZIP_PARAMERROR; +#endif + + if (file == NULL) + return ZIP_PARAMERROR; + + if ((method != 0) && +#ifdef HAVE_BZIP2 + (method != Z_BZIP2ED) && +#endif + (method != Z_DEFLATED)) + return ZIP_PARAMERROR; + + zi = (zip64_internal *)file; + + if (zi->in_opened_file_inzip == 1) { + err = zipCloseFileInZip(file); + if (err != ZIP_OK) + return err; + } + + if (filename == NULL) + filename = "-"; + if (comment != NULL) + size_comment = (uInt)strlen(comment); + + size_filename = (uInt)strlen(filename); + + if (zipfi == NULL) + zi->ci.dosDate = 0; + else { + if (zipfi->dosDate != 0) + zi->ci.dosDate = zipfi->dosDate; + else + zi->ci.dosDate = zip64local_TmzDateToDosDate(&zipfi->tmz_date); + } + + zi->ci.method = method; + zi->ci.compression_method = method; + zi->ci.crc32 = 0; + zi->ci.stream_initialised = 0; + zi->ci.pos_in_buffered_data = 0; + zi->ci.raw = raw; + zi->ci.flag = flagBase; + if ((level == 8) || (level == 9)) + zi->ci.flag |= 2; + if (level == 2) + zi->ci.flag |= 4; + if (level == 1) + zi->ci.flag |= 6; + if (password != NULL) { + zi->ci.flag |= 1; +#ifdef HAVE_AES + zi->ci.method = AES_METHOD; +#endif + } + + if (zi->disk_size > 0) { + if ((zi->number_disk == 0) && (zi->number_entry == 0)) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)DISKHEADERMAGIC, 4); + + /* Make sure enough space available on current disk for local header */ + zipGetDiskSizeAvailable((zipFile)zi, &size_available); + size_needed = 30 + size_filename + size_extrafield_local; + if (zi->ci.zip64) + size_needed += 20; +#ifdef HAVE_AES + if (zi->ci.method == AES_METHOD) + size_needed += 11; +#endif + if (size_available < size_needed) + zipGoToNextDisk((zipFile)zi); + } + + zi->ci.pos_local_header = ZTELL64(zi->z_filefunc, zi->filestream); + zi->ci.size_comment = size_comment; + zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + size_extrafield_global; + zi->ci.size_centralextra = size_extrafield_global; + zi->ci.size_centralextrafree = 32; /* Extra space reserved for ZIP64 extra info */ +#ifdef HAVE_AES + if (zi->ci.method == AES_METHOD) + zi->ci.size_centralextrafree += 11; /* Extra space reserved for AES extra info */ +#endif + zi->ci.central_header = (char *)ALLOC((uInt)zi->ci.size_centralheader + zi->ci.size_centralextrafree + size_comment); + if (zi->ci.central_header == NULL) + return ZIP_INTERNALERROR; + + zi->ci.number_disk = zi->number_disk; + + /* Write central directory header */ + zip64local_putValue_inmemory(zi->ci.central_header, (uLong)CENTRALHEADERMAGIC, 4); + zip64local_putValue_inmemory(zi->ci.central_header + 4, (uLong)versionMadeBy, 2); + zip64local_putValue_inmemory(zi->ci.central_header + 6, (uLong)20, 2); + zip64local_putValue_inmemory(zi->ci.central_header + 8, (uLong)zi->ci.flag, 2); + zip64local_putValue_inmemory(zi->ci.central_header + 10, (uLong)zi->ci.method, 2); + zip64local_putValue_inmemory(zi->ci.central_header + 12, (uLong)zi->ci.dosDate, 4); + zip64local_putValue_inmemory(zi->ci.central_header + 16, (uLong)0, 4); /*crc*/ + zip64local_putValue_inmemory(zi->ci.central_header + 20, (uLong)0, 4); /*compr size*/ + zip64local_putValue_inmemory(zi->ci.central_header + 24, (uLong)0, 4); /*uncompr size*/ + zip64local_putValue_inmemory(zi->ci.central_header + 28, (uLong)size_filename, 2); + zip64local_putValue_inmemory(zi->ci.central_header + 30, (uLong)size_extrafield_global, 2); + zip64local_putValue_inmemory(zi->ci.central_header + 32, (uLong)size_comment, 2); + zip64local_putValue_inmemory(zi->ci.central_header + 34, (uLong)zi->ci.number_disk, 2); /*disk nm start*/ + + if (zipfi == NULL) + zip64local_putValue_inmemory(zi->ci.central_header + 36, (uLong)0, 2); + else + zip64local_putValue_inmemory(zi->ci.central_header + 36, (uLong)zipfi->internal_fa, 2); + if (zipfi == NULL) + zip64local_putValue_inmemory(zi->ci.central_header + 38, (uLong)0, 4); + else + zip64local_putValue_inmemory(zi->ci.central_header + 38, (uLong)zipfi->external_fa, 4); + if (zi->ci.pos_local_header >= 0xffffffff) + zip64local_putValue_inmemory(zi->ci.central_header + 42, (uLong)0xffffffff, 4); + else + zip64local_putValue_inmemory(zi->ci.central_header + 42, + (uLong)zi->ci.pos_local_header - zi->add_position_when_writting_offset, 4); + + for (i = 0; i < size_filename; i++) + zi->ci.central_header[SIZECENTRALHEADER + i] = filename[i]; + for (i = 0; i < size_extrafield_global; i++) + zi->ci.central_header[SIZECENTRALHEADER + size_filename + i] = + ((const char *)extrafield_global)[i]; + /* Store comment at the end for later repositioning */ + for (i = 0; i < size_comment; i++) + zi->ci.central_header[zi->ci.size_centralheader + + zi->ci.size_centralextrafree + i] = comment[i]; + + if (zi->ci.central_header == NULL) + return ZIP_INTERNALERROR; + + zi->ci.zip64 = zip64; + zi->ci.total_compressed = 0; + zi->ci.total_uncompressed = 0; + zi->ci.pos_zip64extrainfo = 0; + + /* Write the local header */ + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)LOCALHEADERMAGIC, 4); + + if (err == ZIP_OK) { + if (zi->ci.zip64) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)45, 2); /* version needed to extract */ + else + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)20, 2); /* version needed to extract */ + } + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->ci.flag, 2); + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->ci.method, 2); + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->ci.dosDate, 4); + + /* CRC & compressed size & uncompressed size will be filled in later and rewritten later */ + + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)0, 4); /* crc 32, unknown */ + if (err == ZIP_OK) { + if (zi->ci.zip64) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)0xFFFFFFFF, 4); /* compressed size, unknown */ + else + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)0, 4); /* compressed size, unknown */ + } + if (err == ZIP_OK) { + if (zi->ci.zip64) /* uncompressed size, unknown */ + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)0xFFFFFFFF, 4); + else /* uncompressed size, unknown */ + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)0, 4); + } + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)size_filename, 2); + if (err == ZIP_OK) { + ZPOS64_T size_extrafield = size_extrafield_local; + if (zi->ci.zip64) + size_extrafield += 20; +#ifdef HAVE_AES + if (zi->ci.method == AES_METHOD) + size_extrafield += 11; +#endif + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)size_extrafield, 2); + } + if ((err == ZIP_OK) && (size_filename > 0)) { + if (ZWRITE64(zi->z_filefunc, zi->filestream, filename, size_filename) != size_filename) + err = ZIP_ERRNO; + } + if ((err == ZIP_OK) && (size_extrafield_local > 0)) { + if (ZWRITE64(zi->z_filefunc, zi->filestream, extrafield_local, size_extrafield_local) != size_extrafield_local) + err = ZIP_ERRNO; + } + + /* Write the Zip64 extended info */ + if ((err == ZIP_OK) && (zi->ci.zip64)) { + short headerid = 1; + short datasize = 16; + ZPOS64_T compressed_size = 0; + ZPOS64_T uncompressed_size = 0; + + /* Remember position of Zip64 extended info for the local file header. + (needed when we update size after done with file) */ + zi->ci.pos_zip64extrainfo = ZTELL64(zi->z_filefunc, zi->filestream); + + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)headerid, 2); + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)datasize, 2); + + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)uncompressed_size, 8); + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)compressed_size, 8); + } +#ifdef HAVE_AES + /* Write the AES extended info */ + if ((err == ZIP_OK) && (zi->ci.method == AES_METHOD)) { + int headerid = 0x9901; + short datasize = 7; + + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, headerid, 2); + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, datasize, 2); + + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, AES_VERSION, 2); + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, 'A', 1); + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, 'E', 1); + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, AES_ENCRYPTIONMODE, 1); + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->ci.compression_method, 2); + } +#endif + +#ifdef HAVE_BZIP2 + zi->ci.bstream.avail_in = (uInt)0; + zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE; + zi->ci.bstream.next_out = (char *)zi->ci.buffered_data; + zi->ci.bstream.total_in_hi32 = 0; + zi->ci.bstream.total_in_lo32 = 0; + zi->ci.bstream.total_out_hi32 = 0; + zi->ci.bstream.total_out_lo32 = 0; +#endif + + zi->ci.stream.avail_in = (uInt)0; + zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; + zi->ci.stream.next_out = zi->ci.buffered_data; + zi->ci.stream.total_in = 0; + zi->ci.stream.total_out = 0; + zi->ci.stream.data_type = Z_BINARY; + + if ((err == ZIP_OK) && (!zi->ci.raw)) { + if (method == Z_DEFLATED) { + zi->ci.stream.zalloc = (alloc_func)0; + zi->ci.stream.zfree = (free_func)0; + zi->ci.stream.opaque = (voidpf)zi; + + if (windowBits > 0) + windowBits = -windowBits; + + err = deflateInit2(&zi->ci.stream, level, Z_DEFLATED, windowBits, memLevel, strategy); + + if (err == Z_OK) + zi->ci.stream_initialised = Z_DEFLATED; + } else if (method == Z_BZIP2ED) { +#ifdef HAVE_BZIP2 + zi->ci.bstream.bzalloc = 0; + zi->ci.bstream.bzfree = 0; + zi->ci.bstream.opaque = (voidpf)0; + + err = BZ2_bzCompressInit(&zi->ci.bstream, level, 0, 35); + if (err == BZ_OK) + zi->ci.stream_initialised = Z_BZIP2ED; +#endif + } + } + +#ifndef NOCRYPT + zi->ci.crypt_header_size = 0; + if ((err == Z_OK) && ((zi->ci.flag & 1) != 0)) { +#ifdef HAVE_AES + if (zi->ci.method == AES_METHOD) { + unsigned char passverify[AES_PWVERIFYSIZE]; + unsigned char saltvalue[AES_MAXSALTLENGTH]; + uInt saltlength; + + if ((AES_ENCRYPTIONMODE < 1) || (AES_ENCRYPTIONMODE > 3)) + return Z_ERRNO; + + saltlength = SALT_LENGTH(AES_ENCRYPTIONMODE); + + prng_init(entropy_fun, zi->ci.aes_rng); + prng_rand(saltvalue, saltlength, zi->ci.aes_rng); + prng_end(zi->ci.aes_rng); + + fcrypt_init(AES_ENCRYPTIONMODE, (unsigned char *)password, (unsigned int)strlen(password), saltvalue, passverify, &zi->ci.aes_ctx); + + if (ZWRITE64(zi->z_filefunc, zi->filestream, saltvalue, saltlength) != saltlength) + err = ZIP_ERRNO; + if (ZWRITE64(zi->z_filefunc, zi->filestream, passverify, AES_PWVERIFYSIZE) != AES_PWVERIFYSIZE) + err = ZIP_ERRNO; + + zi->ci.crypt_header_size = saltlength + AES_PWVERIFYSIZE + AES_AUTHCODESIZE; + } else +#endif + { + unsigned char bufHead[RAND_HEAD_LEN]; + unsigned int sizeHead; + + zi->ci.pcrc_32_tab = (const unsigned long *)get_crc_table(); + /*init_keys(password, zi->ci.keys, zi->ci.pcrc_32_tab);*/ + + sizeHead = crypthead(password, bufHead, RAND_HEAD_LEN, zi->ci.keys, zi->ci.pcrc_32_tab, crcForCrypting); + zi->ci.crypt_header_size = sizeHead; + + if (ZWRITE64(zi->z_filefunc, zi->filestream, bufHead, sizeHead) != sizeHead) + err = ZIP_ERRNO; + } + } +#endif + + if (err == Z_OK) + zi->in_opened_file_inzip = 1; + return err; +} + +extern int ZEXPORT zipOpenNewFileInZip4(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uInt size_extrafield_local, const void *extrafield_global, + uInt size_extrafield_global, const char *comment, int method, int level, int raw, int windowBits, + int memLevel, int strategy, const char *password, uLong crcForCrypting, uLong versionMadeBy, uLong flagBase) +{ + return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, comment, method, level, raw, windowBits, memLevel, + strategy, password, crcForCrypting, versionMadeBy, flagBase, 0); +} + +extern int ZEXPORT zipOpenNewFileInZip3(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uInt size_extrafield_local, const void *extrafield_global, + uInt size_extrafield_global, const char *comment, int method, int level, int raw, int windowBits, + int memLevel, int strategy, const char *password, uLong crcForCrypting) +{ + return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, comment, method, level, raw, windowBits, memLevel, + strategy, password, crcForCrypting, VERSIONMADEBY, 0, 0); +} + +extern int ZEXPORT zipOpenNewFileInZip3_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uInt size_extrafield_local, const void *extrafield_global, + uInt size_extrafield_global, const char *comment, int method, int level, int raw, int windowBits, + int memLevel, int strategy, const char *password, uLong crcForCrypting, int zip64) +{ + return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, comment, method, level, raw, windowBits, memLevel, strategy, + password, crcForCrypting, VERSIONMADEBY, 0, zip64); +} + +extern int ZEXPORT zipOpenNewFileInZip2(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uInt size_extrafield_local, const void *extrafield_global, + uInt size_extrafield_global, const char *comment, int method, int level, int raw) +{ + return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, comment, method, level, raw, -MAX_WBITS, DEF_MEM_LEVEL, + Z_DEFAULT_STRATEGY, NULL, 0, VERSIONMADEBY, 0, 0); +} + +extern int ZEXPORT zipOpenNewFileInZip2_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uInt size_extrafield_local, const void *extrafield_global, + uInt size_extrafield_global, const char *comment, int method, int level, int raw, int zip64) +{ + return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, comment, method, level, raw, -MAX_WBITS, DEF_MEM_LEVEL, + Z_DEFAULT_STRATEGY, NULL, 0, VERSIONMADEBY, 0, zip64); +} + +extern int ZEXPORT zipOpenNewFileInZip64(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uInt size_extrafield_local, const void *extrafield_global, + uInt size_extrafield_global, const char *comment, int method, int level, int zip64) +{ + return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, comment, method, level, 0, -MAX_WBITS, DEF_MEM_LEVEL, + Z_DEFAULT_STRATEGY, NULL, 0, VERSIONMADEBY, 0, zip64); +} + +extern int ZEXPORT zipOpenNewFileInZip(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uInt size_extrafield_local, const void *extrafield_global, + uInt size_extrafield_global, const char *comment, int method, int level) +{ + return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, comment, method, level, 0, -MAX_WBITS, DEF_MEM_LEVEL, + Z_DEFAULT_STRATEGY, NULL, 0, VERSIONMADEBY, 0, 0); +} + +/* Flushes the write buffer to disk */ +local int zip64FlushWriteBuffer OF((zip64_internal * zi)); +local int zip64FlushWriteBuffer(zip64_internal *zi) +{ + int err = ZIP_OK; + uInt written = 0; + uInt total_written = 0; + uInt write = 0; + uInt max_write = 0; + ZPOS64_T size_available = 0; + + if ((zi->ci.flag & 1) != 0) { +#ifndef NOCRYPT +#ifdef HAVE_AES + if (zi->ci.method == AES_METHOD) { + fcrypt_encrypt(zi->ci.buffered_data, zi->ci.pos_in_buffered_data, &zi->ci.aes_ctx); + } else +#endif + { + uInt i; + int t; + for (i = 0; i < zi->ci.pos_in_buffered_data; i++) + zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, zi->ci.buffered_data[i], t); + } +#endif + } + + write = zi->ci.pos_in_buffered_data; + + do { + max_write = write; + + if (zi->disk_size > 0) { + err = zipGetDiskSizeAvailable((zipFile)zi, &size_available); + if (err != ZIP_OK) + return err; + + if (size_available == 0) { + err = zipGoToNextDisk((zipFile)zi); + if (err != ZIP_OK) + return err; + } + + if (size_available < (ZPOS64_T)max_write) + max_write = (uInt)size_available; + } + + written = (unsigned int)ZWRITE64(zi->z_filefunc, zi->filestream, zi->ci.buffered_data + total_written, max_write); + + if (ZERROR64(zi->z_filefunc, zi->filestream)) { + err = ZIP_ERRNO; + break; + } + + total_written += written; + write -= written; + } while (write > 0); + + zi->ci.total_compressed += zi->ci.pos_in_buffered_data; + +#ifdef HAVE_BZIP2 + if (zi->ci.compression_method == Z_BZIP2ED) { + zi->ci.total_uncompressed += zi->ci.bstream.total_in_lo32; + zi->ci.bstream.total_in_lo32 = 0; + zi->ci.bstream.total_in_hi32 = 0; + } else +#endif + { + zi->ci.total_uncompressed += zi->ci.stream.total_in; + zi->ci.stream.total_in = 0; + } + + zi->ci.pos_in_buffered_data = 0; + + return err; +} + +extern int ZEXPORT zipWriteInFileInZip(zipFile file, const void *buf, unsigned int len) +{ + zip64_internal *zi; + int err = ZIP_OK; + + if (file == NULL) + return ZIP_PARAMERROR; + zi = (zip64_internal *)file; + + if (zi->in_opened_file_inzip == 0) + return ZIP_PARAMERROR; + + zi->ci.crc32 = crc32(zi->ci.crc32, buf, (uInt)len); + +#ifdef HAVE_BZIP2 + if ((zi->ci.compression_method == Z_BZIP2ED) && (!zi->ci.raw)) { + zi->ci.bstream.next_in = (void *)buf; + zi->ci.bstream.avail_in = len; + err = BZ_RUN_OK; + + while ((err == BZ_RUN_OK) && (zi->ci.bstream.avail_in > 0)) { + if (zi->ci.bstream.avail_out == 0) { + if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) + err = ZIP_ERRNO; + zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE; + zi->ci.bstream.next_out = (char *)zi->ci.buffered_data; + } else { + uLong uTotalOutBefore_lo = zi->ci.bstream.total_out_lo32; + uLong uTotalOutBefore_hi = zi->ci.bstream.total_out_hi32; + + err = BZ2_bzCompress(&zi->ci.bstream, BZ_RUN); + + zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore_lo); + } + } + + if (err == BZ_RUN_OK) + err = ZIP_OK; + } else +#endif + { + zi->ci.stream.next_in = (Bytef *)buf; + zi->ci.stream.avail_in = len; + + while ((err == ZIP_OK) && (zi->ci.stream.avail_in > 0)) { + if (zi->ci.stream.avail_out == 0) { + if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) + err = ZIP_ERRNO; + zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; + zi->ci.stream.next_out = zi->ci.buffered_data; + } + + if (err != ZIP_OK) + break; + + if ((zi->ci.compression_method == Z_DEFLATED) && (!zi->ci.raw)) { + uLong total_out_before = zi->ci.stream.total_out; + err = deflate(&zi->ci.stream, Z_NO_FLUSH); + zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - total_out_before); + } else { + uInt copy_this, i; + if (zi->ci.stream.avail_in < zi->ci.stream.avail_out) + copy_this = zi->ci.stream.avail_in; + else + copy_this = zi->ci.stream.avail_out; + + for (i = 0; i < copy_this; i++) + *(((char *)zi->ci.stream.next_out) + i) = + *(((const char *)zi->ci.stream.next_in) + i); + + zi->ci.stream.avail_in -= copy_this; + zi->ci.stream.avail_out -= copy_this; + zi->ci.stream.next_in += copy_this; + zi->ci.stream.next_out += copy_this; + zi->ci.stream.total_in += copy_this; + zi->ci.stream.total_out += copy_this; + zi->ci.pos_in_buffered_data += copy_this; + } + } + } + + return err; +} + +extern int ZEXPORT zipCloseFileInZipRaw(zipFile file, uLong uncompressed_size, uLong crc32) +{ + return zipCloseFileInZipRaw64(file, uncompressed_size, crc32); +} + +extern int ZEXPORT zipCloseFileInZipRaw64(zipFile file, ZPOS64_T uncompressed_size, uLong crc32) +{ + zip64_internal *zi; + ZPOS64_T compressed_size; + uLong invalidValue = 0xffffffff; + uLong i = 0; + short datasize = 0; + int err = ZIP_OK; + + if (file == NULL) + return ZIP_PARAMERROR; + zi = (zip64_internal *)file; + + if (zi->in_opened_file_inzip == 0) + return ZIP_PARAMERROR; + zi->ci.stream.avail_in = 0; + + if (!zi->ci.raw) { + if (zi->ci.compression_method == Z_DEFLATED) { + while (err == ZIP_OK) { + uLong total_out_before; + if (zi->ci.stream.avail_out == 0) { + if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) + err = ZIP_ERRNO; + zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; + zi->ci.stream.next_out = zi->ci.buffered_data; + } + total_out_before = zi->ci.stream.total_out; + err = deflate(&zi->ci.stream, Z_FINISH); + zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - total_out_before); + } + } else if (zi->ci.compression_method == Z_BZIP2ED) { +#ifdef HAVE_BZIP2 + err = BZ_FINISH_OK; + while (err == BZ_FINISH_OK) { + uLong total_out_before; + if (zi->ci.bstream.avail_out == 0) { + if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) + err = ZIP_ERRNO; + zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE; + zi->ci.bstream.next_out = (char *)zi->ci.buffered_data; + } + total_out_before = zi->ci.bstream.total_out_lo32; + err = BZ2_bzCompress(&zi->ci.bstream, BZ_FINISH); + if (err == BZ_STREAM_END) + err = Z_STREAM_END; + zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - total_out_before); + } + + if (err == BZ_FINISH_OK) + err = ZIP_OK; +#endif + } + } + + if (err == Z_STREAM_END) + err = ZIP_OK; /* this is normal */ + + if ((zi->ci.pos_in_buffered_data > 0) && (err == ZIP_OK)) { + if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) + err = ZIP_ERRNO; + } + +#ifdef HAVE_AES + if (zi->ci.method == AES_METHOD) { + unsigned char authcode[AES_AUTHCODESIZE]; + + fcrypt_end(authcode, &zi->ci.aes_ctx); + + if (ZWRITE64(zi->z_filefunc, zi->filestream, authcode, AES_AUTHCODESIZE) != AES_AUTHCODESIZE) + err = ZIP_ERRNO; + } +#endif + + if (!zi->ci.raw) { + if (zi->ci.compression_method == Z_DEFLATED) { + int tmp_err = deflateEnd(&zi->ci.stream); + if (err == ZIP_OK) + err = tmp_err; + zi->ci.stream_initialised = 0; + } +#ifdef HAVE_BZIP2 + else if (zi->ci.compression_method == Z_BZIP2ED) { + int tmperr = BZ2_bzCompressEnd(&zi->ci.bstream); + if (err == ZIP_OK) + err = tmperr; + zi->ci.stream_initialised = 0; + } +#endif + + crc32 = (uLong)zi->ci.crc32; + uncompressed_size = zi->ci.total_uncompressed; + } + + compressed_size = zi->ci.total_compressed; +#ifndef NOCRYPT + compressed_size += zi->ci.crypt_header_size; +#endif + + /* Update current item crc and sizes */ + if (compressed_size >= 0xffffffff || uncompressed_size >= 0xffffffff || zi->ci.pos_local_header >= 0xffffffff) { + zip64local_putValue_inmemory(zi->ci.central_header + 4, (uLong)45, 2); /* version made by */ + zip64local_putValue_inmemory(zi->ci.central_header + 6, (uLong)45, 2); /* version needed */ + } + zip64local_putValue_inmemory(zi->ci.central_header + 16, crc32, 4); /* crc */ + if (compressed_size >= 0xffffffff) + zip64local_putValue_inmemory(zi->ci.central_header + 20, invalidValue, 4); /* compr size */ + else + zip64local_putValue_inmemory(zi->ci.central_header + 20, compressed_size, 4); /* compr size */ + if (zi->ci.stream.data_type == Z_ASCII) + zip64local_putValue_inmemory(zi->ci.central_header + 36, (uLong)Z_ASCII, 2); /* internal file attrib */ + if (uncompressed_size >= 0xffffffff) + zip64local_putValue_inmemory(zi->ci.central_header + 24, invalidValue, 4); /* uncompr size */ + else + zip64local_putValue_inmemory(zi->ci.central_header + 24, uncompressed_size, 4); /* uncompr size */ + + /* Add ZIP64 extra info field for uncompressed size */ + if (uncompressed_size >= 0xffffffff) + datasize += 8; + /* Add ZIP64 extra info field for compressed size */ + if (compressed_size >= 0xffffffff) + datasize += 8; + /* Add ZIP64 extra info field for relative offset to local file header of current file */ + if (zi->ci.pos_local_header >= 0xffffffff) + datasize += 8; + + /* Add Extra Information Header for 'ZIP64 information' */ + if (datasize > 0) { + char *p = zi->ci.central_header + zi->ci.size_centralheader; + + if ((uLong)(datasize + 4) > zi->ci.size_centralextrafree) + return ZIP_BADZIPFILE; + + zip64local_putValue_inmemory(p, 0x0001, 2); + p += 2; + zip64local_putValue_inmemory(p, datasize, 2); + p += 2; + + if (uncompressed_size >= 0xffffffff) { + zip64local_putValue_inmemory(p, uncompressed_size, 8); + p += 8; + } + if (compressed_size >= 0xffffffff) { + zip64local_putValue_inmemory(p, compressed_size, 8); + p += 8; + } + if (zi->ci.pos_local_header >= 0xffffffff) { + zip64local_putValue_inmemory(p, zi->ci.pos_local_header, 8); + p += 8; + } + + zi->ci.size_centralextrafree -= datasize + 4; + zi->ci.size_centralheader += datasize + 4; + zi->ci.size_centralextra += datasize + 4; + + zip64local_putValue_inmemory(zi->ci.central_header + 30, (uLong)zi->ci.size_centralextra, 2); + } + +#ifdef HAVE_AES + /* Write the AES extended info */ + if (zi->ci.method == AES_METHOD) { + char *p = zi->ci.central_header + zi->ci.size_centralheader; + + datasize = 7; + + if ((uLong)(datasize + 4) > zi->ci.size_centralextrafree) + return ZIP_BADZIPFILE; + + zip64local_putValue_inmemory(p, 0x9901, 2); + p += 2; + zip64local_putValue_inmemory(p, datasize, 2); + p += 2; + zip64local_putValue_inmemory(p, AES_VERSION, 2); + p += 2; + zip64local_putValue_inmemory(p, 'A', 1); + p += 1; + zip64local_putValue_inmemory(p, 'E', 1); + p += 1; + zip64local_putValue_inmemory(p, AES_ENCRYPTIONMODE, 1); + p += 1; + zip64local_putValue_inmemory(p, zi->ci.compression_method, 2); + p += 2; + + zi->ci.size_centralextrafree -= datasize + 4; + zi->ci.size_centralheader += datasize + 4; + zi->ci.size_centralextra += datasize + 4; + + zip64local_putValue_inmemory(zi->ci.central_header + 30, (uLong)zi->ci.size_centralextra, 2); + } +#endif + /* Restore comment to correct position */ + for (i = 0; i < zi->ci.size_comment; i++) + zi->ci.central_header[zi->ci.size_centralheader + i] = + zi->ci.central_header[zi->ci.size_centralheader + zi->ci.size_centralextrafree + i]; + zi->ci.size_centralheader += zi->ci.size_comment; + + if (err == ZIP_OK) + err = add_data_in_datablock(&zi->central_dir, zi->ci.central_header, (uLong)zi->ci.size_centralheader); + + free(zi->ci.central_header); + + if (err == ZIP_OK) { + /* Update the LocalFileHeader with the new values. */ + ZPOS64_T cur_pos_inzip = ZTELL64(zi->z_filefunc, zi->filestream); + uLong cur_number_disk = zi->number_disk; + + /* Local file header is stored on previous disk, switch to make edits */ + if (zi->ci.number_disk != cur_number_disk) + err = zipGoToSpecificDisk(file, (int)zi->ci.number_disk, 1); + + if (ZSEEK64(zi->z_filefunc, zi->filestream, zi->ci.pos_local_header + 14, ZLIB_FILEFUNC_SEEK_SET) != 0) + err = ZIP_ERRNO; + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, crc32, 4); /* crc 32, unknown */ + + if (uncompressed_size >= 0xffffffff || compressed_size >= 0xffffffff) { + if (zi->ci.pos_zip64extrainfo > 0) { + /* Update the size in the ZIP64 extended field. */ + if (ZSEEK64(zi->z_filefunc, zi->filestream, zi->ci.pos_zip64extrainfo + 4, ZLIB_FILEFUNC_SEEK_SET) != 0) + err = ZIP_ERRNO; + + if (err == ZIP_OK) /* compressed size, unknown */ + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, uncompressed_size, 8); + if (err == ZIP_OK) /* uncompressed size, unknown */ + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, compressed_size, 8); + } else + err = ZIP_BADZIPFILE; /* Caller passed zip64 = 0, so no room for zip64 info -> fatal */ + } else { + if (err == ZIP_OK) /* compressed size, unknown */ + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, compressed_size, 4); + if (err == ZIP_OK) /* uncompressed size, unknown */ + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, uncompressed_size, 4); + } + + /* Now switch back again to the disk we were on before */ + if (zi->ci.number_disk != cur_number_disk) + err = zipGoToSpecificDisk(file, (int)cur_number_disk, 1); + + if (ZSEEK64(zi->z_filefunc, zi->filestream, cur_pos_inzip, ZLIB_FILEFUNC_SEEK_SET) != 0) + err = ZIP_ERRNO; + } + + zi->number_entry++; + zi->in_opened_file_inzip = 0; + + return err; +} + +extern int ZEXPORT zipCloseFileInZip(zipFile file) +{ + return zipCloseFileInZipRaw(file, 0, 0); +} + +extern int ZEXPORT zipClose(zipFile file, const char *global_comment) +{ + zip64_internal *zi; + int err = 0; + uLong size_centraldir = 0; + uInt size_global_comment = 0; + ZPOS64_T centraldir_pos_inzip; + ZPOS64_T pos = 0; + uLong write = 0; + + if (file == NULL) + return ZIP_PARAMERROR; + + zi = (zip64_internal *)file; + + if (zi->in_opened_file_inzip == 1) + err = zipCloseFileInZip(file); + +#ifndef NO_ADDFILEINEXISTINGZIP + if (global_comment == NULL) + global_comment = zi->globalcomment; +#endif + + if (zi->filestream != zi->filestream_with_CD) { + if (ZCLOSE64(zi->z_filefunc, zi->filestream) != 0) + if (err == ZIP_OK) + err = ZIP_ERRNO; + if (zi->disk_size > 0) + zi->number_disk_with_CD = zi->number_disk + 1; + zi->filestream = zi->filestream_with_CD; + } + + centraldir_pos_inzip = ZTELL64(zi->z_filefunc, zi->filestream); + + if (err == ZIP_OK) { + linkedlist_datablock_internal *ldi = zi->central_dir.first_block; + while (ldi != NULL) { + if ((err == ZIP_OK) && (ldi->filled_in_this_block > 0)) { + write = ZWRITE64(zi->z_filefunc, zi->filestream, ldi->data, ldi->filled_in_this_block); + if (write != ldi->filled_in_this_block) + err = ZIP_ERRNO; + } + + size_centraldir += ldi->filled_in_this_block; + ldi = ldi->next_datablock; + } + } + + free_linkedlist(&(zi->central_dir)); + + pos = centraldir_pos_inzip - zi->add_position_when_writting_offset; + + /* Write the ZIP64 central directory header */ + if (pos >= 0xffffffff || zi->number_entry > 0xffff) { + ZPOS64_T zip64eocd_pos_inzip = ZTELL64(zi->z_filefunc, zi->filestream); + uLong zip64datasize = 44; + + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)ZIP64ENDHEADERMAGIC, 4); + + /* size of this 'zip64 end of central directory' */ + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)zip64datasize, 8); + /* version made by */ + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)45, 2); + /* version needed */ + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)45, 2); + /* number of this disk */ + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->number_disk_with_CD, 4); + /* number of the disk with the start of the central directory */ + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->number_disk_with_CD, 4); + /* total number of entries in the central dir on this disk */ + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8); + /* total number of entries in the central dir */ + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8); + /* size of the central directory */ + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)size_centraldir, 8); + + if (err == ZIP_OK) { + /* offset of start of central directory with respect to the starting disk number */ + ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writting_offset; + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)pos, 8); + } + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)ZIP64ENDLOCHEADERMAGIC, 4); + + /* number of the disk with the start of the central directory */ + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->number_disk_with_CD, 4); + /*relative offset to the Zip64EndOfCentralDirectory */ + if (err == ZIP_OK) { + ZPOS64_T pos = zip64eocd_pos_inzip - zi->add_position_when_writting_offset; + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, pos, 8); + } + /* number of the disk with the start of the central directory */ + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->number_disk_with_CD + 1, 4); + } + + /* Write the central directory header */ + + /* signature */ + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)ENDHEADERMAGIC, 4); + /* number of this disk */ + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->number_disk_with_CD, 2); + /* number of the disk with the start of the central directory */ + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->number_disk_with_CD, 2); + /* total number of entries in the central dir on this disk */ + if (err == ZIP_OK) { + if (zi->number_entry >= 0xffff) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)0xffff, 2); /* use value in ZIP64 record */ + else + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->number_entry, 2); + } + /* total number of entries in the central dir */ + if (err == ZIP_OK) { + if (zi->number_entry >= 0xffff) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)0xffff, 2); /* use value in ZIP64 record */ + else + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->number_entry, 2); + } + /* size of the central directory */ + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)size_centraldir, 4); + /* offset of start of central directory with respect to the starting disk number */ + if (err == ZIP_OK) { + ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writting_offset; + if (pos >= 0xffffffff) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)0xffffffff, 4); + else + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)pos, 4); + } + + /* Write global comment */ + + if (global_comment != NULL) + size_global_comment = (uInt)strlen(global_comment); + if (err == ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)size_global_comment, 2); + if (err == ZIP_OK && size_global_comment > 0) { + if (ZWRITE64(zi->z_filefunc, zi->filestream, global_comment, size_global_comment) != size_global_comment) + err = ZIP_ERRNO; + } + + if ((ZCLOSE64(zi->z_filefunc, zi->filestream) != 0) && (err == ZIP_OK)) + err = ZIP_ERRNO; + +#ifndef NO_ADDFILEINEXISTINGZIP + TRYFREE(zi->globalcomment); +#endif + TRYFREE(zi); + + return err; +} + diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/zip.h b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/zip.h new file mode 100755 index 0000000..10bbf26 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/External Libraries/SSZipArchive/minizip/zip.h @@ -0,0 +1,202 @@ +/* zip.h -- IO on .zip files using zlib + Version 1.1, February 14h, 2010 + part of the MiniZip project + + Copyright (C) 1998-2010 Gilles Vollant + http://www.winimage.com/zLibDll/minizip.html + Modifications for Zip64 support + Copyright (C) 2009-2010 Mathias Svensson + http://result42.com + + This program is distributed under the terms of the same license as zlib. + See the accompanying LICENSE file for the full text of the license. +*/ + +#ifndef _ZIP_H +#define _ZIP_H + +#define HAVE_AES + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _ZLIB_H +# include "zlib.h" +#endif + +#ifndef _ZLIBIOAPI_H +# include "ioapi.h" +#endif + +#ifdef HAVE_BZIP2 +# include "bzlib.h" +#endif + +#define Z_BZIP2ED 12 + +#if defined(STRICTZIP) || defined(STRICTZIPUNZIP) +/* like the STRICT of WIN32, we define a pointer that cannot be converted + from (void*) without cast */ +typedef struct TagzipFile__ { int unused; } zipFile__; +typedef zipFile__ *zipFile; +#else +typedef voidp zipFile; +#endif + +#define ZIP_OK (0) +#define ZIP_EOF (0) +#define ZIP_ERRNO (Z_ERRNO) +#define ZIP_PARAMERROR (-102) +#define ZIP_BADZIPFILE (-103) +#define ZIP_INTERNALERROR (-104) + +#ifndef DEF_MEM_LEVEL +# if MAX_MEM_LEVEL >= 8 +# define DEF_MEM_LEVEL 8 +# else +# define DEF_MEM_LEVEL MAX_MEM_LEVEL +# endif +#endif +/* default memLevel */ + +/* tm_zip contain date/time info */ +typedef struct tm_zip_s +{ + uInt tm_sec; /* seconds after the minute - [0,59] */ + uInt tm_min; /* minutes after the hour - [0,59] */ + uInt tm_hour; /* hours since midnight - [0,23] */ + uInt tm_mday; /* day of the month - [1,31] */ + uInt tm_mon; /* months since January - [0,11] */ + uInt tm_year; /* years - [1980..2044] */ +} tm_zip; + +typedef struct +{ + tm_zip tmz_date; /* date in understandable format */ + uLong dosDate; /* if dos_date == 0, tmu_date is used */ + uLong internal_fa; /* internal file attributes 2 bytes */ + uLong external_fa; /* external file attributes 4 bytes */ +} zip_fileinfo; + +typedef const char* zipcharpc; + +#define APPEND_STATUS_CREATE (0) +#define APPEND_STATUS_CREATEAFTER (1) +#define APPEND_STATUS_ADDINZIP (2) + +/***************************************************************************/ +/* Writing a zip file */ + +extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append)); +extern zipFile ZEXPORT zipOpen64 OF((const void *pathname, int append)); +/* Create a zipfile. + + pathname should contain the full pathname (by example, on a Windows XP computer + "c:\\zlib\\zlib113.zip" or on an Unix computer "zlib/zlib113.zip". + + return NULL if zipfile cannot be opened + return zipFile handle if no error + + If the file pathname exist and append == APPEND_STATUS_CREATEAFTER, the zip + will be created at the end of the file. (useful if the file contain a self extractor code) + If the file pathname exist and append == APPEND_STATUS_ADDINZIP, we will add files in existing + zip (be sure you don't add file that doesn't exist) + + NOTE: There is no delete function into a zipfile. If you want delete file into a zipfile, + you must open a zipfile, and create another. Of course, you can use RAW reading and writing to copy + the file you did not want delete. */ + +extern zipFile ZEXPORT zipOpen2 OF((const char *pathname, int append, zipcharpc* globalcomment, + zlib_filefunc_def* pzlib_filefunc_def)); + +extern zipFile ZEXPORT zipOpen2_64 OF((const void *pathname, int append, zipcharpc* globalcomment, + zlib_filefunc64_def* pzlib_filefunc_def)); + +extern zipFile ZEXPORT zipOpen3 OF((const char *pathname, int append, ZPOS64_T disk_size, + zipcharpc* globalcomment, zlib_filefunc_def* pzlib_filefunc_def)); +/* Same as zipOpen2 but allows specification of spanned zip size */ + +extern zipFile ZEXPORT zipOpen3_64 OF((const void *pathname, int append, ZPOS64_T disk_size, + zipcharpc* globalcomment, zlib_filefunc64_def* pzlib_filefunc_def)); + +extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file, const char* filename, const zip_fileinfo* zipfi, + const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, + uInt size_extrafield_global, const char* comment, int method, int level)); +/* Open a file in the ZIP for writing. + + filename : the filename in zip (if NULL, '-' without quote will be used + *zipfi contain supplemental information + extrafield_local buffer to store the local header extra field data, can be NULL + size_extrafield_local size of extrafield_local buffer + extrafield_global buffer to store the global header extra field data, can be NULL + size_extrafield_global size of extrafield_local buffer + comment buffer for comment string + method contain the compression method (0 for store, Z_DEFLATED for deflate) + level contain the level of compression (can be Z_DEFAULT_COMPRESSION) + zip64 is set to 1 if a zip64 extended information block should be added to the local file header. + this MUST be '1' if the uncompressed size is >= 0xffffffff. */ + +extern int ZEXPORT zipOpenNewFileInZip64 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi, + const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, + uInt size_extrafield_global, const char* comment, int method, int level, int zip64)); +/* Same as zipOpenNewFileInZip with zip64 support */ + +extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi, + const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, + uInt size_extrafield_global, const char* comment, int method, int level, int raw)); +/* Same as zipOpenNewFileInZip, except if raw=1, we write raw file */ + +extern int ZEXPORT zipOpenNewFileInZip2_64 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi, + const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, + uInt size_extrafield_global, const char* comment, int method, int level, int raw, int zip64)); +/* Same as zipOpenNewFileInZip3 with zip64 support */ + +extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi, + const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, + uInt size_extrafield_global, const char* comment, int method, int level, int raw, int windowBits, int memLevel, + int strategy, const char* password, uLong crcForCrypting)); +/* Same as zipOpenNewFileInZip2, except + windowBits, memLevel, strategy : see parameter strategy in deflateInit2 + password : crypting password (NULL for no crypting) + crcForCrypting : crc of file to compress (needed for crypting) */ + +extern int ZEXPORT zipOpenNewFileInZip3_64 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi, + const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, + uInt size_extrafield_global, const char* comment, int method, int level, int raw, int windowBits, int memLevel, + int strategy, const char* password, uLong crcForCrypting, int zip64)); +/* Same as zipOpenNewFileInZip3 with zip64 support */ + +extern int ZEXPORT zipOpenNewFileInZip4 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi, + const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, + uInt size_extrafield_global, const char* comment, int method, int level, int raw, int windowBits, int memLevel, + int strategy, const char* password, uLong crcForCrypting, uLong versionMadeBy, uLong flagBase)); +/* Same as zipOpenNewFileInZip3 except versionMadeBy & flag fields */ + +extern int ZEXPORT zipOpenNewFileInZip4_64 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi, + const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, + uInt size_extrafield_global, const char* comment, int method, int level, int raw, int windowBits, int memLevel, + int strategy, const char* password, uLong crcForCrypting, uLong versionMadeBy, uLong flagBase, int zip64)); +/* Same as zipOpenNewFileInZip4 with zip64 support */ + +extern int ZEXPORT zipWriteInFileInZip OF((zipFile file, const void* buf, unsigned len)); +/* Write data in the zipfile */ + +extern int ZEXPORT zipCloseFileInZip OF((zipFile file)); +/* Close the current file in the zipfile */ + +extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file, uLong uncompressed_size, uLong crc32)); +extern int ZEXPORT zipCloseFileInZipRaw64 OF((zipFile file, ZPOS64_T uncompressed_size, uLong crc32)); +/* Close the current file in the zipfile, for file opened with parameter raw=1 in zipOpenNewFileInZip2 + uncompressed_size and crc32 are value for the uncompressed size */ + +extern int ZEXPORT zipClose OF((zipFile file, const char* global_comment)); +/* Close the zipfile */ + +/***************************************************************************/ + +#ifdef __cplusplus +} +#endif + +#endif /* _ZIP_H */ diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/Info.plist b/iOS/GTFSImporteriOS/GTFSImporteriOS/Info.plist new file mode 100644 index 0000000..40c6215 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/Info.plist @@ -0,0 +1,47 @@ + + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + APPL + CFBundleShortVersionString + 1.0 + CFBundleSignature + ???? + CFBundleVersion + 1 + LSRequiresIPhoneOS + + UILaunchStoryboardName + LaunchScreen + UIMainStoryboardFile + Main + UIRequiredDeviceCapabilities + + armv7 + + UISupportedInterfaceOrientations + + UIInterfaceOrientationPortrait + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + UISupportedInterfaceOrientations~ipad + + UIInterfaceOrientationPortrait + UIInterfaceOrientationPortraitUpsideDown + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + + diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/Resources/GTFS Caltrain Devs.zip b/iOS/GTFSImporteriOS/GTFSImporteriOS/Resources/GTFS Caltrain Devs.zip new file mode 100644 index 0000000000000000000000000000000000000000..0af8ad3b9aca0aeafd5ca3c7871f537f38467617 GIT binary patch literal 39381 zcmd>mc|6tY_J5OPtYiqGLBuv?c8Jqykh#KU+ag6W>`i3KR0<~<3R{XODq$lV+dLm+ z6G@0|+DW_2L+0tXKB{xibnpHC_50`E^XlXIJmY%a>%G=`KI`G0*4ey;c?0sl1+U;! z>xJ)+T^n|6&@?(}xc8Wq<5d?cJN(|`Htw#{#-^+rxVyKSApd4Ia&9;c6L4!5nKIXTYM30rAk*SWWFV;W{>)+kV5uPwmBPCfBSrBX`7-PpXPnK2gdqQX-4y*J68gB;#e>5 zZr`0Bu|w>c_6qh{$<4|$GR!p{-)j~N)6uJ8RT2#oyuvG;!-w&#z-{tb$Mo#~%ZJoH~?lCu2w zfL=V$b|KaXS`K)+%v}0g zWMop~)3=fDED%iD-n-#?@{AuoEiXALC-6bs zvuBxwH=g8V-cF4Q%nVG9OU=A}<970sxEslFaks^e)x@`1Sv*YndPF~Cd_u#wcA98F zUx-@uv)!b`kg-j5aM*S1H{MVBZFYvo`LH){l?3v6#prX$_&dlfR3~U2ZB=+Dn&@oD zuHtVUb?oZbx7hro-Rzc8lZ>EY#%=7(EEX&qH*7G5fB&Lw&0lCM^v|@tXys^wx3+Tm zBXQ4;e{@W2^Mh;A ztt(T`{*Aq*`|jTz@?+4*igr4vSWugq`O)Pzo3{5o(jBj_QjFVjoc0D@s`=U1nK$t1 zwtM0-;z{<8c9b1klQ^b&#}A_`%7)Fd=^VWL)2SD^&j8F@JwS^2iZ zo0wwx_HSW5x~X>Sp-t=Z-9NF9_XtqJ@Vg8A=7IhypUnT668~P*{|#ac#b@oLuUbyc z{`~5LLgMicS<;KSA1MzbKYxCfk3VrZ-gCbz^E&VYd~(nKPK>_>P?3Ko#w9Bk8%wLJ zS6%Ebxc!A0KO!kEGMl+thV}T|FKfp+bx0Sz$AzMs_6ak;zALXhcDH=|?X&szfg|C^ z9tK}nk!`VvX}P={eSzvZJJTIDOEbr%uh`GbB)o{RQoV$#o2k+&89wE7_|5bcQIR>8 z1A&UVzcyaCW;}K2IP-q4dxG~i-n+b0GXxiVDBo)9Q{@YI!>wi8rnnXb7d9>k>=wUQ za88^FZFBk=yOCH?6f-l|7Z{P}aY{2Wg^8^#H0T;*n%bJN??%K$)mD!8Nz&GFA(>IWC~-s-U5lwsZS#`jt86UJBjv#ZDDxx{lRTZJFbIh~jYRXXGs z60h6n-Tle-K^56A!gbO#e@d*OF#glZp$5kMw ze>n3brgy7ZkwndD9jDtOmpJUd=-JuF9Fr_n$aQr8G=IO>oW1*53eEg}weJ48&ceuo z?IMj^4SQ>PwawX0t4m(Steh8Ev^x1VSqS&DMy!jV{HMoEJkw*XVO{YR!s{NI@RZ=w6&AgQ#F8R^NF zx6yJDp_GQS`@`)@dEV`FV; zhri_X$3XgnqB=Tydbgzy=~3z>nodcEH0w0#wP_vWLP=6?Y#S8*^laMY0Uw|EmSQpG zgXkga=x9#UFT8FkBn^+J$y~!4cPlu}@66tQ=f=TX zquMjIdGykUYs$wprAysVAyz`kUmeyVuM>52{O`Q^H(#qRPX8{(qA1dmTI**oU4z#; znOm|$Dt@WqT{v-Y((86%>ggNt%OzK>{j_X0hCYZ-jI!LaOF!e#jcpSy4BoebZp{}A zDF=W4T=Bm4r=Lp9)mNLs)%RL$J65+%;`5hb-VZ~Y&}-(Ckv3ThVG#>v%s;E@%1gJo+~=()Fs7v*lGg+&{<2z|w}uuRmoa zsEq$w7Nv0N%)5PS*;y5|!sN74#_-QKy}gUG%27;e!n+vlbM1Yb<04OO;5@kTqyO@f z|C-R+O!->Azu)Rg-`djJ+_e8{$J+e(T1WZHbl>Wz|1$Jh&hlSVTIgF_5Lz>6&0Sk< z_J?uMp>M6Od}Vx%>c1+z_QkI}%Vm76B;3EPque5Evd-~(M z``oba>U7a+-nd?^P@g70>Dmk3)p>O@)i0Btx%<4;yZW@8!rkeb4zfqO9tn*u(q}$h z9$&t!_gvGPu35a+X>slDs-|a*H0cdWznpKlc+~n@t{Qi5hX((?mxI}RWsjH%vWzb! z{<1Avjr+I=qnMXON#9yYlRr+jY!Z*KGE@ z<>%X91|#|}>!IBVgd-|u3#R5-qm-+ zNK-!wEA`K#9BmBmwWZwiiOe|Za!P4f9dYGabjnhdFt&&1I9a2IN2GJ8 zY%gi?s%5No`clBF@b$J{o-WR>*W%gOJ6#mtTh9$RI=_m^sTA?n=(P!Q^t!(gg`564 zx=}LNQ6=AzGZ|w)M+}CL2vv zY1d@IMy}STzz2L!k zg)Bn1YxhPC&S=!5&q$LNIcK6Axn}mOCM5YqW+Yiy(+%Glkc{8m8M*eoYY);j=FFN` z%bB480q0lf?7gG`F>aAgaqi>p>b)C-9laPGNp$b_yOQG=y;+}TKGNWk^!kKx%rSC_ zt*`ac^bv^!_s-Wi7K5Y0$J@k5^>7F_%I0XHzGFu1>_PPnHm=t<)mu;aqErNasMySVvU3 z9;xm@H9fDs`d4}DFTdvc_BJmZ{$#8!mv_VKYmCOKbI)^29=~(*GnS1bn@yaJm+5?N z{Yvv0^W(R_e12ah;7RD1ZC06JDBI#RKAM<5P$UL}Ci=Dv2*&E9U$diH7WZv-wKJB+ zEji514lVb0v6qr@YbEo$mv1FfG>#trX{>*qv93>Ds4RL-AnI3w#_Bx1Mq42M{%+~K zhT&=2$Y=A{MIJe2W6gE9Di@Bp<92;@m{2m$8lUl!^zy(5hja|LYK%k6b6?-BttNDD z<1&Z2wa(RMx@y**a+l@i>aQtl;gXI*`1JRR+w-~1=kwgKHRkc~Ama)~clv!8!Kcq} z;?L(I;)_-DjT@g~kcUb>m!C7P2}ekD9wt*%%3P`2vkGuC`1JUEnFb%@ zmQ`Au(a-P053LtELu{^KD@AwLRpJ<2?RuoIP=mHhjaH-=Q<>>q;nX6WH*PWVF)gAK z7igkfH;zXw2keUK!9`pqsTO89TTtEeNAOfn+T44$f(+-(h>f-d858_|*nC2M!*W@% zjR%(Iq>S(BL0hQ0E>kA2P(9)(0%{ckmvW68sU6j!WTBD7;UcPd=6Sg;alf0dFQYsM z2xFH{VrzKbhmr$EiKOC;3sM=eE$GAd(Ib~p-DP+|eERY&Y71JWu5a`*%KYNgkqaF8 z#`xZg0I%Qq*y?aVV#P`mJ80f#rAhVho?f|Nu}n%vpb95fQ4fsHUv$CJ+e2pR4g%VPVF3 zsn^XoevJa8!mkR3DA&!oQcFv}?#P#{gtz8Be)!_x2#JgEY=$Q)zA!(Ls%Q~QT`C+E zR40cP;s#VBxcvaP!Fhb-gr9#e>qyD|_pqD!4b&DgjgplvfMYOu36Jth_gtK*T2g3T zf_fJsO72Q^aqpugq1MZ&f&gR$n|m^DVDV+IC6hsN#>B3%lUUjwe^;oR>daX?96_$y zUciszH^~|6AzsYoY8v-Y>SCrZx+`@lTG;u!C1*JMS@v9}&L5o7xW z2$?^Oql(kJy1Qp1{7)+L4qN)+(@UyGyU_~_`9RQFhI!zwa8N-Z@OB)~Q|X|8B2%0S z9#NV57D{2Pe>HSQpusP7Z1?vSX?efC-iEjqwDVwxd#Pxzdd;3+5X116u9@2II`>|G$sYk-OQw2OqQ62KT?}samouJC^9^X7YjN=O(u9($dm>fzTs0w?k zdvj7{f-Pa|K>ENV>WDg9?Oa87&77T#-*!i*NTIA4tpFn)7o3}5m}a@LRAy810xFv^fm*JH#>deU{is+r!uv3)|` zG~%X--;wR@ZvD&&TZb?9D|zw}o5Qzf`Un!UZb(CWUkJ-hw*@|8-{$FXYeAxoJa>~$ zWLC?yVV?oX`i{%zwrbF(FPCm_nk+v#+*KIfKIomRzLn0_(s9|>eau3}Egy~VL!M1D zzG3ajYvQAcn!~b-&85~uc**6*Yvm^$7M*N!d&@P4+x<1?EeeWfcJ>mButK!bwBkI@ z*a-)Edq82Ua=v;Mzp=+~(Duyk!n}SK$DYN@N?BpWv2G5)JP!xjt$2^&TBQq3#d%=) z-Dcp3@I3`ZGu#Dv&b9pG?V8HwY%s;7J-lZ&7rPA*X1(EkpF@G$0OQJdkD1F2CVqOm zCd$Nnl5i!##&PrX&heT@t8XIe*c{k*`?Kbw8%0m6N7LE^SS(E!P6uI8>Xr0-EKBdg zYUcs{9<%HfpW9f}bF1zeXNO9H&aluiXNN&^tpDTRG6IFn_gGdIVNoepQ~cR0GYGEB zt14Rnk-84#XM3*S;l@sl;H&v)ze?$W_J`xmYRi0+K7Nt z<6b4HOzsER`_4lvKOvozXI41{;{|wnH_mK7;c>6fjVYx!3;9{CdjDj(@9N4C8CR+x zXCmH4?~{IIExmcji9tK>JaB*>kZbf?9QF>KswQmatN zmrn0Ztl9m!B&s9Iwj4u1KUObz$etTY2@OkE7R`T z{^qqf!t|$I`9pAkn7iZ4af`~_;S<#n?UV!+&5|qXAynpk@bQ|^1Mt7n#7gV8M?=Q%JHPwlmWfURi$c@G_NhptprM>7v>rD;>)sDNTgG2#KC zRPHv0_pZx&R7_R$d*jrL3v9hQPWJFVCsE$F3A~WE)i}AzOM1A6JQ)_xj+C87p{X$R3s z!nOzf(m@%Y9;*XgV(}gT$Fs$L2!4yN3o~3Ej&+k`lnIP*Ofd9<(}pOa7NSp>5igvY zQa3u|Q6(Ubg*?@U0BCjFGGsUdPmVXnH0F&yj+Ll2`p@{P-?mk!)7 z%5YiCC_VzmsK;McN)H44eRG(@+A>|#5}!v zyaz2)?vBS+J$K9J3LT86#=NBU;B-vg-u94x%j1Qjd3*~f{ifeEgrDc$`I4i)!cKyv z)R>9VPtI6c$U=HBPvhi+etDhW=^;7U@Oq3KHePc5D{_8fNKO{)^5@xh0+?)sO} zR`TRwGN0dO!VHFWIX))ZsrR+l30p0e$@^a(in?WzoB2jwE4EDLb>hQCVJq#xSeN~^ z-+u;C6ReWFz+ili6Wek8>hm*JfK%eB?Zaf-r3p=`nTDcK-b;}l`CL9XGobH&FAu6* z(}6l%vvAm+{38SMQ)6V?*puqrv#hPJf}sQ70$?TY=YgQHm3jC$!GB%FSDmzUuj*(0AVY zZO^RnfRAliWSer&gDh)>CihP$Of|vajL$Elmi6}YsW1Ewre8^uL&{H}ysOcKRPA># zoo1V~O3;3Z|Ai|;CLaHqWnHB;aOvmWmi4z> zeM7empfCffugCGN<&jME#cL$(HEr%pab@3wyY$zL=LovWmi3FmN&W|;2DdF}yT8w} z7V?|q8t1c|ToJCe{<vV4PMW05ENI+?eDl zg1!~=ocYFkia-Fbd~W^eQkb=b4=))%JPnW4X^5%Fae;~P8Ld5xr>d!N#&&00byif1 z<;zD_AsGKk_n>jBMHX@pOV*Wc7RActuF~_W)%Rsq7~;+?#=o+C{%H9Ek7Jcx5i$p_^#DWM#O5)JmrVZEJuKu}w=tis((i9YJ^5t$ zQo#af6EMmu*I3I!mTQ#ZhXxa6y#IuSX?x|TIbEkXYQ$=~x&Ppz23})vynlX0uRd{_ zbFo=kXMS-+)v&24Z!NReKe1GqqA<^&xl+D1V_B$rpXby{gvRRa^n8gK_cjfJZnkx% z(z&3I!F+_cds?^K^6dvqj}&W*XN0CDElL&0rYWV37o|H9nxeDrfOLaRNYGY*X+x#->p+xeB&=tc^`@THuBT>Y>xzjE^;Nvar%NdjJeD?}(-TkXP z{VUep`R(c>LqmhG(4bja-q$}X$eK}Pj_n_kD0aL1#Xr=?=z!|o!yhanV-_V1HH*u2 zF8AuA@97cb2M4X4tkpu$^~NhPT$vdfy5o_gMM-KQdGfU6gY=W`2jbElSBa;GRpam4 znFkbpiMwv(c>ks_N2M-ZcU!<{sLn-$Z0QY=k2f2hyqKgnsb6}7Nlxber4KBPmALa_ zS$ld;a(1ipb7(t@xGDxk3+?IKy1o1P@Gb>s?8V~+^7`7kYZrfGinra(zn3zqoqa^M zUw78=RK=*AaQ5SF6DGSIhvtlb8Cr2(V*Qmm_xUnaru3BP>oM)5{h|uRD22A#Y*KOL z3)3qHicz;ij=vkpG^#po?rkD&rJh-eBFIQ~^b)iSqHmW%tK4&sgPoi27(VxS=A16! zZ^FT=LwM@(Ohi@L?wX1CWYwWr7<|jp0|xhI6~o|_jvj(`$)OM!9NM<^ZE@tQQ-XTq z+6T>}D|-kJ9qCbX=cXU^OmXv?MwBC#zs!eduD&a+*nybFr0L?}A1aPTK2eF(MlRD580sU;}o z)#nv?HHQNEkRNjFPkv$tLvB!Ep6P;fp6#ACC;1Z;EFL4B#Yqxs4khNvY|SDlb1Ywi z9@!OV=NU3`GA7WrfIwhrJ}{!lpFs07ky49z+3M&iXqDJGp;qO{z@MNQn|r=`dYdZ` z)Y9I@Dyp5R;ccC8lr66+XEV6hvINtx-btZ#S~H63RU2B%%d<5fXbf?tdEKht3A1?` zZh$#Tl&(W(V{443;H3UWMF7(o)>rIo%6mo=Bk^On6CydQT1XS2hB}U(36tTQMbw%R zIT8>#So4XlG_RnADMht`ue%T!hH@s<1_W4ix5{Q>a#CjvI)-1EH zFObgrX|NbNzut~?7TgA%(f4dgJ=G2H<$Fb{8X^t7<@x(>D7m6bs$FO)9=nrIapP;>HJD=3!RpgO0X zUH@Saook%Y3Wl(3H-{lBH&~ic62}0S8t(bxG!shQlG5FD?>S=ah23_F!uJ;oq)x=Hw2_CWLAX51K?87uM@upa4%d)=+ zD){OL!sPJ#6ihghZbm(aRro*}f#;G16D0#PPL7_vRvb53npL~B-UO$-ntz%I1bG#D z3dCmahye&k5r*t92AFv98K0}B1>EDGv70e3`}|Ps_|8o zoW+e-L3Gtdj_mJ(sOpMcp)CmVXGI9S_x&S3rUjm-7r^Ev^{S_PT+B|XYk|CsK+e9F z_IUMgx>;b~WeZxt(7;X{Nskbtu~s4pt7VzQbAA;_=s=Aq?n0gl>reUhr`)cDB=M&b z2WhEkEXI2hlHN|}=3FtVX%nTT0y2SM04a@ChBjaQxD&*yKVX3Q{ZBETX`w-vXsNPh z4+H6%Cpq-js)JJ~?ABVIA-V#R&9!GRCt_};P*|+ zNyKWf?;RA?@)2b42wNS+*_u_sXPkQx`Fr`w3@iyA4OC4qL=CNu!_xK71-RF!tDn4&g4A;9reB<0U%XiGKDq9BM9y5J^2z2_R77v zWy^$kGbV53fjAK+#EBT%c|OM+ODj5kkk)C$mtfa^H?3e%;=BDqWNMv|pv?wIshtR_ z0fSzr3Z{yS$=ox>Ie#lpLPqqb6JZFIk}X8RZ%|)QwW@P|qw;mZumm zY;~&*6^r|$?L5baJI2WN5OT=rJjTC zCqV;88j0X{>+ZyW#~#RQz(Mtmhb+xS6lJ9};mKtzVK9;3I5G%tq@}o+FRr5vwMr{k z!m}4pn~FEWR4wL9yv8b#Bz${bktAlFFb^B?));*tf9hzC<2@R@BrQP~59l%qT}I}h z%a%1s9amb|h}gl^pQ@4(N6F_1POgAC0`%Tur@+*Fp!R@-T~qn zV36}iA}@S=Jx4@&CBw!NUU?q)8e++&CyV7(2&UgHeEUL0O_cY9 zQcI6(WakHX32wx7sX+@kl&f>`*3mpCJeuLMkSkg*?ZnZ}(;3VZ5yB|M-tm+G(i5{k zR&$vo2GW&w%7`wyS}vjneVICwAs=MHMqZT2GQ}qbOc@wY1)@Q{6`sb^3K4i={p$TFo0nX ziRyo3#5z%C{&6*o5DVpZMApgjO+Uw4Cy21?SAu_%0pZE;-*9wS``co5pvQHN{tjwkN@^WDzHGu2s||ATo$6Km(OZzlYW5NEDN1<_YbPb(s-{b4ki zsM5bPa_*ni_G2tU{dF5ypJe@H1gq)VAQ&Nj=7(wXC5-=-k?JJxv;%j*A^c7Vus5dW zC9c^AOwE673Q0Gpnobyc75Oi5*FDk?8<$WUPYst4`#WK*X*7H?|~;U=WCg@i>BIHJX>au$Cxn>DuD|Nf+} z(CD18*#7smK1gBm$p_-lj`(PP@unfxO7n;OqjNSkPo{F8?$9q^Xz{b;-YIU7&PX#a zgU&Xk=Lhcma&&&9NAgOU1lui>0;Koh$5Xk?r@hQp8JmYz?N!hW{^zO7W3zQ>zioHq z@9SAL<(d&|N?WMV;!XTO^xKZy^=rg%c~e@?9#LNT1nt~(F@y9ez|UjpA|`l_mcB_1 zmcaW<=#2GqjdeqZPUtWkonqrQK}^VuaWFo`NQQite}*=_f;`zXnq{0F|ADB@9v@vN z)-?2?!u+A@k^_b*MNRU?%~q%0(JY&mxT)MOwx&Vv{PLI?T$nU7wV$!Oa3xQ|=B7yj z(z)chT85cnLQHyP&QEz}z3H12UgG>bmgdrg+158vD*lUMym8`gc)i2guSXGTuGk@nn4yZj(_{xkF3{OqLxg3Kr9wL=i=l zOW6e=D7o!~=4)DBX5=l+LxdqeA~T_aywEcmVQk0oUa_orC0qRD*?8l9H=?Ev)L?pc zA|Uxopu(b44xV&gd=2dq;voMnkbiu(j^y`Z@__W70P5TOwAm{y4bDpi-8Kcj=AUIj z<7fskgN7UZ7=hD0S;iZ8yjLtQ_AQx4dn|d@WsJ>E>SGb5yKPq%8$J`?HhsNNo<7?_ z3efa2E83jWS3nEX&nLaiaLHG>(1-ik$&6CtJ#BaDRG>sB$-GqTpr+`mIr4zZ< zTP$epPpdDtLS~_E@nh`llyBspmQC`=!FDCbiT1NYI*M(lNV&9VkcdA&|)h(@a7_mFBeak}z=~B@t zgWMCurlj_Z#^*P#+Z|C`eBJIMjCTfpAYR)PAFT%{9b8B0B4*zcHOa8+h}}il9KHp< zVG{zAMvU8bp)zsL>p}p39qG4?7PKblaOUPz?!%*AX0;odhj{Eu(Sa=M&Z8sEXydxw znQ@68YD(j%&{7HbKxE&DFt$8~zzB-iyzV^AxOqWFmUZXhfH8P8pLBNvq6y1}w;MeJ zRiSguCQ!x3K|8MvKE^x~m@{kL2{DvJBdrTv`Qi-*a%sYPuU|wu<~g<5r!H#|K4$u+ zqjd%i(uAX4zaZTrJ9WB1b@FVNXHA{3u(Kp zHO4Ido=xYKKGNXXg=1uMasNmgG1phU&%89Ai$0lae&OmFlD5P1Sz=Bje4~de@SXlN z!AW4bX(G8+Fx;hrHh6c0vL_*J|F0g`W+jlm9KX5MeYRmYFz(#z*#ke%sL=gZR+gx# zB~JIVCX61;jE=T0JfFKcQkxMC@4OF!vK}3hvV`yZlF6A%x`!;`lR7LJw`a6@1C?ei zN{XVT`2?m=9Je_po=}iRxz)2~TDC}je&tg@)?qPW^M1zo0f+dCKIibP zjY;Oo?!#wvtSh9I?JYRnV$hDMPi%47}?l9Isi=(Vhx}dOhR%yGV26i9C;Ie3#<8iqGmz>Ayag z8uTS)EYql3Le~TGvb^`coYS)YXbhQJ5vsD;H4~1`+Y-ev-GkO1f_?0}FEE4d*j1Q8 z#H$F>vX_6kW@1kY;evcDo2zQixzu`gGy8GvbMCogA1-4&6^&_cNfT<3*0gc>!iCQ# zG4XH$WSU-HgRf-cFCp+n{L&H!DauPkNHx|+C_t*wjs&Sj8SFdA^t|eZjDqz?eqGuC!ODfm(k!PN=>~JwgV@b7cI_bcDR5gU4^$bOtD5>(xgWTbR zT1B-i;lB5`=v>bQilKG{%LD1>U66jhch4XWa(lQvl2CpGnWT~`VGEuFli0@Ls%hq^ zYv&+G>5>Ivx7$^hd(C{e$TO@UaQ0 zaUx`t0^4!`Eo~Dxy9Te=L#9$L3Fq0XWs%F&tg0K~4z-vn$TOX+#X~yjz_=2UPEt05 zvMQ2`4X&@1QX7}~@;;C*AR+`}R|{K%*vU+gA;#1&+d;l^EE`F4Uxsx1c>B3Mk}S>7 z#m&vQ6UK!ftf;E>S*3JNaB|gAstk=xk3d`6)f3Q$kff}-5eNANVSnl^x~lGgJB`;? zt{C!<4{DI4+ww~l93$rE;tBZIh)JUtgO-%Xd5p)S|z6+;|{5qhmhD3R=Nmy z4D7MvNrO@VbR@?!MKkK*9^3gas4N{W)JgiKxX%yed+p-412_EUb3#p5`OSH3Cg;iIS!*r-h`{ z?sa~|?Me`L)#?_3vNe9a+ymv7Tac*$rf?*@a+JzvG9VxdGSIq42iwthQAHFK!^!9q zY#Yzy^he4bEPj*;x!R_C`G7(db)s>Krsr8}Hz}o-FQW=6wpXv-=_8io4Hq0@lfUyM zbl1o^$ZV1dA>FC_lLxIZu%3?Sa@SkPP=OIobXUc@@+9cFzj-UKrZX%R4p$0>TvDK; zNY29`1(J{a8($?5!;!G6En{nr{5Tp1#lP`&B4YnkM9O-$b3i{=yCRBB^dAnF04;5UGSgST8OaKbvug1 z(Q{18_Xbn*5eYeG$X#~MB0K!#jj+{U{ZDKy4Axpg?s&Z5Zb49FvKZ2x)_#9t>zEaL z`46_{{lRQ(^+J9rtIqjHN79avwf*I$svujvp}o3L+*1YjIQdM@KurOl=Kkbb#8dst zYB1GR%sdGS-DfMH-yEki4O6WLml+|UB2NJXF4R+~SlNW!ZXDHVolrCLxRQ%_EoVEp zg3+3!c!2->C#%tXpQWf4;p~rG{E$imkW8jUWgxwUtaG>5ASdYVD0mLePUONyk9;K; z?!(;ogJ;_20oQ79je%S?kXVq$=Ls>F*!CeNELcA^Edu@aLcd=-;__);SoXGoFGu_R1anX~;;J1fcyd zV8mpR)NvFSas$IV#@G+8^j+&);=XlPFV`(x0i%_!L0G`g6Mg~V+%3Q1`nN#F@6ReK5!mrus15Ru}clPmm!YsQq&zxyS3u@8%e&d7BI zbk>e)gZaPj3R2y^X{Ha5u-Uw5lr3w7h-|ae7WA$9`v#8I9V3AFB)ixa+%&_+1Jr!f0gANGAY|%X&M2@2ClWa?&(g*1F*v zjO%#*zVz=~MgWW&`T1Mtw~)E3p_~SQM38VZ?ek;V=^r|!%%-z7BX4JsPJkIh=TXlo z%^eAJz!A~p@B3K?bbWS5P{9u=zA01nE`&vOG*P~D<_Bts!b0cxUedgd0AbQjd>4Z- zYQmo|X|Y*REk}S+*Rz&?J6!S!BI*hUvl!04VDtMDeje4@2tCj-f;=&upVpBvc(cnT8{6>J_FUv0Nkb zy3+cwYue8ony)}i7_Z}+5b3mMDA|XF#(FfWpRLmc#;i_GgCHh+%k)`73bCw!0_ z&%d3w%Bta*v%o%QPNpsByIUwiS?RnxQnL>U)n!5u$z|0~J_BF$ucKcd%^l7ceKhj= zb9VhHs`e+BT~=4IwdQ@;_VsGIFt*K`y_3}I8ksS4B-jx% z4)zPvlZkL2!U&g|C!pj=s{1i70`*0h6#-wp-J88Ft=IKzC$eeNag|gU2|3E~+aph4 zKExCIWX|m&*_5uYf=EHXD>-~bv=ausiuu+T{sIf+T8Fx@H>aLrSV}()l87So%~3

C*-2d`bLbP@46dU-|Ke-Qz!`_*E((K|7QRt)Dnk}#EoS4y1qcb`LV!{6~C#G z46zl!)c^aQVDRrcL6H5178%g^f$BHi34Fu)|Bs?v&y8am3dM~flk?*GLf-A;kOO0m zwTyeeS=8-NNX{nCm%cf#+kXkjiQMIkcG%P$qRVG#bicx*;PyUGv_X=Zr0@+}F5wB{ z)#F}fa?pGtI>mVZ1W^rMc{XYE*DeuK2z&Fo(>Zq3U`82Z;djT%P1*#{`;B(5TC{l_ zYGPKcAYUw^_NAX?cSculYz|R^`EfA6>ykGn1(F$WuGn9k zdy22{G*%wt?HuQxEryHl%&s5Z|_^BIm-*S{~!A z69Qx1WfH^8(J2fJ6U4|334|So3>+ByF)i1pa?RkC>5#$jW+YGPi$QOBSDLB4k<(UT z!}_$Dq*eIcwnE=?gA1r8j^#=OqYh(j4dsTxU|X%_FrhW=oH?2*3_bU07-g_)hK31J zSJQcIlJMzcb&j>qpdB~7mcwgLHIjNOYRt`AD%8$4i63mg3BN|YRIueq@k*g~GNb6i zbV$x`UN1*u$7bo`#)9#Kuc~uC&e!r_CY?EwOQ?wrYMz63o7B`A;CL-IPH8pw@QnGG zsrDKlY-=}4Y4ve0(BtLD`%B5acfjC#GnE@KjMENtr;58%1RAq?4vf0ky4PTS`6>2h zv1Zqx$Vk7$+@6GkkCe(@DF%-_L%&|Db6yWk*_&l4G>mxRlzcEWN1zOHYH66Ff+=}} zJ$@B1OLgz(XPIZKxNHmizXMeM9UyN2sPsEP_DaePUxIAwyM@XqAA+W5+lm1n9N9n8|K3%HLdFnW5rwFgr@M>8-I{bw;>-ONvxjAoweTH&F_SR_!rTRh>OdG5u zqB18QVRj|vXEt(vr8?A#wf0Mxz%N2*!4ATM#+{+({e?G_*5j8wV>YripG_pBs5DPV zbYi?74zf1CjU%LZy@ua3gn4A63fnux12I=(idjE(w2uy>9M$ky2xU#;KZ?RGqF@)! z-jx_}S>=YKu#37dX;L^Sxu|qXqS@5z;d$0(**i3hcJ`F~{oM%%cLGSkG)&jaDS6A? zeia#176Z9k!zn`3@6Oj?^kooRlTMd7|BbF*np>+KcTLIG?6$SmjNkdYpZt-)kUBGYH3 zkC?4bZ?cdZl5^Z_eR?;-PcZ!@8iq6yoJF$!PSP52gIyPB7!e6Iog2mppUSFoo|+8W zkx^R4Y^m4|G`7@GulZz>$+?7I#8N;*#9e8PAd?n^FGg+XuXVv`K(|{av zBhQ#yUGw{wILoRZ0Y`ld2knx?)EZ<0ZBw67TI0`p#^|Q0z1|;a`z4vuT5@LnN<&KS zghQ!`SW-w%_i03I|18qc^>s=qYew-0{Q_`xSHV4{CiF|x?MgW4p;-26=+-!7Oy^`H z480y!Fg436(J++fQ}QOzY$tAzBS*uS!K=_NBr!xqYSp#OV@KsW&2}$3Ri-oLUxUWe{)CW;FAKK;7=_}r*^?blS-Wj zURteZdXrxzqF#@}>#n{{qk$<)W{^;K^QIZ7V)l%$*qyllgwp$g-*`%P4V!1yVsrLj z)@+!#SM^$kS;lAC)X2G&zO=RwsVMurqy}MZ#^)qb3fDOi%&b<$E0XkPNSZ>MBhuEO z&g0V%gDTP`L3hZbw!rxueU*2;gT&Iy3CV_X>F7oNORGve4-1CV!nQk9*>UkZ`NUsJ zROYtwz8{gVOZTYRD5Rt!f=}P9zIuh-f@MVpcg01od$zUiz}Riq=N+6glzA@u%n#>^3 z_VhtRGlvjnwcM)AHQ!~I5z)Mqu=DQZFp(G#_Rh%GW{aY&muca05T>|?Lh&fbBe_Vm zfS5e}M2YT$vj9o{gVG*K70UNBkr+Rq`c2d--?Lv&*{`v+dIu9U0yd+BZV-%r4oJ@@ zZBvvzTuLxLZ+JDBFzgijwCnrc=^T#;1lNto)&(7qt-tEZkSKW@{C(Fh;p4CzeM7{a zu|AnNH`9d!%Gp!ArWl5guGdg^&L7~a!D1K`4?x2*Th7%Y0wGF#0L0O`ibgjvD5F?B zZmWUxI1z(<(uB4UC@;SdsrUxy)K6z){Hw1f0HFO<6cYr{Hy;o{8(9!QqvNdxmy~q1 zzo5}$F77Y?xc|Y7t1#7V)Q|mlKhJ~;L|0Y5P0g=57uj-5f&c)1R38GsY7hbd2U`gM zAa}ZmFg&c(SXn`FzMn+8_fR-qCl|D}v7JIW_i!sZh^od$Bmx4Uy|~mH-!)}$g;z|w z+=_G(G*yy4MaA-N{KDKs5r03QIYtbv5HV*(-S3kbe2fKczp9{63Xj{`44PjD+T16+ z$sl$=KX?_zlJ)gT4j>#06^O!E=6D4T9H1*T>g`6a?&1`T(wQg;y`DAQOWFT^K6E65 zxGBz3hG_0zEjMXzt2d6GH^q<}cM0y3_p8LJ)VUHyj9X8}wbc!PbU07Uv2q zSZaYL&u80#8`S2e9|~J5_4|lj4zf%@xD`Oq0fkMBwqY?__=T7dZj}peNA;D{=32oH z$EIcfB(4Dw5m%}GU*eL0!s{Aap?|q&0e{eaSpdDd&2zAAEf%(}u7L1s0Q)ST#5_{> z7C$)9wk0r&07{uta2r4sIZL&GB{7(yP<;!0_8F}7InW=<_i_enz9lwWHhuu?dd~7< zUB}g(6DpmULMG2a;{XrKZTefX}6bEhOU?1ZP8^BpC2ldrbs(PfpB7peK$pX=5=SII26HYv~Owvqx z`;x?5P<0K9y3_xdCE`K`F@UAgCS!T$@`^TJrO9Xq44(350MORBy z^z@lV-;5n&?Y2Y6i}zgKFP?+N2}@>A;s=VexWG`B%=UF>;S}0Mme@?}_$*OPvnm5M zbDV2=zcBbrOj@FjKQ=g9>C3w@(R^7cb(EgS!+>6ih&aCsh0^F>QJob*bC*pnW%#rA z{Ra4yysgzE5|`QNoAO5!zbt-jpnIYWE#gcu3k;$jA4+c%0v#kQ4JDi|0D1fLLuxIT z`gYOhRqHeq^GMsoMPK;JbiJd9KV~dWT$y>J==NmmQrk`6rQsypQ1wm2yN;xlnHEL2 z4@VE2OsIc;U^cN|F4bx_j~`V%I>n9d)e148wr8f0q$@{XylWjL`m*=K;+sv5-93O?+pFgoepo?XTuc z(M=|vJPlP!e&ZJ~DqnP^VhGb*eKlZmHE%9r3NvnuXG?TH3!Q;}GllS&^p&{t*kzMY zgSfL7>ya2^=L62!5}WQTD_+1bsN1rlEH$k7Oo9Be_F!KSj=|YF;KANJ?AT2)1r4W$ zz{qmQMPPeZGl1ddiD1m(H!A?_{Owz0~BeX&qdz&zq=zNX>o3effPP=cu6eQ%{ z0bXV7Y|Kjl^xix0VVSC(84}%+rSHLg4ZFggCQAt?POIDi3C;D-{w}A3{JNZPePw_Tf-P_^`C;DTA z_n^@?ETeaz{PEq4X!Q~ZHD?Bh5p3|L0jHkIEynZo6kz=!fsF6hCIltA8>qk2Dq5hecIm*lW#r0oQln(@%0hyfMB7 zu`T~DI|LzL@NW=ti9o4%!p?$tVd6LLZ_59mpD(+q{1f{(LEZi$=*n+@5%jV?A}C(> zzX&QLhY0!`D>AFsVBUg(&*v^6(qad&c6QfFsztY&{`shFNs-5ioXI@F&eha+HV1E0bdDRfi3Y3-J z8?eqR=6!$WmBe8GUwF0gDZ;BQ$^V&G=!V@0ucU7(#rq#yyhELA=(|s2>@K5m0$=BX z3{_C<#Y*x2ue|S$Yiim4MMM!$P-)U_fOHT9lx8n9MVc5O6zLFpA|*kPq992Q2B1x(>uD{pPX?ycSS*lAR~BzO4u?uP55cQ~w!zbIo{CAfx0-;0&O!Rh9S#=6XrPK_(i*H9D*q;PvZ zEud~Csbo)XtZ@&0$Dl}y8cR07j!{~PDEF}vTs?0t%`N|>3pG|Kg-|5~iEwuam~I9U z$9HK;h1NtOfIe&y=+|(GMC2x!^KMWiaxp`d`{>Q68`avC$bh|LgbfNs$UVf)wQ(ht zS!WnALxDTGHo9$GsYHS=bABwQwXk8xV*#HJrPR~fT{lH4kbB`yLVnZ`@;B*P0HrH0 zP)2b_*3&xjy1j_p2sgy=u7tG9GO-cS3Jb2Mk*mc^k>E{T!*r)c4=QUh5?t+fXc$|P zl7DL$G08XwBL=kJ3IO^MR){>r5|F9P9YD-)s8K*ntk}MoDH$}k#VzN5h>6*9q4Kef zOZ=pe-Gxo|VQb3n!>-rahdq`9z>bCd19oG3h*dp}>blvMjof?TROq`8`)W=v*hVy77B zVfqalaBtywVrDTQrF8DTlxD#Ed0f;mqlP$9X*+DX_}BlK&&KIb$>Y07j=|R(3$u-W zbw3`a?=cV0fra+mlFLWt8e7adtkU0jJFvZD<;VP}ojtA4 zM;dHYOPZ?l3(iIx9u+H~^z!FgspwEoYtExpmAHmlTiUdY&RtT#D@yDA%`H4)hOd#_ zvmq&&zY_!|5RHMa-HtY3*)%5FVbn?2O)84k0gEC~8_DF|fwwnT+3W%)A#hY#dA%Eg zjI7#YD!AlgsP#xT2Selv*xejP0<7 zW$5Gxaa+`M&Dj}7V=wkmq@W=FWs^VeCxDf!c4KiW7Y9s%xf*O~%V}@fswezZ#?TKs{+L}wj3ytIup7Me zB=VSBK#TXMHrDF54{r~p5a^XK_xO?nH5<78K87==P4VOY7{*JOVP3uuyTKB7BU2v) zv~Xs%83CWcx}}~-V7Y`D;-v-yGw_R!ZJ zLR+Yw2Ahfv&@mR6Dr2LRX?exYZJ!aTr8!GfVR{(t)6~)QGSA+g*0_5bYj-FOUard^*BX?%zEYHQJhou?-6d%4^6K=~n2@r4qI_9pfm8RcL z(UMjCw&^pXH$7*m6`3BUc4RQa7%R+zx}k~{u8Q~}|X=&@&=1-$^Pk&%+gJPPpy zo4ejyen9d7sk_Ejjn(wzkDM=>ei{oM^>XQPJYE7(uJ-qKMDtzdq@|)wJ{Nu!oF|{P zm9o73)eiqM(>h&IKO*7M_;-Ky0HfuT=ITz0xP$L>Jhc57>Np!O-O1ehP#~pHE;#wb zKtGKGRr9?)SF@c_e`Yk75_m5m9iA`V@Qs7U=AM^n9pAaT`q9%OxntMYNrB%oXS+R} z6h*sJn9=9<+4D=J{YT=!xtprF!(lX@jgtG*~y zq5y$gSR66D;E!7{;vW=BS#-H1EmPewU!_IZ{HdWn4eq;^6*_Zp#?0%u1J31aU1K=w z*-JYW)vmV~-?Xs_O37l)fflS?7okR}+J2-3bSFAA)I0cC#Xi0Cd9iwqtv^&IZ3-ijzlRazL1;&oV%mYT&zGmyNYH#3?qiUY$JBby(EQ zQIbamriI)`;FPgGR6I9Ax9)yz_;ho*wW#rQaRS=5<2a| zvugUnVasiI(9xEZzy%*jdwM{L0JY&Vx-bYnY#>))g@CUtnRV3)Pk-u4=4){KQlRo( z1Q=?f)ZE)22^=U>g1}o_j8|ds>^G>qpu@=MqxeG5#ZN+xMl+Pej6~WzPR+o-p$cL* z7du;SJ8G9vVU~(&51&;`Cs9>&*DrA*^_=a7sv|ApBO=D8i z4MTS4n<1SMM4m9ejF{Q1?uLH$6uX^#&iq{QyuIgVt^5i2?0%zqNPg@K zKGr=h`B}rxgF1H>?Dmcc%8(R&bn40MQYRZ4LD5Eb9E;McrF?CK7Fdv?;kq6U$PQw( zM0)PA_$iB+-B;&e?R-zu6zdqXR&m! zS#D_Wfa(hnOIun@tW>zT@7glY~Zh)JYBFNoaVg-A8QfCMg0dR%LwvB03Uz2v3Z` zHor%uy17#H@w(MYeuhYW40%okr&x<=WS3loX5;C>xYRj69F!F!u)ZV$JBE?ke}grw z+Ac4NYzX3pI^nn~l-auOs%wQLcB1;H|2v6n&-A>X!x}c^y8c}sh=JoAqh~ts{&>%9 z(j`9(&8a@HQTqBCV~-S}B!iP&EdrYt=R~r+QR9DX>f@8@Qk(};g@DQw+Qf!G^d_2{*qajQsqpHu#D=qzPy7uV1V>xVT>rbe* zaqpKiw{jpg;7J&YWOPhOVXqV-oWPjVT06)ob1fXiWb57;?=8`sW%^0gA65{Gj~c)i z0iWtU8Ueaw`h}5LFh6A!R8z65+=pLe?lcSoU25=j$4k|Mn2^bL*^sp@UIUXx#wn07 z;I^@#0A#Ql%j#1-$QfS_1#a40LxBX0JKvrYz(g4ZNsRhKD<1kkiv%&LZ&nHvabPP) z-6YUYeh9P`sc%|<)-zorqCjE|O>IRCsG{@k5@_gP70IY$E2z>0d6Km8=5tXD6@GrO zC3eVHUb%C7G z{%a$%HQfcC@%*EB%^InOWr(o<-1;k{ET#(^Un7%5-m6MR;pR~j2WKPh#H|T%1whLi zTX9_wN~nbHU_Cuh>A*lJu+5sfWE#FWf$cVCIcUq`d)Ig=w&+u`nJid0b(An!>(;tV zmKF6%pa~46u$C(|c>20hU^{9J$+Xm=V92_Fi4ZON>+-Nlp$~dF+(lE|mfLj8+_qbK zgtNj5ik4Ki>qdOdUfcSXWG0t>zi9LjiYOt6vU1cb8s!996V0l%LWs7;7;@@p2svdO zsNc6iFSoQl9Eoh0mIDrCO04I1*Nthg*`2UgI}PtF9BCMzkSd>uY*(hnnaJILLjfu+ z&tC&~66`F1rc!Y0?e5|cgwiB%qoW27vYljPt0qaUd57>!cokT2>!5BAaEiG176s83 z!{dQ+6odcT)`Z3B_aM%4$%#&{f{Dof_Mz zy7CNSyi771BL?9=F?gXY8olzMC@VigHnvAX_h&!Exa+t*%50^L&JkrMCxXOFSGz%m zi7jw7db~7lm~S0Im>%WT4^=ab%DB(NOIiAH(Z;^ImxzW^1(QtQg*HhWzJhRf1wX$` zF{;4wQIem!juHKoIjMDcIGeL^r;9bUz!Mn)OP+{Etc_lp`$lZ``k3e~gu{gSHavGr zPb-(V8JXTmY0-9%?lj%Z@jwp~aydMFAb##S9Dd4XOZv<;%E&dP=kHDVhQ|p^A3+y# zoP4i~Kc5h^9i8L~Cpt4CA9OYQth7im2=Ui7vbRgcSaXf9c_BC58Xo-A5J5hGyn9y* zx?rc-QjkXCYN4Hq0v*{H)Tj==8iMBOe*$oOswqWeh$ zNzr$gZ5PqGEvL1DK~hlDk!bT-5Y^A3>mp$cEyXL7va>Ya;7xMsW`?+h51DfwXtJv#O_0N>=ihS{wj$-<`9_Kj+6DBv@TIu6P0Qcws;w*F{p?vn;Aq6tL~NRsA*c*!H}tde3KgDlaSQoiG>?70({>J`QWs}8YBvcq35#p-e*kDEHA05h*X zsf)WV_mXu;s;b%sxc^qN5ajQ+vdsjTpq=j=SBFpYcii>MuI?$IBQQ=syi_o%YaB2E zv!t6amPvIzI>2Ivu8|;mq?KblkPiv7CdlKF(6`0JaPEuaB5gW6{}1DvI}Y?pHQ z1LTbI7pvpQ2hIaWt2ZQaJln=br?>)?HRUJ9OGa$(x{mEU_u2f>|Z){0Wy&#?;6GqQa;B!-nJPDa2V*TB&+ zoRwFamb^XW7TIOlxgj#8{63Z3Ojy~i&9P6q7HLc~M4nu(a&Il-cxP*Y*DTZFXex>_ za@n5pECbe(x@Q#-;So{hk03GVOZr8laCq9Y>ez{vl2nk`oP4dP#3aH~38x91#R|zz z>GXsM;{tNqi(&>~n4(~zEFNX#mB;nV5wI*wQOp`wFKSRgCg&CC(lRA-30R-U-67uX zh8@*|0=ZWwjDmaumvD>Bms7o#-Rf#%kDLMzZbv*A`?`jzQ|h&c+{0yZ5%fiLFT#7uR@o>@dqOYCr?nmeUN( zwG+XUtykr#iq(E^#ej-s3p{|%i1Z^vLVwoyQJ5Ypz(Up%p`B=xgNaEh7Sf-U*G;hN z@NbiM%;~aAVGWp%*?N`Rb!F@V6q`10e{N(32zxJ7`83yYi`kjFzyMIM3W(CF7t<}} z%oc#rDgBD&kW>_>XR=8W=!@S8`Zg%aV$WYoL2+3^p%QzD%J_%~MOW7mq0Q0A2HE)9 zr=_Lw0F{?VgJw7tBd%(eB$VC zJ=~QWv$5U4n*uyvAT4F^`6D^LeMLd=$GJd5yu?+cI5g2>tVoDI+t&do=b4WIi@jj& zSW&o(?Gv)mq>9j@*z5w{SBb>UGYH{ahJMKgabn5!UIiBEig|eP%?Vr;h!fS*yiWs8 z9)uV!H*7c}nJLLbj!5w;u#_JXI4@abvG(Vyc+BGStH;VwJk&$R9%b7Gngk{ZD38vz z?xRuy@(xfDX^e99tYcTVv61qpUDBB@4s@wKP7db8&RrX4Vu4!U3=l2E*#yMrfu3J` z-^gwR(O=$Hv7A(CBxk$$Z|Y-Cqvx?CwL5dthe~SD^QuT;SU`&Uw0Gn7^tu`7_}eK9 z{OwZ0iM#mQZo+AW*bC4+sYS&g8dPHuczVQ_0#A?E!Vf?)M{-V0D26jBEhz@U_voO`&Cew2#ts&&N)?bdCq)NMW!X}}ED`(|17 zE3|}MNYzsxq7`9p8QSg7r94~G2hP;S-7Dq<2#bR7uM}H&q1M#g z6J0e#`@#{74A9_*oVRojTS$c~G>~LHtD@Tg&07gY##$RG@v^|MOzVA{QFl7kl~Ap7 z$GXHv)Lbo$nh}RHY&n-jPdgf+Z@#)zFacz(FyZusI2oZ8x{?e_vBG7^hL^<>Fogj- z@-3C87X!3y4G}H(t&Jx8(`|eO2Ig!dxuXd2+lJ+&lIim8+y>n%&bCEXjhY_|;RCXj z3N*H_k$4p-Q(E$QRSD^de)2=9awGSZ)k2#g5~%K(sJgl8mx@ z7{c|TtB;b*X<=lvUaqfJD_=FCCfv7E#gx;iK!k&QJ}T>ySK2kpdJ~3B?pApDW?}s!?d%gjNfsHHhLHHkcDnO;+buC~($yPRTcVc4tFi{;F zz6G&)dUjpgXleKe;2uKHUgyLz_uNNcC63fLX5i;e3=iC^51fiLmZbee88C`L4>?r; zCc2c14>EfxLgZQ&GOomjo83yP0G8)&wrR)E|r9ltLN$V~SU>(LUH7Gx=Zo-rbR z#dayMhMkEL-Qz2Ia#_QKqY~DN*!ZD?tq%b!)LuhYZ?ipzOdfPovTrR`d=ttl|=`1Ycr0rGz+0pij?1nqyX3TUOo=it*BQ-&LNG~LHY zMWJX}e2-H~$Mf`I*}X!lPb);u8;&#Zmp!ut%h00LwWZbOr4K7_EgAR?yFL6SP}7!Y zsqAsgQ?vFQP`}yAAf%n=+^VkZamyvaVoqCO**`?ANZj&9N)~9u9aeCOX(?5tEf!qzUH7~( zLWleyH$KmFORfGqwoV>D04iPZK4pw(Y*9I3EWK%=X;We7NFi&A#>u5Fi^G2_9_Jme#5J~p1v<%d$fr#^!kIKHxu$!t}coy?#< zt~;l_Q7OOkOcPZi?~l|(9a3@qfDfW=oN_^0XfO>yS)fa-y(AEVIBfmkek@oXg#;8C z&)EwNaEn=f50uUKjlKAAG88y6ys{EG(Xr%aP2Sr9?+%zPfw*dzIy|1JZx?xh+Lo>x z6Y`&{$Jc)>dUhpkfmMe!&bO2f91gR84`$l+1?B~W&K z?PzK#X;@I>g(gg#QXa5y2Q8g`Pvy9C*b`z+Xr{l&!bLQx;3I`|ByyzxUN}v}tY0M@ zuL!CK#hK?Qd&-~_!GY{yj>;S7(TOa9>;%1(%aK!EpxXPfu><}E7YSQNHquWFUW#_- z<32PPCW3hkr_2fYU7ZbvHRbRI3t16YD7G?mbPy&1#a=@DGTE30y_%n3!3mW`D1%y6 z7?rTaVnY%#z|9ptRYOiQ0jDXmGHmgsx^jhH2+}Nb4I|NDeUIFgZ-1F@A%G|-E3e)`C!Q0>s2)$LPMhkQ zQ-36G2?S?3JC&vw(7si*fDt89T?SqyZ-uHgtUO=xY~NdH zS&h&@(0pEWriV3g=+3VOJzneIBUxy$AxY_Ben_{&w_rQld?L5}FMh6i=}CjPW=1aU zxmeb)r_=O%m3QaT32qmAr9@=EyPF7y@@*k~YOq#0rL(FejyR{3uM~3xTiX(# z9G7UD$N`cgEI}wu35Ly1dv~%qK>Zgbn-Qb+3dLeL*v?*ZhMY+mboK+8< z9JTZ}t%~xb@-JxH!=nW+{H^KPVy7Ny%C@}kEoV5VJvzhsgj*t^t;~!BWGDILz^@-Nj;2S&oV6?S9)T;4 za6%cU7bI`>w8SfQ`@~DQY;IyOPLpusIIgWuor+jbQ)wN_W4ZWjZl;#5g2%KC)_A zM$aI}w^-`J@)I{+DX=fMpF4NCS{1jRLE1FU#K8Uiik;Zs8a?guGD?%(fEf%i({Q?? zHHaFCKqaVjiZQEoo=5?dbUAxLGItzpjzi;2AbKNRISZ2c$`3ZnalYL0GjY?BKZTj8 zXDw0=g_zxe^R}D&GG6>CJzx?(9=Q2qwkIR}V2FlRA2lNHK+05hc#FD%?rH`z^|oC& zx8Vq5BcSq+s@q#tZb#SLlq<6r&6d$-T|Y;}!aG<51Go(NFYK7;)<@J=N7R(#G5`fn zpW3I_Sp+NNhRG@YXuSEsj_LL(4n}4em!52Cj76}RA?YgAcXp! z=c$r=8v9vCXAnY7=OA=+xL5o6n-4PlamM&R&pP_wlhOUJ$odzjJJ$P|U1RGiW9vr7 zw5YF0QIgmB3t*huKazNJ2iuJQJ&8B;h~l?DPmRm}$7x6RHT}EX-M^(AEi(QZg}r^e zp7D#u{K4~R4Loxw~2HVF>rduy+lcO|M#cvKD%&@Z0KE7 z(g+Wr&h?a}BMG%V!}kLM7SeaO*Wpi}`r&t}l)z^3l`g={259rV=nMIN@zHATU-jADaHKI?1)#MPp;HW+(Yb=Xw> z16gKYZJBrjA=?Ax{VNYS;oV908A47&O;l5|7di}1$o)HZ9Tf`s-& z>ES3}Fvr3}yBYHjU-?*WFk5+Pzsv7KIiBJ5>Q4Ri>7(r%>rRg1Zo%UL&IOj{^FiQO zN=g)AFVvNVFX$J_&XNu^hw-k+pEmaW-k$l3?FN`Q&g0d0;VUV(dQ=soig#xijwmtA zeIg2`uPtYsJas3}sxC6F-GQYvj(!~j*L-_@>v0~(r)t$Fy=CX!gF-La8&xeWyXED# z+NL8N>D@~w^Vzc}TvF}|hQ=PfEw7M#`_pEb?u@!CWsx7_v94j0eC$Z(`~YK3G=ujw zZ;m{U(WE7NUZJpi^k;c;3XF}{t?J6;siK_*u;(2^P&q znQz)Y4*sf`jw)r4v3o&Q?zQa*cyoYM+kKZZe6zI;)+KYbq%6|k38j+^f3uh+@&Rpm z@{8hfF&zY#?eByT3pBFqu8{<%xyI0KO%yB1nw*jD9cg_0QYv)m+IWtBngi`f=r-!P z{oLu{#+M$0*8WUGesMK}{5>ub#UxC3$!Dh+7Uq*R13F-B@opcMTHR z#ctQ+CUj(Si*4WYiecoR7XZ1Qr;q=)%;chfnzr{p`h))!PS+rDNrTZ$=Ho^QVQ=

W*84%oj8nSy9sc|JWjyjU{Y}OHv(xqRaQI`Vo0^1&@GBh+A+xLt z?9hQM)|JkgL9CQaysWvGj*Xcff?6ru#wxqv)B`HzSx_-|U)q&8+iPf^XS*YRqkFnl z<33D?tWnZHP}}v}bJ*QjSlz|05oBOW>5YWFRqvl$yQ`#u0b1*D>wRQ^n*X+^BGqG! zh@Pj$hqdQMgI#wUsHiV66=9T6-CKh*qdyV#1XHu(&_Tza z*OL{bD>fYNT8HI$GQMb=O*?(%y4Ur2g{u{T_AGsBQewn2y!|H&-Z3~No|aKJHh!cV9qrA^aIey*xwYjX>ev1!yYq*m?0L2sDUA?IO3z7B? zhi_`hUwzDbSL+}?;@n&E8L$KOC#oCG;{07pG)Yn0j`fJ@*_Gg?6M^h>(Ff_z-T$+Ub$SaVYM<-=d2Zwqr3f`qFUXjg-=npLO-V z_2aWXo|hALR^asws#G6jgMWPu0)DG^M(#=0>vtcH^gSlk{@Vc6_+UW}}*ke>`noWh?fn`*_CE3|uHt_wD=YS;yTEiqYIDrH~85oU>YJ|Lg3c(cG)dDKga` z#+0}&hbxE*Y6%+=Q&@}`l7*fToU2d;Y`1jN;4EPRQ>B$U>d~x`^nQuTWMiLm2JgK* zSU?rUs^cxKTtyPEk*6#phSHiqH%I7)tovW+NImwu=z73Oy*cTA>Fm4Pp4%N6ea|1; zub<`;SNj-po6YgV->UDqc-1~0Ds0cHIh+?V%bUejI?G<@6MQL}w;SG3!ZW_uH_Ltj zzgd)XI_l%?;dA+K=3Y2{s(Y_16gLny=>J;k0sK+-osp^W0=9y!tKj$BrAZ}9J4B`i z?-zCfS&;0U^Gau0G>KMGu}NrtiOTTHMvfewh2KPqNA;XHfx_9@kt&Or*vB;ff?*d9 z?9SibKsz{AJm#Pc*5|#m3R{fJT;M07>I1H?H&6&MY%$okZm<~KQMDBR=^11y_b@-p z{Lm;YN~x*J;?BoZ+O%43YR9>6*cWym1-_qnc)8dFlOH#bb#ZLBZiekND`I^dnhz0uv>kbS$4|pN;SzPiC}QyXq|XqWfT(&uK-LO{Z?D z2aUc%ho7a=DK3~WZZ7dR(U)C5t;qO!HgH7sU)|| zm-}NpuWmz}T;JhW@?*SUzxcevPl8(MgB%5?$jq%@Qx&tZ1f^;7M7>RVxEy1CDf?Tv zRqm^Nu>yTX&2Bq)=<8bBu#mM9Vb{k|vtTXrWhkbu;ORhz%WmaV@@{fRK-r$^TGfv` z%LioqFEx&QGMn<|B%}}w*TO`E#Lbu8F*}dY5`rhB{Kb7%pIXl5hI3=dTIv#T^trb- zyI00VG=}{3OUnASRDB=s&Oe$A7A&T>a;@{Jrr#P%$mco7 z)^@bvapSfdWswH;D+5~$```W2=%JWXY4RO>nQwL8v#PAHyLU|CM@gZp4qxloi`tTz!%#Qm0z-*?e!eKdjMgCZ0-z)Yqs|#jxb6oCCd#Z%d1&m^e8!a&Tz6U3HH;(&c|JGc=F~EL89f_Z zx5fU0OZQ9iVB4C|{<=KT{H|7=k&f>9?f<_x=szye|1094I7e-YTv~%|{|907jmVfe zi9+($`<1PCH-3wQayqmR|1A#kbg26NKjWY+pRl`hzx)XN8h1*A?-<*oOuy8jhgHb}mtEAcI2jmj9$H`i#^Ke_fu47ua3_YWm2 z*1cx^d$1WkR|g(l1pn_ysQpUf4=zz0D1mjFGXUpNp0H|hUSqt=$rHjpQl9>41J zA^A6*{)_NVT+`d%po{-PI4h6>JO=(#r+=UjY4Bg+(F%Z%zjcO34FInXT*ANbAO<=d z`mf-@Pb|G`{;{p}ceBv_Hxc&9PxH#>{3e3zFXXcVnGXL|5&oQ$1;DATnM^1LgpdYQ zBk~I;Vqg%kR{VjEY%M)(z?NRXDq!XPZ<74W!2e}O9NOBtzeytZ3;nFX#3O$u$^RuQ zkJg8+eSj!O08!5T!ipHk4mgGXB#MW(^Y7>5kE8%;TwVRm%}D-2IxFx7%U_b>FLBut zd_Zpp2=ElRPXEG%7>ESC*B=RBWAg;;0I_xb^-toD@VARPJO74X;up$Uf&Rz-6#rjk zvVk@)g#*z0f$R4!k_>q3KY;Jy`d2I{C$o{|H|)RnMD1*UhW)Q`_;qjo_lBc%;tzrU z`zHLq`}cpD|F1jHzc-wkfIkEO*SY+<#r5kFKn#=){Eq_s&I$dI(fqoRBl + +@interface ViewController : UIViewController + + +@end + diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/ViewController.m b/iOS/GTFSImporteriOS/GTFSImporteriOS/ViewController.m new file mode 100644 index 0000000..c7ac3f3 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/ViewController.m @@ -0,0 +1,27 @@ +// +// ViewController.m +// GTFSImporteriOS +// +// Created by Aaron Jubbal on 9/10/16. +// Copyright © 2016 Aaron Jubbal. All rights reserved. +// + +#import "ViewController.h" + +@interface ViewController () + +@end + +@implementation ViewController + +- (void)viewDidLoad { + [super viewDidLoad]; + // Do any additional setup after loading the view, typically from a nib. +} + +- (void)didReceiveMemoryWarning { + [super didReceiveMemoryWarning]; + // Dispose of any resources that can be recreated. +} + +@end diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/main.m b/iOS/GTFSImporteriOS/GTFSImporteriOS/main.m new file mode 100644 index 0000000..4fa0562 --- /dev/null +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/main.m @@ -0,0 +1,16 @@ +// +// main.m +// GTFSImporteriOS +// +// Created by Aaron Jubbal on 9/10/16. +// Copyright © 2016 Aaron Jubbal. All rights reserved. +// + +#import +#import "AppDelegate.h" + +int main(int argc, char * argv[]) { + @autoreleasepool { + return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class])); + } +} From 2e55592c840ad1e975fd1a36f661c72d473770b4 Mon Sep 17 00:00:00 2001 From: Aaron Jubbal Date: Sat, 10 Sep 2016 16:17:21 -0700 Subject: [PATCH 2/3] Reconfigured project to reference GTFSImporter directory at base of project instead of having a duplicate directory. --- GTFSImporter.xcodeproj/project.pbxproj | 8 +- GTFSImporter/Libraries/CSVParser/CSVParser.h | 2 + .../GTFSImporter/CSVImporter.h | 31 - .../GTFSImporter/CSVImporter.m | 543 -------- .../GTFSImporter/GTFSImporter-Prefix.pch | 7 - .../GTFSImporter/GTFSImporter.1 | 79 -- .../Libraries/CSVParser/CSVParser.h | 60 - .../Libraries/CSVParser/CSVParser.m | 520 -------- .../Libraries/SQLite/FMDatabase.h | 155 --- .../Libraries/SQLite/FMDatabase.m | 1148 ----------------- .../Libraries/SQLite/FMDatabaseAdditions.h | 37 - .../Libraries/SQLite/FMDatabaseAdditions.m | 163 --- .../Libraries/SQLite/FMDatabasePool.h | 75 -- .../Libraries/SQLite/FMDatabasePool.m | 244 ---- .../Libraries/SQLite/FMDatabaseQueue.h | 38 - .../Libraries/SQLite/FMDatabaseQueue.m | 176 --- .../Libraries/SQLite/FMResultSet.h | 105 -- .../Libraries/SQLite/FMResultSet.m | 431 ------- .../GTFSImporter/Model/Agency.h | 25 - .../GTFSImporter/Model/Agency.m | 101 -- .../GTFSImporter/Model/Calendar.h | 31 - .../GTFSImporter/Model/Calendar.m | 123 -- .../GTFSImporter/Model/CalendarDate.h | 22 - .../GTFSImporter/Model/CalendarDate.m | 105 -- .../GTFSImporter/Model/FareAttributes.h | 26 - .../GTFSImporter/Model/FareAttributes.m | 101 -- .../GTFSImporter/Model/FareRules.h | 25 - .../GTFSImporter/Model/FareRules.m | 99 -- .../GTFSImporter/Model/Route.h | 26 - .../GTFSImporter/Model/Route.m | 137 -- .../GTFSImporter/Model/Shape.h | 25 - .../GTFSImporter/Model/Shape.m | 104 -- iOS/GTFSImporteriOS/GTFSImporter/Model/Stop.h | 30 - iOS/GTFSImporteriOS/GTFSImporter/Model/Stop.m | 162 --- .../GTFSImporter/Model/StopTime.h | 33 - .../GTFSImporter/Model/StopTime.m | 292 ----- .../GTFSImporter/Model/Transformations.h | 16 - .../GTFSImporter/Model/Transformations.m | 71 - iOS/GTFSImporteriOS/GTFSImporter/Model/Trip.h | 28 - iOS/GTFSImporteriOS/GTFSImporter/Model/Trip.m | 152 --- iOS/GTFSImporteriOS/GTFSImporter/Util.h | 29 - iOS/GTFSImporteriOS/GTFSImporter/Util.m | 181 --- iOS/GTFSImporteriOS/GTFSImporter/main.m | 101 -- .../GTFSImporteriOS.xcodeproj/project.pbxproj | 247 ++-- GTFSImporter/main.m => main.m | 0 45 files changed, 88 insertions(+), 6026 deletions(-) delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/CSVImporter.h delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/CSVImporter.m delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/GTFSImporter-Prefix.pch delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/GTFSImporter.1 delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/CSVParser/CSVParser.h delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/CSVParser/CSVParser.m delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabase.h delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabase.m delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseAdditions.h delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseAdditions.m delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabasePool.h delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabasePool.m delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseQueue.h delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseQueue.m delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMResultSet.h delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMResultSet.m delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Agency.h delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Agency.m delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Calendar.h delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Calendar.m delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/CalendarDate.h delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/CalendarDate.m delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/FareAttributes.h delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/FareAttributes.m delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/FareRules.h delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/FareRules.m delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Route.h delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Route.m delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Shape.h delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Shape.m delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Stop.h delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Stop.m delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/StopTime.h delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/StopTime.m delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Transformations.h delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Transformations.m delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Trip.h delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Model/Trip.m delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Util.h delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/Util.m delete mode 100644 iOS/GTFSImporteriOS/GTFSImporter/main.m rename GTFSImporter/main.m => main.m (100%) diff --git a/GTFSImporter.xcodeproj/project.pbxproj b/GTFSImporter.xcodeproj/project.pbxproj index edf6cb0..8abc732 100644 --- a/GTFSImporter.xcodeproj/project.pbxproj +++ b/GTFSImporter.xcodeproj/project.pbxproj @@ -18,7 +18,6 @@ 8F8E1D2A14173A54002061C7 /* Trip.m in Sources */ = {isa = PBXBuildFile; fileRef = 8F8E1D2114173A54002061C7 /* Trip.m */; }; 8F8E1D2D14173ADB002061C7 /* Util.m in Sources */ = {isa = PBXBuildFile; fileRef = 8F8E1D2C14173ADB002061C7 /* Util.m */; }; 8FA6B3491408F30200B2476E /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 8FA6B3481408F30200B2476E /* Foundation.framework */; }; - 8FA6B34C1408F30200B2476E /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = 8FA6B34B1408F30200B2476E /* main.m */; }; 8FA6B3501408F30200B2476E /* GTFSImporter.1 in CopyFiles */ = {isa = PBXBuildFile; fileRef = 8FA6B34F1408F30200B2476E /* GTFSImporter.1 */; }; 8FA6B3571408F32400B2476E /* libsqlite3.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 8FA6B3561408F32400B2476E /* libsqlite3.dylib */; }; 8FA6B35A1408F34E00B2476E /* CSVImporter.m in Sources */ = {isa = PBXBuildFile; fileRef = 8FA6B3591408F34E00B2476E /* CSVImporter.m */; }; @@ -26,6 +25,7 @@ 8FA6B3691408F3B500B2476E /* FMDatabase.m in Sources */ = {isa = PBXBuildFile; fileRef = 8FA6B3621408F3B500B2476E /* FMDatabase.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; }; 8FA6B36A1408F3B500B2476E /* FMDatabaseAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = 8FA6B3641408F3B500B2476E /* FMDatabaseAdditions.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; }; 8FA6B36C1408F3B500B2476E /* FMResultSet.m in Sources */ = {isa = PBXBuildFile; fileRef = 8FA6B3671408F3B500B2476E /* FMResultSet.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; }; + 93BA29D81D84D2F1008674E7 /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29D71D84D2F1008674E7 /* main.m */; }; D447A6CF16A0910B00E4A74D /* README.md in Resources */ = {isa = PBXBuildFile; fileRef = D447A6CE16A0910B00E4A74D /* README.md */; }; D447A6D416A092D700E4A74D /* FMDatabasePool.m in Sources */ = {isa = PBXBuildFile; fileRef = D447A6D116A092D700E4A74D /* FMDatabasePool.m */; }; D447A6D516A092D700E4A74D /* FMDatabaseQueue.m in Sources */ = {isa = PBXBuildFile; fileRef = D447A6D316A092D700E4A74D /* FMDatabaseQueue.m */; }; @@ -69,7 +69,6 @@ 8F8E1D2C14173ADB002061C7 /* Util.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Util.m; sourceTree = ""; }; 8FA6B3441408F30200B2476E /* gtfsimporter */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = gtfsimporter; sourceTree = BUILT_PRODUCTS_DIR; }; 8FA6B3481408F30200B2476E /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = System/Library/Frameworks/Foundation.framework; sourceTree = SDKROOT; }; - 8FA6B34B1408F30200B2476E /* main.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = ""; }; 8FA6B34E1408F30200B2476E /* GTFSImporter-Prefix.pch */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "GTFSImporter-Prefix.pch"; sourceTree = ""; }; 8FA6B34F1408F30200B2476E /* GTFSImporter.1 */ = {isa = PBXFileReference; lastKnownFileType = text.man; path = GTFSImporter.1; sourceTree = ""; }; 8FA6B3561408F32400B2476E /* libsqlite3.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libsqlite3.dylib; path = usr/lib/libsqlite3.dylib; sourceTree = SDKROOT; }; @@ -83,6 +82,7 @@ 8FA6B3641408F3B500B2476E /* FMDatabaseAdditions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FMDatabaseAdditions.m; sourceTree = ""; }; 8FA6B3661408F3B500B2476E /* FMResultSet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FMResultSet.h; sourceTree = ""; }; 8FA6B3671408F3B500B2476E /* FMResultSet.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FMResultSet.m; sourceTree = ""; }; + 93BA29D71D84D2F1008674E7 /* main.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = SOURCE_ROOT; }; D447A6CE16A0910B00E4A74D /* README.md */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = README.md; sourceTree = ""; }; D447A6D016A092D700E4A74D /* FMDatabasePool.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FMDatabasePool.h; sourceTree = ""; }; D447A6D116A092D700E4A74D /* FMDatabasePool.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FMDatabasePool.m; sourceTree = ""; }; @@ -171,7 +171,7 @@ 8F8E1D0F14173A54002061C7 /* Model */, 8FA6B3581408F34E00B2476E /* CSVImporter.h */, 8FA6B3591408F34E00B2476E /* CSVImporter.m */, - 8FA6B34B1408F30200B2476E /* main.m */, + 93BA29D71D84D2F1008674E7 /* main.m */, 8F8E1D2B14173ADB002061C7 /* Util.h */, 8F8E1D2C14173ADB002061C7 /* Util.m */, 8FA6B34F1408F30200B2476E /* GTFSImporter.1 */, @@ -294,7 +294,6 @@ isa = PBXSourcesBuildPhase; buildActionMask = 2147483647; files = ( - 8FA6B34C1408F30200B2476E /* main.m in Sources */, 8FA6B35A1408F34E00B2476E /* CSVImporter.m in Sources */, 8FA6B3681408F3B500B2476E /* CSVParser.m in Sources */, 8FA6B3691408F3B500B2476E /* FMDatabase.m in Sources */, @@ -305,6 +304,7 @@ 8F8E1D2414173A54002061C7 /* FareAttributes.m in Sources */, 8F8E1D2514173A54002061C7 /* FareRules.m in Sources */, 8F8E1D2614173A54002061C7 /* Route.m in Sources */, + 93BA29D81D84D2F1008674E7 /* main.m in Sources */, 8F8E1D2714173A54002061C7 /* Stop.m in Sources */, 8F8E1D2814173A54002061C7 /* StopTime.m in Sources */, 8F8E1D2914173A54002061C7 /* Transformations.m in Sources */, diff --git a/GTFSImporter/Libraries/CSVParser/CSVParser.h b/GTFSImporter/Libraries/CSVParser/CSVParser.h index 692100b..8b9e8d1 100644 --- a/GTFSImporter/Libraries/CSVParser/CSVParser.h +++ b/GTFSImporter/Libraries/CSVParser/CSVParser.h @@ -21,6 +21,8 @@ // distribution. // +#import + @interface CSVParser : NSObject { NSString *csvString; diff --git a/iOS/GTFSImporteriOS/GTFSImporter/CSVImporter.h b/iOS/GTFSImporteriOS/GTFSImporter/CSVImporter.h deleted file mode 100644 index 2834294..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/CSVImporter.h +++ /dev/null @@ -1,31 +0,0 @@ -// -// CSVImporter.h -// San Jose Transit GTFS -// -// Created by Vashishtha Jogi on 8/27/11. -// Copyright 2011 Vashishtha Jogi Inc. All rights reserved. -// - -#import - -@interface CSVImporter : NSObject - -- (NSString *)parseForFile:(NSString *)file; -- (int) addAgency; -- (int) addCalendar; -- (int) addCalendarDate; -- (int) addFareAttributes; -- (int) addFareRules; -- (int) addRoute; -- (int) addShape; -- (int) addStop; -- (int) addStopRoutes; -- (int) addStopTime; -- (int) addInterpolatedStopTime; -- (int) addTrip; -- (void) sanitizeData; -- (void) vacuum; -- (void) reindex; - - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/CSVImporter.m b/iOS/GTFSImporteriOS/GTFSImporter/CSVImporter.m deleted file mode 100644 index e745785..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/CSVImporter.m +++ /dev/null @@ -1,543 +0,0 @@ -// -// CSVImporter.m -// San Jose Transit GTFS -// -// Created by Vashishtha Jogi on 8/27/11. -// Copyright 2011 Vashishtha Jogi Inc. All rights reserved. -// - -#import "CSVImporter.h" -#import "FMDatabase.h" -#import "CSVParser.h" -#import "Agency.h" -#import "FareAttributes.h" -#import "FareRules.h" -#import "Calendar.h" -#import "CalendarDate.h" -#import "Route.h" -#import "Shape.h" -#import "Stop.h" -#import "Trip.h" -#import "StopTime.h" -#import "Transformations.h" -#import "Util.h" - -@implementation CSVImporter - -- (id)init -{ - self = [super init]; - if (self) { - // Initialization code here. - } - - return self; -} - -- (NSString *)parseForFile:(NSString *)file -{ - NSError *error = nil; - NSString *inputPath = [[[Util getTransitFilesBasepath] stringByAppendingPathComponent:file] stringByAppendingPathExtension:@"txt"]; - NSString *csvString = [NSString stringWithContentsOfFile:inputPath encoding:NSUTF8StringEncoding error:&error]; - - if (!csvString) - { - NSLog(@"Couldn't read file at path %s\n. Error: %s", [inputPath UTF8String], [[error localizedDescription] ? [error localizedDescription] : [error description] UTF8String]); - } - return csvString; -} - -- (int) addCalendar -{ - NSDate *startDate = [NSDate date]; - - FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - [db setShouldCacheStatements:YES]; - if (![db open]) { - NSLog(@"Could not open db."); - //[db release]; - return 1; - } - - NSString *csvString = [self parseForFile:@"calendar"]; - - Calendar *cal = [[Calendar alloc] initWithDB:db]; - - CSVParser *parser = - [[CSVParser alloc] - initWithString:csvString - separator:@"," - hasHeader:YES - fieldNames:nil]; - - [cal cleanupAndCreate]; - [db beginTransaction]; - [parser parseRowsForReceiver:cal selector:@selector(receiveRecord:)]; - [db commit]; - - NSDate *endDate = [NSDate date]; - - NSLog(@"Calendar entries successfully imported in %f seconds.", [endDate timeIntervalSinceDate:startDate]); - - [db close]; - - return 0; -} - -- (int) addCalendarDate -{ - NSDate *startDate = [NSDate date]; - - FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - [db setShouldCacheStatements:YES]; - if (![db open]) { - NSLog(@"Could not open db."); - //[db release]; - return 1; - } - - NSString *csvString = [self parseForFile:@"calendar_dates"]; - - CalendarDate *calDate = [[CalendarDate alloc] initWithDB:db]; - - CSVParser *parser = - [[CSVParser alloc] - initWithString:csvString - separator:@"," - hasHeader:YES - fieldNames:nil]; - - [calDate cleanupAndCreate]; - [db beginTransaction]; - [parser parseRowsForReceiver:calDate selector:@selector(receiveRecord:)]; - [db commit]; - - NSDate *endDate = [NSDate date]; - - NSLog(@"Calendar Dates entries successfully imported in %f seconds.", [endDate timeIntervalSinceDate:startDate]); - - [db close]; - - return 0; -} - - -- (int) addAgency -{ - NSDate *startDate = [NSDate date]; - - FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - - [db setShouldCacheStatements:YES]; - if (![db open]) { - NSLog(@"Could not open db."); - //[db release]; - return 1; - } - - NSString *csvString = [self parseForFile:@"agency"]; - - Agency *agency = [[Agency alloc] initWithDB:db]; - - CSVParser *parser = - [[CSVParser alloc] - initWithString:csvString - separator:@"," - hasHeader:YES - fieldNames:nil]; - - [agency cleanupAndCreate]; - [db beginTransaction]; - [parser parseRowsForReceiver:agency selector:@selector(receiveRecord:)]; - [db commit]; - - NSDate *endDate = [NSDate date]; - - NSLog(@"Agency entries successfully imported in %f seconds.", [endDate timeIntervalSinceDate:startDate]); - - [db close]; - - return 0; -} - -- (int) addFareAttributes -{ - NSDate *startDate = [NSDate date]; - - FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - - [db setShouldCacheStatements:YES]; - if (![db open]) { - NSLog(@"Could not open db."); - //[db release]; - return 1; - } - - NSString *csvString = [self parseForFile:@"fare_attributes"]; - - FareAttributes *fareAttributes = [[FareAttributes alloc] initWithDB:db]; - - CSVParser *parser = - [[CSVParser alloc] - initWithString:csvString - separator:@"," - hasHeader:YES - fieldNames:nil]; - - [fareAttributes cleanupAndCreate]; - [db beginTransaction]; - [parser parseRowsForReceiver:fareAttributes selector:@selector(receiveRecord:)]; - [db commit]; - - NSDate *endDate = [NSDate date]; - - NSLog(@"FareAttributes entries successfully imported in %f seconds.", [endDate timeIntervalSinceDate:startDate]); - - [db close]; - return 0; -} - -- (int) addFareRules -{ - NSDate *startDate = [NSDate date]; - - FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - - [db setShouldCacheStatements:YES]; - if (![db open]) { - NSLog(@"Could not open db."); - //[db release]; - return 1; - } - - NSString *csvString = [self parseForFile:@"fare_rules"]; - - FareRules *fareRules = [[FareRules alloc] initWithDB:db]; - - CSVParser *parser = - [[CSVParser alloc] - initWithString:csvString - separator:@"," - hasHeader:YES - fieldNames:nil]; - - [fareRules cleanupAndCreate]; - [db beginTransaction]; - [parser parseRowsForReceiver:fareRules selector:@selector(receiveRecord:)]; - [db commit]; - - NSDate *endDate = [NSDate date]; - - NSLog(@"FareRules entries successfully imported in %f seconds.", [endDate timeIntervalSinceDate:startDate]); - - [db close]; - - return 0; -} - -- (int) addRoute -{ - NSDate *startDate = [NSDate date]; - - FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - - [db setShouldCacheStatements:YES]; - if (![db open]) { - NSLog(@"Could not open db."); - //[db release]; - return 1; - } - - NSString *csvString = [self parseForFile:@"routes"]; - - Route *route = [[Route alloc] initWithDB:db]; - - CSVParser *parser = - [[CSVParser alloc] - initWithString:csvString - separator:@"," - hasHeader:YES - fieldNames:nil]; - - [route cleanupAndCreate]; - [db beginTransaction]; - [parser parseRowsForReceiver:route selector:@selector(receiveRecord:)]; - [db commit]; - - NSDate *endDate = [NSDate date]; - - NSLog(@"Route entries successfully imported in %f seconds.", [endDate timeIntervalSinceDate:startDate]); - - [db close]; - - return 0; -} - -- (int) addShape -{ - NSDate *startDate = [NSDate date]; - - FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - - [db setShouldCacheStatements:YES]; - if (![db open]) { - NSLog(@"Could not open db."); - //[db release]; - return 1; - } - - NSString *csvString = [self parseForFile:@"shapes"]; - - Shape *shape = [[Shape alloc] initWithDB:db]; - - CSVParser *parser = - [[CSVParser alloc] - initWithString:csvString - separator:@"," - hasHeader:YES - fieldNames:nil]; - - [shape cleanupAndCreate]; - [db beginTransaction]; - [parser parseRowsForReceiver:shape selector:@selector(receiveRecord:)]; - [db commit]; - - NSDate *endDate = [NSDate date]; - - NSLog(@"Shape entries successfully imported in %f seconds.", [endDate timeIntervalSinceDate:startDate]); - - [db close]; - - return 0; -} - -- (int) addStop -{ - NSDate *startDate = [NSDate date]; - - FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - - [db setShouldCacheStatements:YES]; - if (![db open]) { - NSLog(@"Could not open db."); - //[db release]; - return 1; - } - - NSString *csvString = [self parseForFile:@"stops"]; - - Stop *stop = [[Stop alloc] initWithDB:db]; - - CSVParser *parser = - [[CSVParser alloc] - initWithString:csvString - separator:@"," - hasHeader:YES - fieldNames:nil]; - - [stop cleanupAndCreate]; - [db beginTransaction]; - [parser parseRowsForReceiver:stop selector:@selector(receiveRecord:)]; - [db commit]; - - NSDate *endDate = [NSDate date]; - - NSLog(@"Stop entries successfully imported in %f seconds.", [endDate timeIntervalSinceDate:startDate]); - - [db close]; - - return 0; -} - -- (int) addStopRoutes -{ - NSDate *startDate = [NSDate date]; - - FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - - [db setShouldCacheStatements:YES]; - if (![db open]) { - NSLog(@"Could not open db."); - //[db release]; - return 1; - } - - Stop *stop = [[Stop alloc] initWithDB:db]; - - [stop updateRoutes]; - - NSDate *endDate = [NSDate date]; - - NSLog(@"Stop entries successfully updated with routes in %f seconds.", [endDate timeIntervalSinceDate:startDate]); - - [db close]; - - return 0; -} - -- (int) addStopTime -{ - NSDate *startDate = [NSDate date]; - - FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - - [db setShouldCacheStatements:YES]; - if (![db open]) { - NSLog(@"Could not open db."); - //[db release]; - return 1; - } - - NSString *csvString = [self parseForFile:@"stop_times"]; - - StopTime *stopTime = [[StopTime alloc] initWithDB:db]; - - CSVParser *parser = - [[CSVParser alloc] - initWithString:csvString - separator:@"," - hasHeader:YES - fieldNames:nil]; - - [stopTime cleanupAndCreate]; - [db beginTransaction]; - [parser parseRowsForReceiver:stopTime selector:@selector(receiveRecord:)]; - [db commit]; - - NSDate *endDate = [NSDate date]; - - NSLog(@"StopTime entries successfully imported in %f seconds.", [endDate timeIntervalSinceDate:startDate]); - - [db close]; - - return 0; -} - -- (int) addInterpolatedStopTime -{ - NSDate *startDate = [NSDate date]; - - FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - - [db setShouldCacheStatements:YES]; - if (![db open]) { - NSLog(@"Could not open db."); - //[db release]; - return 1; - } - - StopTime *stopTime = [[StopTime alloc] initWithDB:db]; - - [stopTime interpolateStopTimes]; - - NSDate *endDate = [NSDate date]; - - NSLog(@"StopTime entries interpolated successfully in %f seconds.", [endDate timeIntervalSinceDate:startDate]); - - [db close]; - - - return 0; -} - -- (int) addTrip -{ - NSDate *startDate = [NSDate date]; - - FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - - [db setShouldCacheStatements:YES]; - if (![db open]) { - NSLog(@"Could not open db."); - //[db release]; - return 1; - } - - NSString *csvString = [self parseForFile:@"trips"]; - - Trip *trip = [[Trip alloc] initWithDB:db]; - - CSVParser *parser = - [[CSVParser alloc] - initWithString:csvString - separator:@"," - hasHeader:YES - fieldNames:nil]; - - [trip cleanupAndCreate]; - [db beginTransaction]; - [parser parseRowsForReceiver:trip selector:@selector(receiveRecord:)]; - [db commit]; - - NSDate *endDate = [NSDate date]; - - NSLog(@"Trip entries successfully imported in %f seconds.", [endDate timeIntervalSinceDate:startDate]); - - [db close]; - - return 0; -} - -- (void) sanitizeData -{ - Transformations *transformations = [[Transformations alloc] init]; - [transformations applyTransformationsFromCSV]; -} - - -- (void) vacuum -{ - NSDate *startDate = [NSDate date]; - - FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - - [db setShouldCacheStatements:YES]; - if (![db open]) { - NSLog(@"Could not open db."); - //[db release]; - } - - [db executeUpdate:@"VACUUM"]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } - - NSDate *endDate = [NSDate date]; - - NSLog(@"Vaccuuming done in %f seconds.", [endDate timeIntervalSinceDate:startDate]); - - - [db close]; -} - -- (void) reindex -{ - NSDate *startDate = [NSDate date]; - - FMDatabase *db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - - [db setShouldCacheStatements:YES]; - if (![db open]) { - NSLog(@"Could not open db."); - //[db release]; - } - - [db executeUpdate:@"REINDEX"]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } - - NSDate *endDate = [NSDate date]; - - NSLog(@"Reindexing done in %f seconds.", [endDate timeIntervalSinceDate:startDate]); - - - [db close]; -} - - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/GTFSImporter-Prefix.pch b/iOS/GTFSImporteriOS/GTFSImporter/GTFSImporter-Prefix.pch deleted file mode 100644 index 8d9e41d..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/GTFSImporter-Prefix.pch +++ /dev/null @@ -1,7 +0,0 @@ -// -// Prefix header for all source files of the 'GTFSImporter' target in the 'GTFSImporter' project -// - -#ifdef __OBJC__ - #import -#endif diff --git a/iOS/GTFSImporteriOS/GTFSImporter/GTFSImporter.1 b/iOS/GTFSImporteriOS/GTFSImporter/GTFSImporter.1 deleted file mode 100644 index e845743..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/GTFSImporter.1 +++ /dev/null @@ -1,79 +0,0 @@ -.\"Modified from man(1) of FreeBSD, the NetBSD mdoc.template, and mdoc.samples. -.\"See Also: -.\"man mdoc.samples for a complete listing of options -.\"man mdoc for the short list of editing options -.\"/usr/share/misc/mdoc.template -.Dd 8/27/11 \" DATE -.Dt GTFSImporter 1 \" Program name and manual section number -.Os Darwin -.Sh NAME \" Section Header - required - don't modify -.Nm GTFSImporter, -.\" The following lines are read in generating the apropos(man -k) database. Use only key -.\" words here as the database is built based on the words here and in the .ND line. -.Nm Other_name_for_same_program(), -.Nm Yet another name for the same program. -.\" Use .Nm macro to designate other names for the documented program. -.Nd This line parsed for whatis database. -.Sh SYNOPSIS \" Section Header - required - don't modify -.Nm -.Op Fl abcd \" [-abcd] -.Op Fl a Ar path \" [-a path] -.Op Ar file \" [file] -.Op Ar \" [file ...] -.Ar arg0 \" Underlined argument - use .Ar anywhere to underline -arg2 ... \" Arguments -.Sh DESCRIPTION \" Section Header - required - don't modify -Use the .Nm macro to refer to your program throughout the man page like such: -.Nm -Underlining is accomplished with the .Ar macro like this: -.Ar underlined text . -.Pp \" Inserts a space -A list of items with descriptions: -.Bl -tag -width -indent \" Begins a tagged list -.It item a \" Each item preceded by .It macro -Description of item a -.It item b -Description of item b -.El \" Ends the list -.Pp -A list of flags and their descriptions: -.Bl -tag -width -indent \" Differs from above in tag removed -.It Fl a \"-a flag as a list item -Description of -a flag -.It Fl b -Description of -b flag -.El \" Ends the list -.Pp -.\" .Sh ENVIRONMENT \" May not be needed -.\" .Bl -tag -width "ENV_VAR_1" -indent \" ENV_VAR_1 is width of the string ENV_VAR_1 -.\" .It Ev ENV_VAR_1 -.\" Description of ENV_VAR_1 -.\" .It Ev ENV_VAR_2 -.\" Description of ENV_VAR_2 -.\" .El -.Sh FILES \" File used or created by the topic of the man page -.Bl -tag -width "/Users/joeuser/Library/really_long_file_name" -compact -.It Pa /usr/share/file_name -FILE_1 description -.It Pa /Users/joeuser/Library/really_long_file_name -FILE_2 description -.El \" Ends the list -.\" .Sh DIAGNOSTICS \" May not be needed -.\" .Bl -diag -.\" .It Diagnostic Tag -.\" Diagnostic informtion here. -.\" .It Diagnostic Tag -.\" Diagnostic informtion here. -.\" .El -.Sh SEE ALSO -.\" List links in ascending order by section, alphabetically within a section. -.\" Please do not reference files that do not exist without filing a bug report -.Xr a 1 , -.Xr b 1 , -.Xr c 1 , -.Xr a 2 , -.Xr b 2 , -.Xr a 3 , -.Xr b 3 -.\" .Sh BUGS \" Document known, unremedied bugs -.\" .Sh HISTORY \" Document history if command behaves in a unique manner \ No newline at end of file diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/CSVParser/CSVParser.h b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/CSVParser/CSVParser.h deleted file mode 100644 index 8b9e8d1..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/CSVParser/CSVParser.h +++ /dev/null @@ -1,60 +0,0 @@ -// -// CSVParser.h -// CSVImporter -// -// Created by Matt Gallagher on 2009/11/30. -// Copyright 2009 Matt Gallagher. All rights reserved. -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. Permission is granted to anyone to -// use this software for any purpose, including commercial applications, and to -// alter it and redistribute it freely, subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source -// distribution. -// - -#import - -@interface CSVParser : NSObject -{ - NSString *csvString; - NSString *separator; - NSScanner *scanner; - BOOL hasHeader; - NSMutableArray *fieldNames; - id receiver; - SEL receiverSelector; - NSCharacterSet *endTextCharacterSet; - BOOL separatorIsSingleChar; -} - -- (id)initWithString:(NSString *)aCSVString - separator:(NSString *)aSeparatorString - hasHeader:(BOOL)header - fieldNames:(NSArray *)names; - -- (NSArray *)arrayOfParsedRows; -- (void)parseRowsForReceiver:(id)aReceiver selector:(SEL)aSelector; - -- (NSArray *)parseFile; -- (NSMutableArray *)parseHeader; -- (NSDictionary *)parseRecord; -- (NSString *)parseName; -- (NSString *)parseField; -- (NSString *)parseEscaped; -- (NSString *)parseNonEscaped; -- (NSString *)parseDoubleQuote; -- (NSString *)parseSeparator; -- (NSString *)parseLineSeparator; -- (NSString *)parseTwoDoubleQuotes; -- (NSString *)parseTextData; - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/CSVParser/CSVParser.m b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/CSVParser/CSVParser.m deleted file mode 100644 index ff7397c..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/CSVParser/CSVParser.m +++ /dev/null @@ -1,520 +0,0 @@ -// -// CSVParser.m -// CSVImporter -// -// Created by Matt Gallagher on 2009/11/30. -// Copyright 2009 Matt Gallagher. All rights reserved. -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. Permission is granted to anyone to -// use this software for any purpose, including commercial applications, and to -// alter it and redistribute it freely, subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source -// distribution. -// - -#import "CSVParser.h" - - -@implementation CSVParser - -// -// initWithString:separator:hasHeader:fieldNames: -// -// Parameters: -// aCSVString - the string that will be parsed -// aSeparatorString - the separator (normally "," or "\t") -// header - if YES, treats the first row as a list of field names -// names - a list of field names (will have no effect if header is YES) -// -// returns the initialized object (nil on failure) -// -- (id)initWithString:(NSString *)aCSVString - separator:(NSString *)aSeparatorString - hasHeader:(BOOL)header - fieldNames:(NSArray *)names -{ - self = [super init]; - if (self) - { - csvString = [aCSVString retain]; - separator = [aSeparatorString retain]; - - NSAssert([separator length] > 0 && - [separator rangeOfString:@"\""].location == NSNotFound && - [separator rangeOfCharacterFromSet:[NSCharacterSet newlineCharacterSet]].location == NSNotFound, - @"CSV separator string must not be empty and must not contain the double quote character or newline characters."); - - NSMutableCharacterSet *endTextMutableCharacterSet = - [[NSCharacterSet newlineCharacterSet] mutableCopy]; - [endTextMutableCharacterSet addCharactersInString:@"\""]; - [endTextMutableCharacterSet addCharactersInString:[separator substringToIndex:1]]; - endTextCharacterSet = endTextMutableCharacterSet; - - if ([separator length] == 1) - { - separatorIsSingleChar = YES; - } - - hasHeader = header; - fieldNames = [names mutableCopy]; - } - - return self; -} - -// -// dealloc -// -// Releases instance memory. -// -- (void)dealloc -{ - [csvString release]; - [separator release]; - [fieldNames release]; - [endTextCharacterSet release]; - [super dealloc]; -} - - -// -// arrayOfParsedRows -// -// Performs a parsing of the csvString, returning the entire result. -// -// returns the array of all parsed row records -// -- (NSArray *)arrayOfParsedRows -{ - scanner = [[NSScanner alloc] initWithString:csvString]; - [scanner setCharactersToBeSkipped:[[[NSCharacterSet alloc] init] autorelease]]; - - NSArray *result = [self parseFile]; - [scanner release]; - scanner = nil; - - return result; -} - -// -// parseRowsForReceiver:selector: -// -// Performs a parsing of the csvString, sending the entries, 1 row at a time, -// to the receiver. -// -// Parameters: -// aReceiver - the target that will receive each row as it is parsed -// aSelector - the selector that will receive each row as it is parsed -// (should be a method that takes a single NSDictionary argument) -// -- (void)parseRowsForReceiver:(id)aReceiver selector:(SEL)aSelector -{ - scanner = [[NSScanner alloc] initWithString:csvString]; - [scanner setCharactersToBeSkipped:[[[NSCharacterSet alloc] init] autorelease]]; - receiver = [aReceiver retain]; - receiverSelector = aSelector; - - [self parseFile]; - - [scanner release]; - scanner = nil; - [receiver release]; - receiver = nil; -} - -// -// parseFile -// -// Attempts to parse a file from the current scan location. -// -// returns the parsed results if successful and receiver is nil, otherwise -// returns nil when done or on failure. -// -- (NSArray *)parseFile -{ - if (hasHeader) - { - if (fieldNames) - { - [fieldNames release]; - } - - fieldNames = [[self parseHeader] retain]; - if (!fieldNames || ![self parseLineSeparator]) - { - return nil; - } - } - - NSMutableArray *records = nil; - if (!receiver) - { - records = [NSMutableArray array]; - } - - NSDictionary *record = [[self parseRecord] retain]; - if (!record) - { - return nil; - } - - while (record) - { - NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; - - if (receiver) - { - [receiver performSelector:receiverSelector withObject:record]; - } - else - { - [records addObject:record]; - } - [record release]; - - if (![self parseLineSeparator]) - { - break; - } - - record = [[self parseRecord] retain]; - - [pool drain]; - } - - return records; -} - -// -// parseHeader -// -// Attempts to parse a header row from the current scan location. -// -// returns the array of parsed field names or nil on parse failure. -// -- (NSMutableArray *)parseHeader -{ - NSString *name = [self parseName]; - if (!name) - { - return nil; - } - - NSMutableArray *names = [NSMutableArray array]; - while (name) - { - [names addObject:name]; - - if (![self parseSeparator]) - { - break; - } - - name = [self parseName]; - } - return names; -} - -// -// parseRecord -// -// Attempts to parse a record from the current scan location. The record -// dictionary will use the fieldNames as keys, or FIELD_X for each column -// X-1 if no fieldName exists for a given column. -// -// returns the parsed record as a dictionary, or nil on failure. -// -- (NSDictionary *)parseRecord -{ - // - // Special case: return nil if the line is blank. Without this special case, - // it would parse as a single blank field. - // - if ([self parseLineSeparator] || [scanner isAtEnd]) - { - return nil; - } - - NSString *field = [self parseField]; - if (!field) - { - return nil; - } - - NSInteger fieldNamesCount = [fieldNames count]; - NSInteger fieldCount = 0; - - NSMutableDictionary *record = - [NSMutableDictionary dictionaryWithCapacity:[fieldNames count]]; - while (field) - { - NSString *fieldName; - if (fieldNamesCount > fieldCount) - { - fieldName = [fieldNames objectAtIndex:fieldCount]; - } - else - { - fieldName = [NSString stringWithFormat:@"FIELD_%ld", fieldCount + 1]; - [fieldNames addObject:fieldName]; - fieldNamesCount++; - } - - [record setObject:field forKey:fieldName]; - fieldCount++; - - if (![self parseSeparator]) - { - break; - } - - field = [self parseField]; - } - - return record; -} - -// -// parseName -// -// Attempts to parse a name from the current scan location. -// -// returns the name or nil. -// -- (NSString *)parseName -{ - return [self parseField]; -} - -// -// parseField -// -// Attempts to parse a field from the current scan location. -// -// returns the field or nil -// -- (NSString *)parseField -{ - NSString *escapedString = [self parseEscaped]; - if (escapedString) - { - return escapedString; - } - - NSString *nonEscapedString = [self parseNonEscaped]; - if (nonEscapedString) - { - return nonEscapedString; - } - - // - // Special case: if the current location is immediately - // followed by a separator, then the field is a valid, empty string. - // - NSInteger currentLocation = [scanner scanLocation]; - if ([self parseSeparator] || [self parseLineSeparator] || [scanner isAtEnd]) - { - [scanner setScanLocation:currentLocation]; - return @""; - } - - return nil; -} - -// -// parseEscaped -// -// Attempts to parse an escaped field value from the current scan location. -// -// returns the field value or nil. -// -- (NSString *)parseEscaped -{ - if (![self parseDoubleQuote]) - { - return nil; - } - - NSString *accumulatedData = [NSString string]; - while (YES) - { - NSString *fragment = [self parseTextData]; - if (!fragment) - { - fragment = [self parseSeparator]; - if (!fragment) - { - fragment = [self parseLineSeparator]; - if (!fragment) - { - if ([self parseTwoDoubleQuotes]) - { - fragment = @"\""; - } - else - { - break; - } - } - } - } - - accumulatedData = [accumulatedData stringByAppendingString:fragment]; - } - - if (![self parseDoubleQuote]) - { - return nil; - } - - return accumulatedData; -} - -// -// parseNonEscaped -// -// Attempts to parse a non-escaped field value from the current scan location. -// -// returns the field value or nil. -// -- (NSString *)parseNonEscaped -{ - return [self parseTextData]; -} - -// -// parseTwoDoubleQuotes -// -// Attempts to parse two double quotes from the current scan location. -// -// returns a string containing two double quotes or nil. -// -- (NSString *)parseTwoDoubleQuotes -{ - if ([scanner scanString:@"\"\"" intoString:NULL]) - { - return @"\"\""; - } - return nil; -} - -// -// parseDoubleQuote -// -// Attempts to parse a double quote from the current scan location. -// -// returns @"\"" or nil. -// -- (NSString *)parseDoubleQuote -{ - if ([scanner scanString:@"\"" intoString:NULL]) - { - return @"\""; - } - return nil; -} - -// -// parseSeparator -// -// Attempts to parse the separator string from the current scan location. -// -// returns the separator string or nil. -// -- (NSString *)parseSeparator -{ - if ([scanner scanString:separator intoString:NULL]) - { - return separator; - } - return nil; -} - -// -// parseLineSeparator -// -// Attempts to parse newline characters from the current scan location. -// -// returns a string containing one or more newline characters or nil. -// -- (NSString *)parseLineSeparator -{ - NSString *matchedNewlines = nil; - [scanner - scanCharactersFromSet:[NSCharacterSet newlineCharacterSet] - intoString:&matchedNewlines]; - return matchedNewlines; -} - -// -// parseTextData -// -// Attempts to parse text data from the current scan location. -// -// returns a non-zero length string or nil. -// -- (NSString *)parseTextData -{ - NSString *accumulatedData = [NSString string]; - while (YES) - { - NSString *fragment; - if ([scanner scanUpToCharactersFromSet:endTextCharacterSet intoString:&fragment]) - { - accumulatedData = [accumulatedData stringByAppendingString:fragment]; - } - - // - // If the separator is just a single character (common case) then - // we know we've reached the end of parseable text - // - if (separatorIsSingleChar) - { - break; - } - - // - // Otherwise, we need to consider the case where the first character - // of the separator is matched but we don't have the full separator. - // - NSUInteger location = [scanner scanLocation]; - NSString *firstCharOfSeparator; - if ([scanner scanString:[separator substringToIndex:1] intoString:&firstCharOfSeparator]) - { - if ([scanner scanString:[separator substringFromIndex:1] intoString:NULL]) - { - [scanner setScanLocation:location]; - break; - } - - // - // We have the first char of the separator but not the whole - // separator, so just append the char and continue - // - accumulatedData = [accumulatedData stringByAppendingString:firstCharOfSeparator]; - continue; - } - else - { - break; - } - } - - if ([accumulatedData length] > 0) - { - return accumulatedData; - } - - return nil; -} - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabase.h b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabase.h deleted file mode 100644 index 843e5ae..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabase.h +++ /dev/null @@ -1,155 +0,0 @@ -#import -#import "sqlite3.h" -#import "FMResultSet.h" -#import "FMDatabasePool.h" - - -#if ! __has_feature(objc_arc) - #define FMDBAutorelease(__v) ([__v autorelease]); - #define FMDBReturnAutoreleased FMDBAutorelease - - #define FMDBRetain(__v) ([__v retain]); - #define FMDBReturnRetained FMDBRetain - - #define FMDBRelease(__v) ([__v release]); - - #define FMDBDispatchQueueRelease(__v) (dispatch_release(__v)); -#else - // -fobjc-arc - #define FMDBAutorelease(__v) - #define FMDBReturnAutoreleased(__v) (__v) - - #define FMDBRetain(__v) - #define FMDBReturnRetained(__v) (__v) - - #define FMDBRelease(__v) - - #if TARGET_OS_IPHONE - // Compiling for iOS - #if __IPHONE_OS_VERSION_MIN_REQUIRED >= 60000 - // iOS 6.0 or later - #define FMDBDispatchQueueRelease(__v) - #else - // iOS 5.X or earlier - #define FMDBDispatchQueueRelease(__v) (dispatch_release(__v)); - #endif - #else - // Compiling for Mac OS X - #if MAC_OS_X_VERSION_MIN_REQUIRED >= 1080 - // Mac OS X 10.8 or later - #define FMDBDispatchQueueRelease(__v) - #else - // Mac OS X 10.7 or earlier - #define FMDBDispatchQueueRelease(__v) (dispatch_release(__v)); - #endif - #endif -#endif - - -@interface FMDatabase : NSObject { - - sqlite3* _db; - NSString* _databasePath; - BOOL _logsErrors; - BOOL _crashOnErrors; - BOOL _traceExecution; - BOOL _checkedOut; - BOOL _shouldCacheStatements; - BOOL _isExecutingStatement; - BOOL _inTransaction; - int _busyRetryTimeout; - - NSMutableDictionary *_cachedStatements; - NSMutableSet *_openResultSets; - NSMutableSet *_openFunctions; - -} - - -@property (atomic, assign) BOOL traceExecution; -@property (atomic, assign) BOOL checkedOut; -@property (atomic, assign) int busyRetryTimeout; -@property (atomic, assign) BOOL crashOnErrors; -@property (atomic, assign) BOOL logsErrors; -@property (atomic, retain) NSMutableDictionary *cachedStatements; - - -+ (id)databaseWithPath:(NSString*)inPath; -- (id)initWithPath:(NSString*)inPath; - -- (BOOL)open; -#if SQLITE_VERSION_NUMBER >= 3005000 -- (BOOL)openWithFlags:(int)flags; -#endif -- (BOOL)close; -- (BOOL)goodConnection; -- (void)clearCachedStatements; -- (void)closeOpenResultSets; -- (BOOL)hasOpenResultSets; - -// encryption methods. You need to have purchased the sqlite encryption extensions for these to work. -- (BOOL)setKey:(NSString*)key; -- (BOOL)rekey:(NSString*)key; - -- (NSString *)databasePath; - -- (NSString*)lastErrorMessage; - -- (int)lastErrorCode; -- (BOOL)hadError; -- (NSError*)lastError; - -- (sqlite_int64)lastInsertRowId; - -- (sqlite3*)sqliteHandle; - -- (BOOL)update:(NSString*)sql withErrorAndBindings:(NSError**)outErr, ...; -- (BOOL)executeUpdate:(NSString*)sql, ...; -- (BOOL)executeUpdateWithFormat:(NSString *)format, ...; -- (BOOL)executeUpdate:(NSString*)sql withArgumentsInArray:(NSArray *)arguments; -- (BOOL)executeUpdate:(NSString*)sql withParameterDictionary:(NSDictionary *)arguments; - -- (FMResultSet *)executeQuery:(NSString*)sql, ...; -- (FMResultSet *)executeQueryWithFormat:(NSString*)format, ...; -- (FMResultSet *)executeQuery:(NSString *)sql withArgumentsInArray:(NSArray *)arguments; -- (FMResultSet *)executeQuery:(NSString *)sql withParameterDictionary:(NSDictionary *)arguments; - -- (BOOL)rollback; -- (BOOL)commit; -- (BOOL)beginTransaction; -- (BOOL)beginDeferredTransaction; -- (BOOL)inTransaction; -- (BOOL)shouldCacheStatements; -- (void)setShouldCacheStatements:(BOOL)value; - -#if SQLITE_VERSION_NUMBER >= 3007000 -- (BOOL)startSavePointWithName:(NSString*)name error:(NSError**)outErr; -- (BOOL)releaseSavePointWithName:(NSString*)name error:(NSError**)outErr; -- (BOOL)rollbackToSavePointWithName:(NSString*)name error:(NSError**)outErr; -- (NSError*)inSavePoint:(void (^)(BOOL *rollback))block; -#endif - -+ (BOOL)isSQLiteThreadSafe; -+ (NSString*)sqliteLibVersion; - -- (int)changes; - -- (void)makeFunctionNamed:(NSString*)name maximumArguments:(int)count withBlock:(void (^)(sqlite3_context *context, int argc, sqlite3_value **argv))block; - -@end - -@interface FMStatement : NSObject { - sqlite3_stmt *_statement; - NSString *_query; - long _useCount; -} - -@property (atomic, assign) long useCount; -@property (atomic, retain) NSString *query; -@property (atomic, assign) sqlite3_stmt *statement; - -- (void)close; -- (void)reset; - -@end - diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabase.m b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabase.m deleted file mode 100644 index d4841af..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabase.m +++ /dev/null @@ -1,1148 +0,0 @@ -#import "FMDatabase.h" -#import "unistd.h" -#import - -@interface FMDatabase () - -- (FMResultSet *)executeQuery:(NSString *)sql withArgumentsInArray:(NSArray*)arrayArgs orDictionary:(NSDictionary *)dictionaryArgs orVAList:(va_list)args; -- (BOOL)executeUpdate:(NSString*)sql error:(NSError**)outErr withArgumentsInArray:(NSArray*)arrayArgs orDictionary:(NSDictionary *)dictionaryArgs orVAList:(va_list)args; -@end - -@implementation FMDatabase -@synthesize cachedStatements=_cachedStatements; -@synthesize logsErrors=_logsErrors; -@synthesize crashOnErrors=_crashOnErrors; -@synthesize busyRetryTimeout=_busyRetryTimeout; -@synthesize checkedOut=_checkedOut; -@synthesize traceExecution=_traceExecution; - -+ (id)databaseWithPath:(NSString*)aPath { - return FMDBReturnAutoreleased([[self alloc] initWithPath:aPath]); -} - -+ (NSString*)sqliteLibVersion { - return [NSString stringWithFormat:@"%s", sqlite3_libversion()]; -} - -+ (BOOL)isSQLiteThreadSafe { - // make sure to read the sqlite headers on this guy! - return sqlite3_threadsafe() != 0; -} - -- (id)initWithPath:(NSString*)aPath { - - assert(sqlite3_threadsafe()); // whoa there big boy- gotta make sure sqlite it happy with what we're going to do. - - self = [super init]; - - if (self) { - _databasePath = [aPath copy]; - _openResultSets = [[NSMutableSet alloc] init]; - _db = 0x00; - _logsErrors = 0x00; - _crashOnErrors = 0x00; - _busyRetryTimeout = 0x00; - } - - return self; -} - -- (void)finalize { - [self close]; - [super finalize]; -} - -- (void)dealloc { - [self close]; - FMDBRelease(_openResultSets); - FMDBRelease(_cachedStatements); - FMDBRelease(_databasePath); - FMDBRelease(_openFunctions); - -#if ! __has_feature(objc_arc) - [super dealloc]; -#endif -} - -- (NSString *)databasePath { - return _databasePath; -} - -- (sqlite3*)sqliteHandle { - return _db; -} - -- (BOOL)open { - if (_db) { - return YES; - } - - int err = sqlite3_open((_databasePath ? [_databasePath fileSystemRepresentation] : ":memory:"), &_db ); - if(err != SQLITE_OK) { - NSLog(@"error opening!: %d", err); - return NO; - } - - return YES; -} - -#if SQLITE_VERSION_NUMBER >= 3005000 -- (BOOL)openWithFlags:(int)flags { - int err = sqlite3_open_v2((_databasePath ? [_databasePath fileSystemRepresentation] : ":memory:"), &_db, flags, NULL /* Name of VFS module to use */); - if(err != SQLITE_OK) { - NSLog(@"error opening!: %d", err); - return NO; - } - return YES; -} -#endif - - -- (BOOL)close { - - [self clearCachedStatements]; - [self closeOpenResultSets]; - - if (!_db) { - return YES; - } - - int rc; - BOOL retry; - int numberOfRetries = 0; - BOOL triedFinalizingOpenStatements = NO; - - do { - retry = NO; - rc = sqlite3_close(_db); - - if (SQLITE_BUSY == rc || SQLITE_LOCKED == rc) { - - retry = YES; - usleep(20); - - if (_busyRetryTimeout && (numberOfRetries++ > _busyRetryTimeout)) { - NSLog(@"%s:%d", __FUNCTION__, __LINE__); - NSLog(@"Database busy, unable to close"); - return NO; - } - - if (!triedFinalizingOpenStatements) { - triedFinalizingOpenStatements = YES; - sqlite3_stmt *pStmt; - while ((pStmt = sqlite3_next_stmt(_db, 0x00)) !=0) { - NSLog(@"Closing leaked statement"); - sqlite3_finalize(pStmt); - } - } - } - else if (SQLITE_OK != rc) { - NSLog(@"error closing!: %d", rc); - } - } - while (retry); - - _db = nil; - return YES; -} - -- (void)clearCachedStatements { - - for (FMStatement *cachedStmt in [_cachedStatements objectEnumerator]) { - [cachedStmt close]; - } - - [_cachedStatements removeAllObjects]; -} - -- (BOOL)hasOpenResultSets { - return [_openResultSets count] > 0; -} - -- (void)closeOpenResultSets { - - //Copy the set so we don't get mutation errors - NSMutableSet *openSetCopy = FMDBReturnAutoreleased([_openResultSets copy]); - for (NSValue *rsInWrappedInATastyValueMeal in openSetCopy) { - FMResultSet *rs = (FMResultSet *)[rsInWrappedInATastyValueMeal pointerValue]; - - [rs setParentDB:nil]; - [rs close]; - - [_openResultSets removeObject:rsInWrappedInATastyValueMeal]; - } -} - -- (void)resultSetDidClose:(FMResultSet *)resultSet { - NSValue *setValue = [NSValue valueWithNonretainedObject:resultSet]; - - [_openResultSets removeObject:setValue]; -} - -- (FMStatement*)cachedStatementForQuery:(NSString*)query { - return [_cachedStatements objectForKey:query]; -} - -- (void)setCachedStatement:(FMStatement*)statement forQuery:(NSString*)query { - - query = [query copy]; // in case we got handed in a mutable string... - - [statement setQuery:query]; - - [_cachedStatements setObject:statement forKey:query]; - - FMDBRelease(query); -} - - -- (BOOL)rekey:(NSString*)key { -#ifdef SQLITE_HAS_CODEC - if (!key) { - return NO; - } - - int rc = sqlite3_rekey(_db, [key UTF8String], (int)strlen([key UTF8String])); - - if (rc != SQLITE_OK) { - NSLog(@"error on rekey: %d", rc); - NSLog(@"%@", [self lastErrorMessage]); - } - - return (rc == SQLITE_OK); -#else - return NO; -#endif -} - -- (BOOL)setKey:(NSString*)key { -#ifdef SQLITE_HAS_CODEC - if (!key) { - return NO; - } - - int rc = sqlite3_key(_db, [key UTF8String], (int)strlen([key UTF8String])); - - return (rc == SQLITE_OK); -#else - return NO; -#endif -} - -- (BOOL)goodConnection { - - if (!_db) { - return NO; - } - - FMResultSet *rs = [self executeQuery:@"select name from sqlite_master where type='table'"]; - - if (rs) { - [rs close]; - return YES; - } - - return NO; -} - -- (void)warnInUse { - NSLog(@"The FMDatabase %@ is currently in use.", self); - -#ifndef NS_BLOCK_ASSERTIONS - if (_crashOnErrors) { - abort(); - NSAssert1(false, @"The FMDatabase %@ is currently in use.", self); - } -#endif -} - -- (BOOL)databaseExists { - - if (!_db) { - - NSLog(@"The FMDatabase %@ is not open.", self); - - #ifndef NS_BLOCK_ASSERTIONS - if (_crashOnErrors) { - abort(); - NSAssert1(false, @"The FMDatabase %@ is not open.", self); - } - #endif - - return NO; - } - - return YES; -} - -- (NSString*)lastErrorMessage { - return [NSString stringWithUTF8String:sqlite3_errmsg(_db)]; -} - -- (BOOL)hadError { - int lastErrCode = [self lastErrorCode]; - - return (lastErrCode > SQLITE_OK && lastErrCode < SQLITE_ROW); -} - -- (int)lastErrorCode { - return sqlite3_errcode(_db); -} - - -- (NSError*)errorWithMessage:(NSString*)message { - NSDictionary* errorMessage = [NSDictionary dictionaryWithObject:message forKey:NSLocalizedDescriptionKey]; - - return [NSError errorWithDomain:@"FMDatabase" code:sqlite3_errcode(_db) userInfo:errorMessage]; -} - -- (NSError*)lastError { - return [self errorWithMessage:[self lastErrorMessage]]; -} - -- (sqlite_int64)lastInsertRowId { - - if (_isExecutingStatement) { - [self warnInUse]; - return NO; - } - - _isExecutingStatement = YES; - - sqlite_int64 ret = sqlite3_last_insert_rowid(_db); - - _isExecutingStatement = NO; - - return ret; -} - -- (int)changes { - if (_isExecutingStatement) { - [self warnInUse]; - return 0; - } - - _isExecutingStatement = YES; - - int ret = sqlite3_changes(_db); - - _isExecutingStatement = NO; - - return ret; -} - -- (void)bindObject:(id)obj toColumn:(int)idx inStatement:(sqlite3_stmt*)pStmt { - - if ((!obj) || ((NSNull *)obj == [NSNull null])) { - sqlite3_bind_null(pStmt, idx); - } - - // FIXME - someday check the return codes on these binds. - else if ([obj isKindOfClass:[NSData class]]) { - const void *bytes = [obj bytes]; - if (!bytes) { - // it's an empty NSData object, aka [NSData data]. - // Don't pass a NULL pointer, or sqlite will bind a SQL null instead of a blob. - bytes = ""; - } - sqlite3_bind_blob(pStmt, idx, bytes, (int)[obj length], SQLITE_STATIC); - } - else if ([obj isKindOfClass:[NSDate class]]) { - sqlite3_bind_double(pStmt, idx, [obj timeIntervalSince1970]); - } - else if ([obj isKindOfClass:[NSNumber class]]) { - - if (strcmp([obj objCType], @encode(BOOL)) == 0) { - sqlite3_bind_int(pStmt, idx, ([obj boolValue] ? 1 : 0)); - } - else if (strcmp([obj objCType], @encode(int)) == 0) { - sqlite3_bind_int64(pStmt, idx, [obj longValue]); - } - else if (strcmp([obj objCType], @encode(long)) == 0) { - sqlite3_bind_int64(pStmt, idx, [obj longValue]); - } - else if (strcmp([obj objCType], @encode(long long)) == 0) { - sqlite3_bind_int64(pStmt, idx, [obj longLongValue]); - } - else if (strcmp([obj objCType], @encode(unsigned long long)) == 0) { - sqlite3_bind_int64(pStmt, idx, (long long)[obj unsignedLongLongValue]); - } - else if (strcmp([obj objCType], @encode(float)) == 0) { - sqlite3_bind_double(pStmt, idx, [obj floatValue]); - } - else if (strcmp([obj objCType], @encode(double)) == 0) { - sqlite3_bind_double(pStmt, idx, [obj doubleValue]); - } - else { - sqlite3_bind_text(pStmt, idx, [[obj description] UTF8String], -1, SQLITE_STATIC); - } - } - else { - sqlite3_bind_text(pStmt, idx, [[obj description] UTF8String], -1, SQLITE_STATIC); - } -} - -- (void)extractSQL:(NSString *)sql argumentsList:(va_list)args intoString:(NSMutableString *)cleanedSQL arguments:(NSMutableArray *)arguments { - - NSUInteger length = [sql length]; - unichar last = '\0'; - for (NSUInteger i = 0; i < length; ++i) { - id arg = nil; - unichar current = [sql characterAtIndex:i]; - unichar add = current; - if (last == '%') { - switch (current) { - case '@': - arg = va_arg(args, id); - break; - case 'c': - // warning: second argument to 'va_arg' is of promotable type 'char'; this va_arg has undefined behavior because arguments will be promoted to 'int' - arg = [NSString stringWithFormat:@"%c", va_arg(args, int)]; - break; - case 's': - arg = [NSString stringWithUTF8String:va_arg(args, char*)]; - break; - case 'd': - case 'D': - case 'i': - arg = [NSNumber numberWithInt:va_arg(args, int)]; - break; - case 'u': - case 'U': - arg = [NSNumber numberWithUnsignedInt:va_arg(args, unsigned int)]; - break; - case 'h': - i++; - if (i < length && [sql characterAtIndex:i] == 'i') { - // warning: second argument to 'va_arg' is of promotable type 'short'; this va_arg has undefined behavior because arguments will be promoted to 'int' - arg = [NSNumber numberWithShort:(short)(va_arg(args, int))]; - } - else if (i < length && [sql characterAtIndex:i] == 'u') { - // warning: second argument to 'va_arg' is of promotable type 'unsigned short'; this va_arg has undefined behavior because arguments will be promoted to 'int' - arg = [NSNumber numberWithUnsignedShort:(unsigned short)(va_arg(args, uint))]; - } - else { - i--; - } - break; - case 'q': - i++; - if (i < length && [sql characterAtIndex:i] == 'i') { - arg = [NSNumber numberWithLongLong:va_arg(args, long long)]; - } - else if (i < length && [sql characterAtIndex:i] == 'u') { - arg = [NSNumber numberWithUnsignedLongLong:va_arg(args, unsigned long long)]; - } - else { - i--; - } - break; - case 'f': - arg = [NSNumber numberWithDouble:va_arg(args, double)]; - break; - case 'g': - // warning: second argument to 'va_arg' is of promotable type 'float'; this va_arg has undefined behavior because arguments will be promoted to 'double' - arg = [NSNumber numberWithFloat:(float)(va_arg(args, double))]; - break; - case 'l': - i++; - if (i < length) { - unichar next = [sql characterAtIndex:i]; - if (next == 'l') { - i++; - if (i < length && [sql characterAtIndex:i] == 'd') { - //%lld - arg = [NSNumber numberWithLongLong:va_arg(args, long long)]; - } - else if (i < length && [sql characterAtIndex:i] == 'u') { - //%llu - arg = [NSNumber numberWithUnsignedLongLong:va_arg(args, unsigned long long)]; - } - else { - i--; - } - } - else if (next == 'd') { - //%ld - arg = [NSNumber numberWithLong:va_arg(args, long)]; - } - else if (next == 'u') { - //%lu - arg = [NSNumber numberWithUnsignedLong:va_arg(args, unsigned long)]; - } - else { - i--; - } - } - else { - i--; - } - break; - default: - // something else that we can't interpret. just pass it on through like normal - break; - } - } - else if (current == '%') { - // percent sign; skip this character - add = '\0'; - } - - if (arg != nil) { - [cleanedSQL appendString:@"?"]; - [arguments addObject:arg]; - } - else if (add != '\0') { - [cleanedSQL appendFormat:@"%C", add]; - } - last = current; - } -} - -- (FMResultSet *)executeQuery:(NSString *)sql withParameterDictionary:(NSDictionary *)arguments { - return [self executeQuery:sql withArgumentsInArray:nil orDictionary:arguments orVAList:nil]; -} - -- (FMResultSet *)executeQuery:(NSString *)sql withArgumentsInArray:(NSArray*)arrayArgs orDictionary:(NSDictionary *)dictionaryArgs orVAList:(va_list)args { - - if (![self databaseExists]) { - return 0x00; - } - - if (_isExecutingStatement) { - [self warnInUse]; - return 0x00; - } - - _isExecutingStatement = YES; - - int rc = 0x00; - sqlite3_stmt *pStmt = 0x00; - FMStatement *statement = 0x00; - FMResultSet *rs = 0x00; - - if (_traceExecution && sql) { - NSLog(@"%@ executeQuery: %@", self, sql); - } - - if (_shouldCacheStatements) { - statement = [self cachedStatementForQuery:sql]; - pStmt = statement ? [statement statement] : 0x00; - [statement reset]; - } - - int numberOfRetries = 0; - BOOL retry = NO; - - if (!pStmt) { - do { - retry = NO; - rc = sqlite3_prepare_v2(_db, [sql UTF8String], -1, &pStmt, 0); - - if (SQLITE_BUSY == rc || SQLITE_LOCKED == rc) { - retry = YES; - usleep(20); - - if (_busyRetryTimeout && (numberOfRetries++ > _busyRetryTimeout)) { - NSLog(@"%s:%d Database busy (%@)", __FUNCTION__, __LINE__, [self databasePath]); - NSLog(@"Database busy"); - sqlite3_finalize(pStmt); - _isExecutingStatement = NO; - return nil; - } - } - else if (SQLITE_OK != rc) { - - if (_logsErrors) { - NSLog(@"DB Error: %d \"%@\"", [self lastErrorCode], [self lastErrorMessage]); - NSLog(@"DB Query: %@", sql); - NSLog(@"DB Path: %@", _databasePath); -#ifndef NS_BLOCK_ASSERTIONS - if (_crashOnErrors) { - abort(); - NSAssert2(false, @"DB Error: %d \"%@\"", [self lastErrorCode], [self lastErrorMessage]); - } -#endif - } - - sqlite3_finalize(pStmt); - _isExecutingStatement = NO; - return nil; - } - } - while (retry); - } - - id obj; - int idx = 0; - int queryCount = sqlite3_bind_parameter_count(pStmt); // pointed out by Dominic Yu (thanks!) - - // If dictionaryArgs is passed in, that means we are using sqlite's named parameter support - if (dictionaryArgs) { - - for (NSString *dictionaryKey in [dictionaryArgs allKeys]) { - - // Prefix the key with a colon. - NSString *parameterName = [[NSString alloc] initWithFormat:@":%@", dictionaryKey]; - - // Get the index for the parameter name. - int namedIdx = sqlite3_bind_parameter_index(pStmt, [parameterName UTF8String]); - - FMDBRelease(parameterName); - - if (namedIdx > 0) { - // Standard binding from here. - [self bindObject:[dictionaryArgs objectForKey:dictionaryKey] toColumn:namedIdx inStatement:pStmt]; - // increment the binding count, so our check below works out - idx++; - } - else { - NSLog(@"Could not find index for %@", dictionaryKey); - } - } - } - else { - - while (idx < queryCount) { - - if (arrayArgs) { - obj = [arrayArgs objectAtIndex:(NSUInteger)idx]; - } - else { - obj = va_arg(args, id); - } - - if (_traceExecution) { - NSLog(@"obj: %@", obj); - } - - idx++; - - [self bindObject:obj toColumn:idx inStatement:pStmt]; - } - } - - if (idx != queryCount) { - NSLog(@"Error: the bind count is not correct for the # of variables (executeQuery)"); - sqlite3_finalize(pStmt); - _isExecutingStatement = NO; - return nil; - } - - FMDBRetain(statement); // to balance the release below - - if (!statement) { - statement = [[FMStatement alloc] init]; - [statement setStatement:pStmt]; - - if (_shouldCacheStatements) { - [self setCachedStatement:statement forQuery:sql]; - } - } - - // the statement gets closed in rs's dealloc or [rs close]; - rs = [FMResultSet resultSetWithStatement:statement usingParentDatabase:self]; - [rs setQuery:sql]; - - NSValue *openResultSet = [NSValue valueWithNonretainedObject:rs]; - [_openResultSets addObject:openResultSet]; - - [statement setUseCount:[statement useCount] + 1]; - - FMDBRelease(statement); - - _isExecutingStatement = NO; - - return rs; -} - -- (FMResultSet *)executeQuery:(NSString*)sql, ... { - va_list args; - va_start(args, sql); - - id result = [self executeQuery:sql withArgumentsInArray:nil orDictionary:nil orVAList:args]; - - va_end(args); - return result; -} - -- (FMResultSet *)executeQueryWithFormat:(NSString*)format, ... { - va_list args; - va_start(args, format); - - NSMutableString *sql = [NSMutableString stringWithCapacity:[format length]]; - NSMutableArray *arguments = [NSMutableArray array]; - [self extractSQL:format argumentsList:args intoString:sql arguments:arguments]; - - va_end(args); - - return [self executeQuery:sql withArgumentsInArray:arguments]; -} - -- (FMResultSet *)executeQuery:(NSString *)sql withArgumentsInArray:(NSArray *)arguments { - return [self executeQuery:sql withArgumentsInArray:arguments orDictionary:nil orVAList:nil]; -} - -- (BOOL)executeUpdate:(NSString*)sql error:(NSError**)outErr withArgumentsInArray:(NSArray*)arrayArgs orDictionary:(NSDictionary *)dictionaryArgs orVAList:(va_list)args { - - if (![self databaseExists]) { - return NO; - } - - if (_isExecutingStatement) { - [self warnInUse]; - return NO; - } - - _isExecutingStatement = YES; - - int rc = 0x00; - sqlite3_stmt *pStmt = 0x00; - FMStatement *cachedStmt = 0x00; - - if (_traceExecution && sql) { - NSLog(@"%@ executeUpdate: %@", self, sql); - } - - if (_shouldCacheStatements) { - cachedStmt = [self cachedStatementForQuery:sql]; - pStmt = cachedStmt ? [cachedStmt statement] : 0x00; - [cachedStmt reset]; - } - - int numberOfRetries = 0; - BOOL retry = NO; - - if (!pStmt) { - - do { - retry = NO; - rc = sqlite3_prepare_v2(_db, [sql UTF8String], -1, &pStmt, 0); - if (SQLITE_BUSY == rc || SQLITE_LOCKED == rc) { - retry = YES; - usleep(20); - - if (_busyRetryTimeout && (numberOfRetries++ > _busyRetryTimeout)) { - NSLog(@"%s:%d Database busy (%@)", __FUNCTION__, __LINE__, [self databasePath]); - NSLog(@"Database busy"); - sqlite3_finalize(pStmt); - _isExecutingStatement = NO; - return NO; - } - } - else if (SQLITE_OK != rc) { - - if (_logsErrors) { - NSLog(@"DB Error: %d \"%@\"", [self lastErrorCode], [self lastErrorMessage]); - NSLog(@"DB Query: %@", sql); - NSLog(@"DB Path: %@", _databasePath); -#ifndef NS_BLOCK_ASSERTIONS - if (_crashOnErrors) { - abort(); - NSAssert2(false, @"DB Error: %d \"%@\"", [self lastErrorCode], [self lastErrorMessage]); - } -#endif - } - - sqlite3_finalize(pStmt); - - if (outErr) { - *outErr = [self errorWithMessage:[NSString stringWithUTF8String:sqlite3_errmsg(_db)]]; - } - - _isExecutingStatement = NO; - return NO; - } - } - while (retry); - } - - id obj; - int idx = 0; - int queryCount = sqlite3_bind_parameter_count(pStmt); - - // If dictionaryArgs is passed in, that means we are using sqlite's named parameter support - if (dictionaryArgs) { - - for (NSString *dictionaryKey in [dictionaryArgs allKeys]) { - - // Prefix the key with a colon. - NSString *parameterName = [[NSString alloc] initWithFormat:@":%@", dictionaryKey]; - - // Get the index for the parameter name. - int namedIdx = sqlite3_bind_parameter_index(pStmt, [parameterName UTF8String]); - - FMDBRelease(parameterName); - - if (namedIdx > 0) { - // Standard binding from here. - [self bindObject:[dictionaryArgs objectForKey:dictionaryKey] toColumn:namedIdx inStatement:pStmt]; - - // increment the binding count, so our check below works out - idx++; - } - else { - NSLog(@"Could not find index for %@", dictionaryKey); - } - } - } - else { - - while (idx < queryCount) { - - if (arrayArgs) { - obj = [arrayArgs objectAtIndex:(NSUInteger)idx]; - } - else { - obj = va_arg(args, id); - } - - if (_traceExecution) { - NSLog(@"obj: %@", obj); - } - - idx++; - - [self bindObject:obj toColumn:idx inStatement:pStmt]; - } - } - - - if (idx != queryCount) { - NSLog(@"Error: the bind count (%d) is not correct for the # of variables in the query (%d) (%@) (executeUpdate)", idx, queryCount, sql); - sqlite3_finalize(pStmt); - _isExecutingStatement = NO; - return NO; - } - - /* Call sqlite3_step() to run the virtual machine. Since the SQL being - ** executed is not a SELECT statement, we assume no data will be returned. - */ - numberOfRetries = 0; - - do { - rc = sqlite3_step(pStmt); - retry = NO; - - if (SQLITE_BUSY == rc || SQLITE_LOCKED == rc) { - // this will happen if the db is locked, like if we are doing an update or insert. - // in that case, retry the step... and maybe wait just 10 milliseconds. - retry = YES; - if (SQLITE_LOCKED == rc) { - rc = sqlite3_reset(pStmt); - if (rc != SQLITE_LOCKED) { - NSLog(@"Unexpected result from sqlite3_reset (%d) eu", rc); - } - } - usleep(20); - - if (_busyRetryTimeout && (numberOfRetries++ > _busyRetryTimeout)) { - NSLog(@"%s:%d Database busy (%@)", __FUNCTION__, __LINE__, [self databasePath]); - NSLog(@"Database busy"); - retry = NO; - } - } - else if (SQLITE_DONE == rc) { - // all is well, let's return. - } - else if (SQLITE_ERROR == rc) { - NSLog(@"Error calling sqlite3_step (%d: %s) SQLITE_ERROR", rc, sqlite3_errmsg(_db)); - NSLog(@"DB Query: %@", sql); - } - else if (SQLITE_MISUSE == rc) { - // uh oh. - NSLog(@"Error calling sqlite3_step (%d: %s) SQLITE_MISUSE", rc, sqlite3_errmsg(_db)); - NSLog(@"DB Query: %@", sql); - } - else { - // wtf? - NSLog(@"Unknown error calling sqlite3_step (%d: %s) eu", rc, sqlite3_errmsg(_db)); - NSLog(@"DB Query: %@", sql); - } - - } while (retry); - - if (rc == SQLITE_ROW) { - NSAssert1(NO, @"A executeUpdate is being called with a query string '%@'", sql); - } - - if (_shouldCacheStatements && !cachedStmt) { - cachedStmt = [[FMStatement alloc] init]; - - [cachedStmt setStatement:pStmt]; - - [self setCachedStatement:cachedStmt forQuery:sql]; - - FMDBRelease(cachedStmt); - } - - int closeErrorCode; - - if (cachedStmt) { - [cachedStmt setUseCount:[cachedStmt useCount] + 1]; - closeErrorCode = sqlite3_reset(pStmt); - } - else { - /* Finalize the virtual machine. This releases all memory and other - ** resources allocated by the sqlite3_prepare() call above. - */ - closeErrorCode = sqlite3_finalize(pStmt); - } - - if (closeErrorCode != SQLITE_OK) { - NSLog(@"Unknown error finalizing or resetting statement (%d: %s)", closeErrorCode, sqlite3_errmsg(_db)); - NSLog(@"DB Query: %@", sql); - } - - _isExecutingStatement = NO; - return (rc == SQLITE_DONE || rc == SQLITE_OK); -} - - -- (BOOL)executeUpdate:(NSString*)sql, ... { - va_list args; - va_start(args, sql); - - BOOL result = [self executeUpdate:sql error:nil withArgumentsInArray:nil orDictionary:nil orVAList:args]; - - va_end(args); - return result; -} - -- (BOOL)executeUpdate:(NSString*)sql withArgumentsInArray:(NSArray *)arguments { - return [self executeUpdate:sql error:nil withArgumentsInArray:arguments orDictionary:nil orVAList:nil]; -} - -- (BOOL)executeUpdate:(NSString*)sql withParameterDictionary:(NSDictionary *)arguments { - return [self executeUpdate:sql error:nil withArgumentsInArray:nil orDictionary:arguments orVAList:nil]; -} - -- (BOOL)executeUpdateWithFormat:(NSString*)format, ... { - va_list args; - va_start(args, format); - - NSMutableString *sql = [NSMutableString stringWithCapacity:[format length]]; - NSMutableArray *arguments = [NSMutableArray array]; - - [self extractSQL:format argumentsList:args intoString:sql arguments:arguments]; - - va_end(args); - - return [self executeUpdate:sql withArgumentsInArray:arguments]; -} - -- (BOOL)update:(NSString*)sql withErrorAndBindings:(NSError**)outErr, ... { - va_list args; - va_start(args, outErr); - - BOOL result = [self executeUpdate:sql error:outErr withArgumentsInArray:nil orDictionary:nil orVAList:args]; - - va_end(args); - return result; -} - -- (BOOL)rollback { - BOOL b = [self executeUpdate:@"rollback transaction"]; - - if (b) { - _inTransaction = NO; - } - - return b; -} - -- (BOOL)commit { - BOOL b = [self executeUpdate:@"commit transaction"]; - - if (b) { - _inTransaction = NO; - } - - return b; -} - -- (BOOL)beginDeferredTransaction { - - BOOL b = [self executeUpdate:@"begin deferred transaction"]; - if (b) { - _inTransaction = YES; - } - - return b; -} - -- (BOOL)beginTransaction { - - BOOL b = [self executeUpdate:@"begin exclusive transaction"]; - if (b) { - _inTransaction = YES; - } - - return b; -} - -- (BOOL)inTransaction { - return _inTransaction; -} - -#if SQLITE_VERSION_NUMBER >= 3007000 - -- (BOOL)startSavePointWithName:(NSString*)name error:(NSError**)outErr { - - // FIXME: make sure the savepoint name doesn't have a ' in it. - - NSParameterAssert(name); - - if (![self executeUpdate:[NSString stringWithFormat:@"savepoint '%@';", name]]) { - - if (*outErr) { - *outErr = [self lastError]; - } - - return NO; - } - - return YES; -} - -- (BOOL)releaseSavePointWithName:(NSString*)name error:(NSError**)outErr { - - NSParameterAssert(name); - - BOOL worked = [self executeUpdate:[NSString stringWithFormat:@"release savepoint '%@';", name]]; - - if (!worked && *outErr) { - *outErr = [self lastError]; - } - - return worked; -} - -- (BOOL)rollbackToSavePointWithName:(NSString*)name error:(NSError**)outErr { - - NSParameterAssert(name); - - BOOL worked = [self executeUpdate:[NSString stringWithFormat:@"rollback transaction to savepoint '%@';", name]]; - - if (!worked && *outErr) { - *outErr = [self lastError]; - } - - return worked; -} - -- (NSError*)inSavePoint:(void (^)(BOOL *rollback))block { - static unsigned long savePointIdx = 0; - - NSString *name = [NSString stringWithFormat:@"dbSavePoint%ld", savePointIdx++]; - - BOOL shouldRollback = NO; - - NSError *err = 0x00; - - if (![self startSavePointWithName:name error:&err]) { - return err; - } - - block(&shouldRollback); - - if (shouldRollback) { - [self rollbackToSavePointWithName:name error:&err]; - } - else { - [self releaseSavePointWithName:name error:&err]; - } - - return err; -} - -#endif - - -- (BOOL)shouldCacheStatements { - return _shouldCacheStatements; -} - -- (void)setShouldCacheStatements:(BOOL)value { - - _shouldCacheStatements = value; - - if (_shouldCacheStatements && !_cachedStatements) { - [self setCachedStatements:[NSMutableDictionary dictionary]]; - } - - if (!_shouldCacheStatements) { - [self setCachedStatements:nil]; - } -} - -void FMDBBlockSQLiteCallBackFunction(sqlite3_context *context, int argc, sqlite3_value **argv); -void FMDBBlockSQLiteCallBackFunction(sqlite3_context *context, int argc, sqlite3_value **argv) { -#if ! __has_feature(objc_arc) - void (^block)(sqlite3_context *context, int argc, sqlite3_value **argv) = (id)sqlite3_user_data(context); -#else - void (^block)(sqlite3_context *context, int argc, sqlite3_value **argv) = (__bridge id)sqlite3_user_data(context); -#endif - block(context, argc, argv); -} - - -- (void)makeFunctionNamed:(NSString*)name maximumArguments:(int)count withBlock:(void (^)(sqlite3_context *context, int argc, sqlite3_value **argv))block { - - if (!_openFunctions) { - _openFunctions = [NSMutableSet new]; - } - - id b = FMDBReturnAutoreleased([block copy]); - - [_openFunctions addObject:b]; - - /* I tried adding custom functions to release the block when the connection is destroyed- but they seemed to never be called, so we use _openFunctions to store the values instead. */ -#if ! __has_feature(objc_arc) - sqlite3_create_function([self sqliteHandle], [name UTF8String], count, SQLITE_UTF8, (void*)b, &FMDBBlockSQLiteCallBackFunction, 0x00, 0x00); -#else - sqlite3_create_function([self sqliteHandle], [name UTF8String], count, SQLITE_UTF8, (__bridge void*)b, &FMDBBlockSQLiteCallBackFunction, 0x00, 0x00); -#endif -} - -@end - - - -@implementation FMStatement -@synthesize statement=_statement; -@synthesize query=_query; -@synthesize useCount=_useCount; - -- (void)finalize { - [self close]; - [super finalize]; -} - -- (void)dealloc { - [self close]; - FMDBRelease(_query); -#if ! __has_feature(objc_arc) - [super dealloc]; -#endif -} - -- (void)close { - if (_statement) { - sqlite3_finalize(_statement); - _statement = 0x00; - } -} - -- (void)reset { - if (_statement) { - sqlite3_reset(_statement); - } -} - -- (NSString*)description { - return [NSString stringWithFormat:@"%@ %ld hit(s) for query %@", [super description], _useCount, _query]; -} - - -@end - diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseAdditions.h b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseAdditions.h deleted file mode 100644 index 3b5264f..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseAdditions.h +++ /dev/null @@ -1,37 +0,0 @@ -// -// FMDatabaseAdditions.h -// fmkit -// -// Created by August Mueller on 10/30/05. -// Copyright 2005 Flying Meat Inc.. All rights reserved. -// - -#import -@interface FMDatabase (FMDatabaseAdditions) - - -- (int)intForQuery:(NSString*)objs, ...; -- (long)longForQuery:(NSString*)objs, ...; -- (BOOL)boolForQuery:(NSString*)objs, ...; -- (double)doubleForQuery:(NSString*)objs, ...; -- (NSString*)stringForQuery:(NSString*)objs, ...; -- (NSData*)dataForQuery:(NSString*)objs, ...; -- (NSDate*)dateForQuery:(NSString*)objs, ...; - -// Notice that there's no dataNoCopyForQuery:. -// That would be a bad idea, because we close out the result set, and then what -// happens to the data that we just didn't copy? Who knows, not I. - - -- (BOOL)tableExists:(NSString*)tableName; -- (FMResultSet*)getSchema; -- (FMResultSet*)getTableSchema:(NSString*)tableName; - -- (BOOL)columnExists:(NSString*)columnName inTableWithName:(NSString*)tableName; - -- (BOOL)validateSQL:(NSString*)sql error:(NSError**)error; - -// deprecated - use columnExists:inTableWithName: instead. -- (BOOL)columnExists:(NSString*)tableName columnName:(NSString*)columnName __attribute__ ((deprecated)); - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseAdditions.m b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseAdditions.m deleted file mode 100644 index 60c94ac..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseAdditions.m +++ /dev/null @@ -1,163 +0,0 @@ -// -// FMDatabaseAdditions.m -// fmkit -// -// Created by August Mueller on 10/30/05. -// Copyright 2005 Flying Meat Inc.. All rights reserved. -// - -#import "FMDatabase.h" -#import "FMDatabaseAdditions.h" - -@interface FMDatabase (PrivateStuff) -- (FMResultSet *)executeQuery:(NSString *)sql withArgumentsInArray:(NSArray*)arrayArgs orDictionary:(NSDictionary *)dictionaryArgs orVAList:(va_list)args; -@end - -@implementation FMDatabase (FMDatabaseAdditions) - -#define RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(type, sel) \ -va_list args; \ -va_start(args, query); \ -FMResultSet *resultSet = [self executeQuery:query withArgumentsInArray:0x00 orDictionary:0x00 orVAList:args]; \ -va_end(args); \ -if (![resultSet next]) { return (type)0; } \ -type ret = [resultSet sel:0]; \ -[resultSet close]; \ -[resultSet setParentDB:nil]; \ -return ret; - - -- (NSString*)stringForQuery:(NSString*)query, ... { - RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(NSString *, stringForColumnIndex); -} - -- (int)intForQuery:(NSString*)query, ... { - RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(int, intForColumnIndex); -} - -- (long)longForQuery:(NSString*)query, ... { - RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(long, longForColumnIndex); -} - -- (BOOL)boolForQuery:(NSString*)query, ... { - RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(BOOL, boolForColumnIndex); -} - -- (double)doubleForQuery:(NSString*)query, ... { - RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(double, doubleForColumnIndex); -} - -- (NSData*)dataForQuery:(NSString*)query, ... { - RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(NSData *, dataForColumnIndex); -} - -- (NSDate*)dateForQuery:(NSString*)query, ... { - RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(NSDate *, dateForColumnIndex); -} - - -- (BOOL)tableExists:(NSString*)tableName { - - tableName = [tableName lowercaseString]; - - FMResultSet *rs = [self executeQuery:@"select [sql] from sqlite_master where [type] = 'table' and lower(name) = ?", tableName]; - - //if at least one next exists, table exists - BOOL returnBool = [rs next]; - - //close and free object - [rs close]; - - return returnBool; -} - -/* - get table with list of tables: result colums: type[STRING], name[STRING],tbl_name[STRING],rootpage[INTEGER],sql[STRING] - check if table exist in database (patch from OZLB) -*/ -- (FMResultSet*)getSchema { - - //result colums: type[STRING], name[STRING],tbl_name[STRING],rootpage[INTEGER],sql[STRING] - FMResultSet *rs = [self executeQuery:@"SELECT type, name, tbl_name, rootpage, sql FROM (SELECT * FROM sqlite_master UNION ALL SELECT * FROM sqlite_temp_master) WHERE type != 'meta' AND name NOT LIKE 'sqlite_%' ORDER BY tbl_name, type DESC, name"]; - - return rs; -} - -/* - get table schema: result colums: cid[INTEGER], name,type [STRING], notnull[INTEGER], dflt_value[],pk[INTEGER] -*/ -- (FMResultSet*)getTableSchema:(NSString*)tableName { - - //result colums: cid[INTEGER], name,type [STRING], notnull[INTEGER], dflt_value[],pk[INTEGER] - FMResultSet *rs = [self executeQuery:[NSString stringWithFormat: @"PRAGMA table_info('%@')", tableName]]; - - return rs; -} - -- (BOOL)columnExists:(NSString*)columnName inTableWithName:(NSString*)tableName { - - BOOL returnBool = NO; - - tableName = [tableName lowercaseString]; - columnName = [columnName lowercaseString]; - - FMResultSet *rs = [self getTableSchema:tableName]; - - //check if column is present in table schema - while ([rs next]) { - if ([[[rs stringForColumn:@"name"] lowercaseString] isEqualToString:columnName]) { - returnBool = YES; - break; - } - } - - //If this is not done FMDatabase instance stays out of pool - [rs close]; - - return returnBool; -} - -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wdeprecated-implementations" - -- (BOOL)columnExists:(NSString*)tableName columnName:(NSString*)columnName __attribute__ ((deprecated)) { - return [self columnExists:columnName inTableWithName:tableName]; -} - -#pragma clang diagnostic pop - -- (BOOL)validateSQL:(NSString*)sql error:(NSError**)error { - sqlite3_stmt *pStmt = NULL; - BOOL validationSucceeded = YES; - BOOL keepTrying = YES; - int numberOfRetries = 0; - - while (keepTrying == YES) { - keepTrying = NO; - int rc = sqlite3_prepare_v2(_db, [sql UTF8String], -1, &pStmt, 0); - if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED) { - keepTrying = YES; - usleep(20); - - if (_busyRetryTimeout && (numberOfRetries++ > _busyRetryTimeout)) { - NSLog(@"%s:%d Database busy (%@)", __FUNCTION__, __LINE__, [self databasePath]); - NSLog(@"Database busy"); - } - } - else if (rc != SQLITE_OK) { - validationSucceeded = NO; - if (error) { - *error = [NSError errorWithDomain:NSCocoaErrorDomain - code:[self lastErrorCode] - userInfo:[NSDictionary dictionaryWithObject:[self lastErrorMessage] - forKey:NSLocalizedDescriptionKey]]; - } - } - } - - sqlite3_finalize(pStmt); - - return validationSucceeded; -} - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabasePool.h b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabasePool.h deleted file mode 100644 index 8fe0c3e..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabasePool.h +++ /dev/null @@ -1,75 +0,0 @@ -// -// FMDatabasePool.h -// fmdb -// -// Created by August Mueller on 6/22/11. -// Copyright 2011 Flying Meat Inc. All rights reserved. -// - -#import -#import "sqlite3.h" - -/* - - ***README OR SUFFER*** -Before using FMDatabasePool, please consider using FMDatabaseQueue instead. - -If you really really really know what you're doing and FMDatabasePool is what -you really really need (ie, you're using a read only database), OK you can use -it. But just be careful not to deadlock! - -For an example on deadlocking, search for: -ONLY_USE_THE_POOL_IF_YOU_ARE_DOING_READS_OTHERWISE_YOULL_DEADLOCK_USE_FMDATABASEQUEUE_INSTEAD -in the main.m file. - -*/ - - - -@class FMDatabase; - -@interface FMDatabasePool : NSObject { - NSString *_path; - - dispatch_queue_t _lockQueue; - - NSMutableArray *_databaseInPool; - NSMutableArray *_databaseOutPool; - - __unsafe_unretained id _delegate; - - NSUInteger _maximumNumberOfDatabasesToCreate; -} - -@property (atomic, retain) NSString *path; -@property (atomic, assign) id delegate; -@property (atomic, assign) NSUInteger maximumNumberOfDatabasesToCreate; - -+ (id)databasePoolWithPath:(NSString*)aPath; -- (id)initWithPath:(NSString*)aPath; - -- (NSUInteger)countOfCheckedInDatabases; -- (NSUInteger)countOfCheckedOutDatabases; -- (NSUInteger)countOfOpenDatabases; -- (void)releaseAllDatabases; - -- (void)inDatabase:(void (^)(FMDatabase *db))block; - -- (void)inTransaction:(void (^)(FMDatabase *db, BOOL *rollback))block; -- (void)inDeferredTransaction:(void (^)(FMDatabase *db, BOOL *rollback))block; - -#if SQLITE_VERSION_NUMBER >= 3007000 -// NOTE: you can not nest these, since calling it will pull another database out of the pool and you'll get a deadlock. -// If you need to nest, use FMDatabase's startSavePointWithName:error: instead. -- (NSError*)inSavePoint:(void (^)(FMDatabase *db, BOOL *rollback))block; -#endif - -@end - - -@interface NSObject (FMDatabasePoolDelegate) - -- (BOOL)databasePool:(FMDatabasePool*)pool shouldAddDatabaseToPool:(FMDatabase*)database; - -@end - diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabasePool.m b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabasePool.m deleted file mode 100644 index 4cad6cb..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabasePool.m +++ /dev/null @@ -1,244 +0,0 @@ -// -// FMDatabasePool.m -// fmdb -// -// Created by August Mueller on 6/22/11. -// Copyright 2011 Flying Meat Inc. All rights reserved. -// - -#import "FMDatabasePool.h" -#import "FMDatabase.h" - -@interface FMDatabasePool() - -- (void)pushDatabaseBackInPool:(FMDatabase*)db; -- (FMDatabase*)db; - -@end - - -@implementation FMDatabasePool -@synthesize path=_path; -@synthesize delegate=_delegate; -@synthesize maximumNumberOfDatabasesToCreate=_maximumNumberOfDatabasesToCreate; - - -+ (id)databasePoolWithPath:(NSString*)aPath { - return FMDBReturnAutoreleased([[self alloc] initWithPath:aPath]); -} - -- (id)initWithPath:(NSString*)aPath { - - self = [super init]; - - if (self != nil) { - _path = [aPath copy]; - _lockQueue = dispatch_queue_create([[NSString stringWithFormat:@"fmdb.%@", self] UTF8String], NULL); - _databaseInPool = FMDBReturnRetained([NSMutableArray array]); - _databaseOutPool = FMDBReturnRetained([NSMutableArray array]); - } - - return self; -} - -- (void)dealloc { - - _delegate = 0x00; - FMDBRelease(_path); - FMDBRelease(_databaseInPool); - FMDBRelease(_databaseOutPool); - - if (_lockQueue) { - FMDBDispatchQueueRelease(_lockQueue); - _lockQueue = 0x00; - } -#if ! __has_feature(objc_arc) - [super dealloc]; -#endif -} - - -- (void)executeLocked:(void (^)(void))aBlock { - dispatch_sync(_lockQueue, aBlock); -} - -- (void)pushDatabaseBackInPool:(FMDatabase*)db { - - if (!db) { // db can be null if we set an upper bound on the # of databases to create. - return; - } - - [self executeLocked:^() { - - if ([_databaseInPool containsObject:db]) { - [[NSException exceptionWithName:@"Database already in pool" reason:@"The FMDatabase being put back into the pool is already present in the pool" userInfo:nil] raise]; - } - - [_databaseInPool addObject:db]; - [_databaseOutPool removeObject:db]; - - }]; -} - -- (FMDatabase*)db { - - __block FMDatabase *db; - - [self executeLocked:^() { - db = [_databaseInPool lastObject]; - - if (db) { - [_databaseOutPool addObject:db]; - [_databaseInPool removeLastObject]; - } - else { - - if (_maximumNumberOfDatabasesToCreate) { - NSUInteger currentCount = [_databaseOutPool count] + [_databaseInPool count]; - - if (currentCount >= _maximumNumberOfDatabasesToCreate) { - NSLog(@"Maximum number of databases (%ld) has already been reached!", (long)currentCount); - return; - } - } - - db = [FMDatabase databaseWithPath:_path]; - } - - //This ensures that the db is opened before returning - if ([db open]) { - if ([_delegate respondsToSelector:@selector(databasePool:shouldAddDatabaseToPool:)] && ![_delegate databasePool:self shouldAddDatabaseToPool:db]) { - [db close]; - db = 0x00; - } - else { - //It should not get added in the pool twice if lastObject was found - if (![_databaseOutPool containsObject:db]) { - [_databaseOutPool addObject:db]; - } - } - } - else { - NSLog(@"Could not open up the database at path %@", _path); - db = 0x00; - } - }]; - - return db; -} - -- (NSUInteger)countOfCheckedInDatabases { - - __block NSUInteger count; - - [self executeLocked:^() { - count = [_databaseInPool count]; - }]; - - return count; -} - -- (NSUInteger)countOfCheckedOutDatabases { - - __block NSUInteger count; - - [self executeLocked:^() { - count = [_databaseOutPool count]; - }]; - - return count; -} - -- (NSUInteger)countOfOpenDatabases { - __block NSUInteger count; - - [self executeLocked:^() { - count = [_databaseOutPool count] + [_databaseInPool count]; - }]; - - return count; -} - -- (void)releaseAllDatabases { - [self executeLocked:^() { - [_databaseOutPool removeAllObjects]; - [_databaseInPool removeAllObjects]; - }]; -} - -- (void)inDatabase:(void (^)(FMDatabase *db))block { - - FMDatabase *db = [self db]; - - block(db); - - [self pushDatabaseBackInPool:db]; -} - -- (void)beginTransaction:(BOOL)useDeferred withBlock:(void (^)(FMDatabase *db, BOOL *rollback))block { - - BOOL shouldRollback = NO; - - FMDatabase *db = [self db]; - - if (useDeferred) { - [db beginDeferredTransaction]; - } - else { - [db beginTransaction]; - } - - - block(db, &shouldRollback); - - if (shouldRollback) { - [db rollback]; - } - else { - [db commit]; - } - - [self pushDatabaseBackInPool:db]; -} - -- (void)inDeferredTransaction:(void (^)(FMDatabase *db, BOOL *rollback))block { - [self beginTransaction:YES withBlock:block]; -} - -- (void)inTransaction:(void (^)(FMDatabase *db, BOOL *rollback))block { - [self beginTransaction:NO withBlock:block]; -} -#if SQLITE_VERSION_NUMBER >= 3007000 -- (NSError*)inSavePoint:(void (^)(FMDatabase *db, BOOL *rollback))block { - - static unsigned long savePointIdx = 0; - - NSString *name = [NSString stringWithFormat:@"savePoint%ld", savePointIdx++]; - - BOOL shouldRollback = NO; - - FMDatabase *db = [self db]; - - NSError *err = 0x00; - - if (![db startSavePointWithName:name error:&err]) { - [self pushDatabaseBackInPool:db]; - return err; - } - - block(db, &shouldRollback); - - if (shouldRollback) { - [db rollbackToSavePointWithName:name error:&err]; - } - else { - [db releaseSavePointWithName:name error:&err]; - } - - [self pushDatabaseBackInPool:db]; - - return err; -} -#endif - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseQueue.h b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseQueue.h deleted file mode 100644 index bbf9c66..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseQueue.h +++ /dev/null @@ -1,38 +0,0 @@ -// -// FMDatabasePool.h -// fmdb -// -// Created by August Mueller on 6/22/11. -// Copyright 2011 Flying Meat Inc. All rights reserved. -// - -#import -#import "sqlite3.h" - -@class FMDatabase; - -@interface FMDatabaseQueue : NSObject { - NSString *_path; - dispatch_queue_t _queue; - FMDatabase *_db; -} - -@property (atomic, retain) NSString *path; - -+ (id)databaseQueueWithPath:(NSString*)aPath; -- (id)initWithPath:(NSString*)aPath; -- (void)close; - -- (void)inDatabase:(void (^)(FMDatabase *db))block; - -- (void)inTransaction:(void (^)(FMDatabase *db, BOOL *rollback))block; -- (void)inDeferredTransaction:(void (^)(FMDatabase *db, BOOL *rollback))block; - -#if SQLITE_VERSION_NUMBER >= 3007000 -// NOTE: you can not nest these, since calling it will pull another database out of the pool and you'll get a deadlock. -// If you need to nest, use FMDatabase's startSavePointWithName:error: instead. -- (NSError*)inSavePoint:(void (^)(FMDatabase *db, BOOL *rollback))block; -#endif - -@end - diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseQueue.m b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseQueue.m deleted file mode 100644 index 98fac81..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMDatabaseQueue.m +++ /dev/null @@ -1,176 +0,0 @@ -// -// FMDatabasePool.m -// fmdb -// -// Created by August Mueller on 6/22/11. -// Copyright 2011 Flying Meat Inc. All rights reserved. -// - -#import "FMDatabaseQueue.h" -#import "FMDatabase.h" - -/* - - Note: we call [self retain]; before using dispatch_sync, just incase - FMDatabaseQueue is released on another thread and we're in the middle of doing - something in dispatch_sync - - */ - -@implementation FMDatabaseQueue - -@synthesize path = _path; - -+ (id)databaseQueueWithPath:(NSString*)aPath { - - FMDatabaseQueue *q = [[self alloc] initWithPath:aPath]; - - FMDBAutorelease(q); - - return q; -} - -- (id)initWithPath:(NSString*)aPath { - - self = [super init]; - - if (self != nil) { - - _db = [FMDatabase databaseWithPath:aPath]; - FMDBRetain(_db); - - if (![_db open]) { - NSLog(@"Could not create database queue for path %@", aPath); - FMDBRelease(self); - return 0x00; - } - - _path = FMDBReturnRetained(aPath); - - _queue = dispatch_queue_create([[NSString stringWithFormat:@"fmdb.%@", self] UTF8String], NULL); - } - - return self; -} - -- (void)dealloc { - - FMDBRelease(_db); - FMDBRelease(_path); - - if (_queue) { - FMDBDispatchQueueRelease(_queue); - _queue = 0x00; - } -#if ! __has_feature(objc_arc) - [super dealloc]; -#endif -} - -- (void)close { - FMDBRetain(self); - dispatch_sync(_queue, ^() { - [_db close]; - FMDBRelease(_db); - _db = 0x00; - }); - FMDBRelease(self); -} - -- (FMDatabase*)database { - if (!_db) { - _db = FMDBReturnRetained([FMDatabase databaseWithPath:_path]); - - if (![_db open]) { - NSLog(@"FMDatabaseQueue could not reopen database for path %@", _path); - FMDBRelease(_db); - _db = 0x00; - return 0x00; - } - } - - return _db; -} - -- (void)inDatabase:(void (^)(FMDatabase *db))block { - FMDBRetain(self); - - dispatch_sync(_queue, ^() { - - FMDatabase *db = [self database]; - block(db); - - if ([db hasOpenResultSets]) { - NSLog(@"Warning: there is at least one open result set around after performing [FMDatabaseQueue inDatabase:]"); - } - }); - - FMDBRelease(self); -} - - -- (void)beginTransaction:(BOOL)useDeferred withBlock:(void (^)(FMDatabase *db, BOOL *rollback))block { - FMDBRetain(self); - dispatch_sync(_queue, ^() { - - BOOL shouldRollback = NO; - - if (useDeferred) { - [[self database] beginDeferredTransaction]; - } - else { - [[self database] beginTransaction]; - } - - block([self database], &shouldRollback); - - if (shouldRollback) { - [[self database] rollback]; - } - else { - [[self database] commit]; - } - }); - - FMDBRelease(self); -} - -- (void)inDeferredTransaction:(void (^)(FMDatabase *db, BOOL *rollback))block { - [self beginTransaction:YES withBlock:block]; -} - -- (void)inTransaction:(void (^)(FMDatabase *db, BOOL *rollback))block { - [self beginTransaction:NO withBlock:block]; -} - -#if SQLITE_VERSION_NUMBER >= 3007000 -- (NSError*)inSavePoint:(void (^)(FMDatabase *db, BOOL *rollback))block { - - static unsigned long savePointIdx = 0; - __block NSError *err = 0x00; - FMDBRetain(self); - dispatch_sync(_queue, ^() { - - NSString *name = [NSString stringWithFormat:@"savePoint%ld", savePointIdx++]; - - BOOL shouldRollback = NO; - - if ([[self database] startSavePointWithName:name error:&err]) { - - block([self database], &shouldRollback); - - if (shouldRollback) { - [[self database] rollbackToSavePointWithName:name error:&err]; - } - else { - [[self database] releaseSavePointWithName:name error:&err]; - } - - } - }); - FMDBRelease(self); - return err; -} -#endif - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMResultSet.h b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMResultSet.h deleted file mode 100644 index b3dd6f6..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMResultSet.h +++ /dev/null @@ -1,105 +0,0 @@ -#import -#import "sqlite3.h" - -#ifndef __has_feature // Optional. -#define __has_feature(x) 0 // Compatibility with non-clang compilers. -#endif - -#ifndef NS_RETURNS_NOT_RETAINED -#if __has_feature(attribute_ns_returns_not_retained) -#define NS_RETURNS_NOT_RETAINED __attribute__((ns_returns_not_retained)) -#else -#define NS_RETURNS_NOT_RETAINED -#endif -#endif - -@class FMDatabase; -@class FMStatement; - -@interface FMResultSet : NSObject { - FMDatabase *_parentDB; - FMStatement *_statement; - - NSString *_query; - NSMutableDictionary *_columnNameToIndexMap; - BOOL _columnNamesSetup; -} - -@property (atomic, retain) NSString *query; -@property (atomic, retain) NSMutableDictionary *columnNameToIndexMap; -@property (atomic, retain) FMStatement *statement; - -+ (id)resultSetWithStatement:(FMStatement *)statement usingParentDatabase:(FMDatabase*)aDB; - -- (void)close; - -- (void)setParentDB:(FMDatabase *)newDb; - -- (BOOL)next; -- (BOOL)hasAnotherRow; - -- (int)columnCount; - -- (int)columnIndexForName:(NSString*)columnName; -- (NSString*)columnNameForIndex:(int)columnIdx; - -- (int)intForColumn:(NSString*)columnName; -- (int)intForColumnIndex:(int)columnIdx; - -- (long)longForColumn:(NSString*)columnName; -- (long)longForColumnIndex:(int)columnIdx; - -- (long long int)longLongIntForColumn:(NSString*)columnName; -- (long long int)longLongIntForColumnIndex:(int)columnIdx; - -- (unsigned long long int)unsignedLongLongIntForColumn:(NSString*)columnName; -- (unsigned long long int)unsignedLongLongIntForColumnIndex:(int)columnIdx; - -- (BOOL)boolForColumn:(NSString*)columnName; -- (BOOL)boolForColumnIndex:(int)columnIdx; - -- (double)doubleForColumn:(NSString*)columnName; -- (double)doubleForColumnIndex:(int)columnIdx; - -- (NSString*)stringForColumn:(NSString*)columnName; -- (NSString*)stringForColumnIndex:(int)columnIdx; - -- (NSDate*)dateForColumn:(NSString*)columnName; -- (NSDate*)dateForColumnIndex:(int)columnIdx; - -- (NSData*)dataForColumn:(NSString*)columnName; -- (NSData*)dataForColumnIndex:(int)columnIdx; - -- (const unsigned char *)UTF8StringForColumnIndex:(int)columnIdx; -- (const unsigned char *)UTF8StringForColumnName:(NSString*)columnName; - -// returns one of NSNumber, NSString, NSData, or NSNull -- (id)objectForColumnName:(NSString*)columnName; -- (id)objectForColumnIndex:(int)columnIdx; - -- (id)objectForKeyedSubscript:(NSString *)columnName; -- (id)objectAtIndexedSubscript:(int)columnIdx; - -/* -If you are going to use this data after you iterate over the next row, or after you close the -result set, make sure to make a copy of the data first (or just use dataForColumn:/dataForColumnIndex:) -If you don't, you're going to be in a world of hurt when you try and use the data. -*/ -- (NSData*)dataNoCopyForColumn:(NSString*)columnName NS_RETURNS_NOT_RETAINED; -- (NSData*)dataNoCopyForColumnIndex:(int)columnIdx NS_RETURNS_NOT_RETAINED; - -- (BOOL)columnIndexIsNull:(int)columnIdx; -- (BOOL)columnIsNull:(NSString*)columnName; - - -/* Returns a dictionary of the row results mapped to case sensitive keys of the column names. */ -- (NSDictionary*)resultDictionary; - -/* Please use resultDictionary instead. Also, beware that resultDictionary is case sensitive! */ -- (NSDictionary*)resultDict __attribute__ ((deprecated)); - -- (void)kvcMagic:(id)object; - - -@end - diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMResultSet.m b/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMResultSet.m deleted file mode 100644 index 1414f40..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Libraries/SQLite/FMResultSet.m +++ /dev/null @@ -1,431 +0,0 @@ -#import "FMResultSet.h" -#import "FMDatabase.h" -#import "unistd.h" - -@interface FMDatabase () -- (void)resultSetDidClose:(FMResultSet *)resultSet; -@end - - -@interface FMResultSet (Private) -- (NSMutableDictionary *)columnNameToIndexMap; -- (void)setColumnNameToIndexMap:(NSMutableDictionary *)value; -@end - -@implementation FMResultSet -@synthesize query=_query; -@synthesize columnNameToIndexMap=_columnNameToIndexMap; -@synthesize statement=_statement; - -+ (id)resultSetWithStatement:(FMStatement *)statement usingParentDatabase:(FMDatabase*)aDB { - - FMResultSet *rs = [[FMResultSet alloc] init]; - - [rs setStatement:statement]; - [rs setParentDB:aDB]; - - return FMDBReturnAutoreleased(rs); -} - -- (void)finalize { - [self close]; - [super finalize]; -} - -- (void)dealloc { - [self close]; - - FMDBRelease(_query); - _query = nil; - - FMDBRelease(_columnNameToIndexMap); - _columnNameToIndexMap = nil; - -#if ! __has_feature(objc_arc) - [super dealloc]; -#endif -} - -- (void)close { - [_statement reset]; - FMDBRelease(_statement); - _statement = nil; - - // we don't need this anymore... (i think) - //[_parentDB setInUse:NO]; - [_parentDB resultSetDidClose:self]; - _parentDB = nil; -} - -- (int)columnCount { - return sqlite3_column_count([_statement statement]); -} - -- (void)setupColumnNames { - - if (!_columnNameToIndexMap) { - [self setColumnNameToIndexMap:[NSMutableDictionary dictionary]]; - } - - int columnCount = sqlite3_column_count([_statement statement]); - - int columnIdx = 0; - for (columnIdx = 0; columnIdx < columnCount; columnIdx++) { - [_columnNameToIndexMap setObject:[NSNumber numberWithInt:columnIdx] - forKey:[[NSString stringWithUTF8String:sqlite3_column_name([_statement statement], columnIdx)] lowercaseString]]; - } - _columnNamesSetup = YES; -} - -- (void)kvcMagic:(id)object { - - int columnCount = sqlite3_column_count([_statement statement]); - - int columnIdx = 0; - for (columnIdx = 0; columnIdx < columnCount; columnIdx++) { - - const char *c = (const char *)sqlite3_column_text([_statement statement], columnIdx); - - // check for a null row - if (c) { - NSString *s = [NSString stringWithUTF8String:c]; - - [object setValue:s forKey:[NSString stringWithUTF8String:sqlite3_column_name([_statement statement], columnIdx)]]; - } - } -} - -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wdeprecated-implementations" - -- (NSDictionary*)resultDict { - - NSUInteger num_cols = (NSUInteger)sqlite3_data_count([_statement statement]); - - if (num_cols > 0) { - NSMutableDictionary *dict = [NSMutableDictionary dictionaryWithCapacity:num_cols]; - - if (!_columnNamesSetup) { - [self setupColumnNames]; - } - - NSEnumerator *columnNames = [_columnNameToIndexMap keyEnumerator]; - NSString *columnName = nil; - while ((columnName = [columnNames nextObject])) { - id objectValue = [self objectForColumnName:columnName]; - [dict setObject:objectValue forKey:columnName]; - } - - return FMDBReturnAutoreleased([dict copy]); - } - else { - NSLog(@"Warning: There seem to be no columns in this set."); - } - - return nil; -} - -#pragma clang diagnostic pop - -- (NSDictionary*)resultDictionary { - - NSUInteger num_cols = (NSUInteger)sqlite3_data_count([_statement statement]); - - if (num_cols > 0) { - NSMutableDictionary *dict = [NSMutableDictionary dictionaryWithCapacity:num_cols]; - - int columnCount = sqlite3_column_count([_statement statement]); - - int columnIdx = 0; - for (columnIdx = 0; columnIdx < columnCount; columnIdx++) { - - NSString *columnName = [NSString stringWithUTF8String:sqlite3_column_name([_statement statement], columnIdx)]; - id objectValue = [self objectForColumnIndex:columnIdx]; - [dict setObject:objectValue forKey:columnName]; - } - - return dict; - } - else { - NSLog(@"Warning: There seem to be no columns in this set."); - } - - return nil; -} - - - - - -- (BOOL)next { - - int rc; - BOOL retry; - int numberOfRetries = 0; - do { - retry = NO; - - rc = sqlite3_step([_statement statement]); - - if (SQLITE_BUSY == rc || SQLITE_LOCKED == rc) { - // this will happen if the db is locked, like if we are doing an update or insert. - // in that case, retry the step... and maybe wait just 10 milliseconds. - retry = YES; - if (SQLITE_LOCKED == rc) { - rc = sqlite3_reset([_statement statement]); - if (rc != SQLITE_LOCKED) { - NSLog(@"Unexpected result from sqlite3_reset (%d) rs", rc); - } - } - usleep(20); - - if ([_parentDB busyRetryTimeout] && (numberOfRetries++ > [_parentDB busyRetryTimeout])) { - - NSLog(@"%s:%d Database busy (%@)", __FUNCTION__, __LINE__, [_parentDB databasePath]); - NSLog(@"Database busy"); - break; - } - } - else if (SQLITE_DONE == rc || SQLITE_ROW == rc) { - // all is well, let's return. - } - else if (SQLITE_ERROR == rc) { - NSLog(@"Error calling sqlite3_step (%d: %s) rs", rc, sqlite3_errmsg([_parentDB sqliteHandle])); - break; - } - else if (SQLITE_MISUSE == rc) { - // uh oh. - NSLog(@"Error calling sqlite3_step (%d: %s) rs", rc, sqlite3_errmsg([_parentDB sqliteHandle])); - break; - } - else { - // wtf? - NSLog(@"Unknown error calling sqlite3_step (%d: %s) rs", rc, sqlite3_errmsg([_parentDB sqliteHandle])); - break; - } - - } while (retry); - - - if (rc != SQLITE_ROW) { - [self close]; - } - - return (rc == SQLITE_ROW); -} - -- (BOOL)hasAnotherRow { - return sqlite3_errcode([_parentDB sqliteHandle]) == SQLITE_ROW; -} - -- (int)columnIndexForName:(NSString*)columnName { - - if (!_columnNamesSetup) { - [self setupColumnNames]; - } - - columnName = [columnName lowercaseString]; - - NSNumber *n = [_columnNameToIndexMap objectForKey:columnName]; - - if (n) { - return [n intValue]; - } - - NSLog(@"Warning: I could not find the column named '%@'.", columnName); - - return -1; -} - - - -- (int)intForColumn:(NSString*)columnName { - return [self intForColumnIndex:[self columnIndexForName:columnName]]; -} - -- (int)intForColumnIndex:(int)columnIdx { - return sqlite3_column_int([_statement statement], columnIdx); -} - -- (long)longForColumn:(NSString*)columnName { - return [self longForColumnIndex:[self columnIndexForName:columnName]]; -} - -- (long)longForColumnIndex:(int)columnIdx { - return (long)sqlite3_column_int64([_statement statement], columnIdx); -} - -- (long long int)longLongIntForColumn:(NSString*)columnName { - return [self longLongIntForColumnIndex:[self columnIndexForName:columnName]]; -} - -- (long long int)longLongIntForColumnIndex:(int)columnIdx { - return sqlite3_column_int64([_statement statement], columnIdx); -} - -- (unsigned long long int)unsignedLongLongIntForColumn:(NSString*)columnName { - return [self unsignedLongLongIntForColumnIndex:[self columnIndexForName:columnName]]; -} - -- (unsigned long long int)unsignedLongLongIntForColumnIndex:(int)columnIdx { - return (unsigned long long int)[self longLongIntForColumnIndex:columnIdx]; -} - -- (BOOL)boolForColumn:(NSString*)columnName { - return [self boolForColumnIndex:[self columnIndexForName:columnName]]; -} - -- (BOOL)boolForColumnIndex:(int)columnIdx { - return ([self intForColumnIndex:columnIdx] != 0); -} - -- (double)doubleForColumn:(NSString*)columnName { - return [self doubleForColumnIndex:[self columnIndexForName:columnName]]; -} - -- (double)doubleForColumnIndex:(int)columnIdx { - return sqlite3_column_double([_statement statement], columnIdx); -} - -- (NSString*)stringForColumnIndex:(int)columnIdx { - - if (sqlite3_column_type([_statement statement], columnIdx) == SQLITE_NULL || (columnIdx < 0)) { - return nil; - } - - const char *c = (const char *)sqlite3_column_text([_statement statement], columnIdx); - - if (!c) { - // null row. - return nil; - } - - return [NSString stringWithUTF8String:c]; -} - -- (NSString*)stringForColumn:(NSString*)columnName { - return [self stringForColumnIndex:[self columnIndexForName:columnName]]; -} - -- (NSDate*)dateForColumn:(NSString*)columnName { - return [self dateForColumnIndex:[self columnIndexForName:columnName]]; -} - -- (NSDate*)dateForColumnIndex:(int)columnIdx { - - if (sqlite3_column_type([_statement statement], columnIdx) == SQLITE_NULL || (columnIdx < 0)) { - return nil; - } - - return [NSDate dateWithTimeIntervalSince1970:[self doubleForColumnIndex:columnIdx]]; -} - - -- (NSData*)dataForColumn:(NSString*)columnName { - return [self dataForColumnIndex:[self columnIndexForName:columnName]]; -} - -- (NSData*)dataForColumnIndex:(int)columnIdx { - - if (sqlite3_column_type([_statement statement], columnIdx) == SQLITE_NULL || (columnIdx < 0)) { - return nil; - } - - int dataSize = sqlite3_column_bytes([_statement statement], columnIdx); - - NSMutableData *data = [NSMutableData dataWithLength:(NSUInteger)dataSize]; - - memcpy([data mutableBytes], sqlite3_column_blob([_statement statement], columnIdx), dataSize); - - return data; -} - - -- (NSData*)dataNoCopyForColumn:(NSString*)columnName { - return [self dataNoCopyForColumnIndex:[self columnIndexForName:columnName]]; -} - -- (NSData*)dataNoCopyForColumnIndex:(int)columnIdx { - - if (sqlite3_column_type([_statement statement], columnIdx) == SQLITE_NULL || (columnIdx < 0)) { - return nil; - } - - int dataSize = sqlite3_column_bytes([_statement statement], columnIdx); - - NSData *data = [NSData dataWithBytesNoCopy:(void *)sqlite3_column_blob([_statement statement], columnIdx) length:(NSUInteger)dataSize freeWhenDone:NO]; - - return data; -} - - -- (BOOL)columnIndexIsNull:(int)columnIdx { - return sqlite3_column_type([_statement statement], columnIdx) == SQLITE_NULL; -} - -- (BOOL)columnIsNull:(NSString*)columnName { - return [self columnIndexIsNull:[self columnIndexForName:columnName]]; -} - -- (const unsigned char *)UTF8StringForColumnIndex:(int)columnIdx { - - if (sqlite3_column_type([_statement statement], columnIdx) == SQLITE_NULL || (columnIdx < 0)) { - return nil; - } - - return sqlite3_column_text([_statement statement], columnIdx); -} - -- (const unsigned char *)UTF8StringForColumnName:(NSString*)columnName { - return [self UTF8StringForColumnIndex:[self columnIndexForName:columnName]]; -} - -- (id)objectForColumnIndex:(int)columnIdx { - int columnType = sqlite3_column_type([_statement statement], columnIdx); - - id returnValue = nil; - - if (columnType == SQLITE_INTEGER) { - returnValue = [NSNumber numberWithLongLong:[self longLongIntForColumnIndex:columnIdx]]; - } - else if (columnType == SQLITE_FLOAT) { - returnValue = [NSNumber numberWithDouble:[self doubleForColumnIndex:columnIdx]]; - } - else if (columnType == SQLITE_BLOB) { - returnValue = [self dataForColumnIndex:columnIdx]; - } - else { - //default to a string for everything else - returnValue = [self stringForColumnIndex:columnIdx]; - } - - if (returnValue == nil) { - returnValue = [NSNull null]; - } - - return returnValue; -} - -- (id)objectForColumnName:(NSString*)columnName { - return [self objectForColumnIndex:[self columnIndexForName:columnName]]; -} - -// returns autoreleased NSString containing the name of the column in the result set -- (NSString*)columnNameForIndex:(int)columnIdx { - return [NSString stringWithUTF8String: sqlite3_column_name([_statement statement], columnIdx)]; -} - -- (void)setParentDB:(FMDatabase *)newDb { - _parentDB = newDb; -} - -- (id)objectAtIndexedSubscript:(int)columnIdx { - return [self objectForColumnIndex:columnIdx]; -} - -- (id)objectForKeyedSubscript:(NSString *)columnName { - return [self objectForColumnName:columnName]; -} - - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Agency.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/Agency.h deleted file mode 100644 index 887d582..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/Agency.h +++ /dev/null @@ -1,25 +0,0 @@ -// -// Agency.h -// GTFS-VTA -// -// Created by Vashishtha Jogi on 7/31/11. -// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. -// - -#import -#import "FMDatabase.h" - - -@interface Agency : NSObject - -@property (nonatomic, strong) NSString * agencyId; -@property (nonatomic, strong) NSString * agencyName; -@property (nonatomic, strong) NSString * agencyTimezone; -@property (nonatomic, strong) NSString * agencyUrl; - -- (void)addAgency:(Agency *)agency; -- (id)initWithDB:(FMDatabase *)fmdb; -- (void)cleanupAndCreate; -- (void)receiveRecord:(NSDictionary *)aRecord; - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Agency.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/Agency.m deleted file mode 100644 index f7a0858..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/Agency.m +++ /dev/null @@ -1,101 +0,0 @@ -// -// Agency.m -// GTFS-VTA -// -// Created by Vashishtha Jogi on 7/31/11. -// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. -// - -#import "Agency.h" -#import "CSVParser.h" -#import "FMDatabase.h" -#import "Util.h" - -@interface Agency () -{ - FMDatabase *db; -} - -@end - -@implementation Agency - -- (id)initWithDB:(FMDatabase *)fmdb -{ - self = [super init]; - if (self) - { - db = fmdb; - } - return self; -} - -- (void)addAgency:(Agency *)agency -{ - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - [db executeUpdate:@"INSERT into agency(agency_id, agency_name, agency_timezone, agency_url) values(?, ?, ?, ?)", - agency.agencyId, - agency.agencyName, - agency.agencyTimezone, - agency.agencyUrl]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } - -} - -- (void)cleanupAndCreate -{ - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - //Drop table if it exists - NSString *dropAgency = @"DROP TABLE IF EXISTS agency"; - - [db executeUpdate:dropAgency]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } - - //Create table - NSString *createAgency = @"CREATE TABLE 'agency' ('agency_url' TEXT DEFAULT NULL, 'agency_name' TEXT DEFAULT NULL, 'agency_timezone' TEXT DEFAULT NULL, 'agency_id' TEXT NOT NULL, PRIMARY KEY ('agency_id'))"; - - [db executeUpdate:createAgency]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } -} - -- (void)receiveRecord:(NSDictionary *)aRecord -{ - - Agency *agencyRecord = [[Agency alloc] init]; - agencyRecord.agencyId = aRecord[@"agency_id"]; - agencyRecord.agencyName = aRecord[@"agency_name"]; - agencyRecord.agencyTimezone = aRecord[@"agency_timezone"]; - agencyRecord.agencyUrl = aRecord[@"agency_url"]; - - [self addAgency:agencyRecord]; -} - - - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Calendar.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/Calendar.h deleted file mode 100644 index 3650483..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/Calendar.h +++ /dev/null @@ -1,31 +0,0 @@ -// -// Calendar.h -// GTFS-VTA -// -// Created by Vashishtha Jogi on 7/31/11. -// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. -// - -#import -#import "FMDatabase.h" - - -@interface Calendar : NSObject - -@property (nonatomic, strong) NSString * endDate; -@property (nonatomic, strong) NSString * friday; -@property (nonatomic, strong) NSString * monday; -@property (nonatomic, strong) NSString * saturday; -@property (nonatomic, strong) NSString * serviceId; -@property (nonatomic, strong) NSString * startDate; -@property (nonatomic, strong) NSString * sunday; -@property (nonatomic, strong) NSString * thursday; -@property (nonatomic, strong) NSString * tuesday; -@property (nonatomic, strong) NSString * wednesday; - -- (id)initWithDB:(FMDatabase *)fmdb; -- (void)addCalendar:(Calendar *)calendar; -- (void)cleanupAndCreate; -- (void)receiveRecord:(NSDictionary *)aRecord; - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Calendar.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/Calendar.m deleted file mode 100644 index bf910b8..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/Calendar.m +++ /dev/null @@ -1,123 +0,0 @@ -// -// Calendar.m -// GTFS-VTA -// -// Created by Vashishtha Jogi on 7/31/11. -// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. -// - -#import "Calendar.h" -#import "FMDatabase.h" -#import "CSVParser.h" -#import "Util.h" - -@interface Calendar () -{ - FMDatabase *db; - NSDateFormatter *dateFormat, *dateFormat2; -} - -@end - -@implementation Calendar - -- (id)initWithDB:(FMDatabase *)fmdb -{ - self = [super init]; - if (self) - { - db = fmdb; - dateFormat = [[NSDateFormatter alloc] init]; - [dateFormat setDateFormat:@"yyyyMMdd"]; - dateFormat2 = [[NSDateFormatter alloc] init]; - [dateFormat2 setDateFormat:@"yyyy-MM-dd"]; - } - return self; -} - -- (void)addCalendar:(Calendar *)calendar -{ -// NSLog(@"Calendar %@, %@", calendar.start_date, calendar.end_date); - - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - [db executeUpdate:@"INSERT into calendar(end_date, friday, monday, saturday, service_id, start_date, sunday, thursday, tuesday, wednesday) values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", - calendar.endDate, - calendar.friday, - calendar.monday, - calendar.saturday, - calendar.serviceId, - calendar.startDate, - calendar.sunday, - calendar.thursday, - calendar.tuesday, - calendar.wednesday]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } -} - - - -- (void)cleanupAndCreate -{ - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - //Drop table if it exists - NSString *drop = @"DROP TABLE IF EXISTS calendar"; - - [db executeUpdate:drop]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } - - //Create table - NSString *create = @"CREATE TABLE 'calendar' ('service_id' TEXT DEFAULT NULL,'start_date' date DEFAULT NULL,'end_date' date DEFAULT NULL,'monday' tinyint(1) DEFAULT NULL,'tuesday' tinyint(1) DEFAULT NULL,'wednesday' tinyint(1) DEFAULT NULL,'thursday' tinyint(1) DEFAULT NULL,'friday' tinyint(1) DEFAULT NULL,'saturday' tinyint(1) DEFAULT NULL,'sunday' tinyint(1) DEFAULT NULL)"; - NSString *createIndex = @"CREATE INDEX service_id_calendar ON calendar(service_id)"; - - [db executeUpdate:create]; - [db executeUpdate:createIndex]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } -} - -- (void)receiveRecord:(NSDictionary *)aRecord -{ - - Calendar *calendarRecord = [[Calendar alloc] init]; - calendarRecord.serviceId = aRecord[@"service_id"]; - calendarRecord.sunday = aRecord[@"sunday"]; - calendarRecord.monday = aRecord[@"monday"]; - calendarRecord.tuesday = aRecord[@"tuesday"]; - calendarRecord.wednesday = aRecord[@"wednesday"]; - calendarRecord.thursday = aRecord[@"thursday"]; - calendarRecord.friday = aRecord[@"friday"]; - calendarRecord.saturday = aRecord[@"saturday"]; - //Date format is wrong, so correct it now - calendarRecord.startDate = [dateFormat2 stringFromDate:[dateFormat dateFromString:aRecord[@"start_date"]]]; - calendarRecord.endDate = [dateFormat2 stringFromDate:[dateFormat dateFromString:aRecord[@"end_date"]]]; - - [self addCalendar:calendarRecord]; -} - - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/CalendarDate.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/CalendarDate.h deleted file mode 100644 index b03c0b0..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/CalendarDate.h +++ /dev/null @@ -1,22 +0,0 @@ -// -// CalendarDate.h -// -// Created by Kevin Conley on 6/25/2013. -// - -#import -#import "FMDatabase.h" - - -@interface CalendarDate : NSObject - -@property (nonatomic, strong) NSString * serviceId; -@property (nonatomic, strong) NSString * date; -@property (nonatomic, strong) NSString * exceptionType; - -- (id)initWithDB:(FMDatabase *)fmdb; -- (void)addCalendarDate:(CalendarDate *)calendarDate; -- (void)cleanupAndCreate; -- (void)receiveRecord:(NSDictionary *)aRecord; - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/CalendarDate.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/CalendarDate.m deleted file mode 100644 index fcc9955..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/CalendarDate.m +++ /dev/null @@ -1,105 +0,0 @@ -// -// CalendarDate.m -// -// Created by Kevin Conley on 6/25/2013. -// - -#import "CalendarDate.h" -#import "FMDatabase.h" -#import "CSVParser.h" -#import "Util.h" - -@interface CalendarDate () -{ - FMDatabase *db; - NSDateFormatter *dateFormat, *dateFormat2; -} - -@end - -@implementation CalendarDate - -- (id)initWithDB:(FMDatabase *)fmdb -{ - self = [super init]; - if (self) - { - db = fmdb; - dateFormat = [[NSDateFormatter alloc] init]; - [dateFormat setDateFormat:@"yyyyMMdd"]; - dateFormat2 = [[NSDateFormatter alloc] init]; - [dateFormat2 setDateFormat:@"yyyy-MM-dd"]; - } - return self; -} - -- (void)addCalendarDate:(CalendarDate *)calendarDate -{ - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - [db executeUpdate:@"INSERT into calendar_dates(service_id,date,exception_type) values(?, ?, ?)", - calendarDate.serviceId, - calendarDate.date, - calendarDate.exceptionType]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } -} - - - -- (void)cleanupAndCreate -{ - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - //Drop table if it exists - NSString *drop = @"DROP TABLE IF EXISTS calendar_dates"; - - [db executeUpdate:drop]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } - - //Create table - NSString *create = @"CREATE TABLE 'calendar_dates' ('service_id' TEXT NOT NULL,'date' date NOT NULL,'exception_type' tinyint(2) NOT NULL)"; - NSString *createIndex = @"CREATE INDEX service_id_calendar_dates ON calendar_dates(service_id)"; - - [db executeUpdate:create]; - [db executeUpdate:createIndex]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } -} - -- (void)receiveRecord:(NSDictionary *)aRecord -{ - - CalendarDate *calendarDateRecord = [[CalendarDate alloc] init]; - calendarDateRecord.serviceId = aRecord[@"service_id"]; - calendarDateRecord.exceptionType = aRecord[@"exception_type"]; - //Date format is wrong, so correct it now - calendarDateRecord.date = [dateFormat2 stringFromDate:[dateFormat dateFromString:aRecord[@"date"]]]; - - [self addCalendarDate:calendarDateRecord]; -} - - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/FareAttributes.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/FareAttributes.h deleted file mode 100644 index ba4f995..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/FareAttributes.h +++ /dev/null @@ -1,26 +0,0 @@ -// -// FareAttributes.h -// GTFS-VTA -// -// Created by Vashishtha Jogi on 7/31/11. -// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. -// - -#import -#import "FMDatabase.h" - -@interface FareAttributes : NSObject - -@property (nonatomic, strong) NSString * currencyType; -@property (nonatomic, strong) NSString * fareId; -@property (nonatomic, strong) NSNumber * paymentMethod; -@property (nonatomic, strong) NSNumber * price; -@property (nonatomic, strong) NSNumber * transferDuration; -@property (nonatomic, strong) NSNumber * transfers; - -- (void)addFareAttributesObject:(FareAttributes *)value; -- (id)initWithDB:(FMDatabase *)fmdb; -- (void)cleanupAndCreate; -- (void)receiveRecord:(NSDictionary *)aRecord; - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/FareAttributes.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/FareAttributes.m deleted file mode 100644 index 1a3e6fb..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/FareAttributes.m +++ /dev/null @@ -1,101 +0,0 @@ -// -// FareAttributes.m -// GTFS-VTA -// -// Created by Vashishtha Jogi on 7/31/11. -// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. -// - -#import "FareAttributes.h" -#import "CSVParser.h" -#import "FMDatabase.h" -#import "Util.h" - -@interface FareAttributes () -{ - FMDatabase *db; -} - -@end - -@implementation FareAttributes - -- (id)initWithDB:(FMDatabase *)fmdb -{ - self = [super init]; - if (self) - { - db = fmdb; - } - return self; -} - -- (void)addFareAttributesObject:(FareAttributes *)value { - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - [db executeUpdate:@"INSERT into fare_attributes(fare_id,price,currency_type,payment_method,transfers,transfer_duration) values(?, ?, ?, ?, ?, ?)", - value.fareId, - value.price, - value.currencyType, - value.paymentMethod, - value.transfers, - value.transferDuration]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } -} - -- (void)cleanupAndCreate -{ - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - //Drop table if it exists - NSString *drop = @"DROP TABLE IF EXISTS fare_attributes"; - - [db executeUpdate:drop]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } - - //Create table - NSString *create = @"CREATE TABLE 'fare_attributes' ('fare_id' TEXT NOT NULL, 'price' FLOAT DEFAULT 0.0, 'currency_type' TEXT DEFAULT NULL, 'payment_method' INT(2), 'transfers' INT(11), 'transfer_duration' INT(11), PRIMARY KEY ('fare_id'))"; - - [db executeUpdate:create]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } -} - -- (void)receiveRecord:(NSDictionary *)aRecord -{ - FareAttributes *fareAttributesRecord = [[FareAttributes alloc] init]; - fareAttributesRecord.fareId = aRecord[@"fare_id"]; - fareAttributesRecord.price = aRecord[@"price"]; - fareAttributesRecord.currencyType = aRecord[@"currency_type"]; - fareAttributesRecord.paymentMethod = aRecord[@"payment_type"]; - fareAttributesRecord.transfers = aRecord[@"transfers"]; - fareAttributesRecord.transferDuration = aRecord[@"transfer_duration"]; - - [self addFareAttributesObject:fareAttributesRecord]; -} - - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/FareRules.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/FareRules.h deleted file mode 100644 index a11810d..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/FareRules.h +++ /dev/null @@ -1,25 +0,0 @@ -// -// FareRules.h -// GTFS-VTA -// -// Created by Vashishtha Jogi on 7/31/11. -// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. -// - -#import -#import "FMDatabase.h" - -@interface FareRules : NSObject - -@property (nonatomic, strong) NSString *fareId; -@property (nonatomic, strong) NSString *routeId; -@property (nonatomic, strong) NSString *originId; -@property (nonatomic, strong) NSString *destinationId; -@property (nonatomic, strong) NSString *containsId; - -- (void)addFareRules:(FareRules *)value; -- (id)initWithDB:(FMDatabase *)fmdb; -- (void)cleanupAndCreate; -- (void)receiveRecord:(NSDictionary *)aRecord; - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/FareRules.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/FareRules.m deleted file mode 100644 index eb4af82..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/FareRules.m +++ /dev/null @@ -1,99 +0,0 @@ -// -// FareRules.m -// GTFS-VTA -// -// Created by Vashishtha Jogi on 7/31/11. -// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. -// - -#import "FareRules.h" -#import "CSVParser.h" -#import "FMDatabase.h" -#import "Util.h" - -@interface FareRules () -{ - FMDatabase *db; -} - -@end - -@implementation FareRules - -- (id) initWithDB:(FMDatabase *)fmdb -{ - self = [super init]; - if (self) - { - db = fmdb; - } - return self; -} - -- (void)addFareRules:(FareRules *)value { - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - [db executeUpdate:@"INSERT into fare_rules(fare_id,route_id,origin_id,destination_id,contains_id) values(?, ?, ?, ?, ?)", - value.fareId, - value.routeId, - value.originId, - value.destinationId, - value.containsId]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } -} - -- (void)cleanupAndCreate -{ - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - //Drop table if it exists - NSString *drop = @"DROP TABLE IF EXISTS fare_rules"; - - [db executeUpdate:drop]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } - - //Create table - NSString *create = @"CREATE TABLE 'fare_rules' ('fare_id' TEXT NOT NULL, 'route_id' TEXT NOT NULL, 'origin_id' TEXT NOT NULL, 'destination_id' TEXT NOT NULL, 'contains_id' TEXT NOT NULL)"; - - [db executeUpdate:create]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } -} - -- (void)receiveRecord:(NSDictionary *)aRecord -{ - FareRules *fareRulesRecord = [[FareRules alloc] init]; - fareRulesRecord.fareId = aRecord[@"fare_id"]; - fareRulesRecord.routeId = aRecord[@"route_id"]; - fareRulesRecord.originId = aRecord[@"origin_id"]; - fareRulesRecord.destinationId = aRecord[@"destination_id"]; - fareRulesRecord.containsId = aRecord[@"contains_id"]; - - [self addFareRules:fareRulesRecord]; -} - - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Route.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/Route.h deleted file mode 100644 index 8128086..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/Route.h +++ /dev/null @@ -1,26 +0,0 @@ -// -// Route.h -// GTFS-VTA -// -// Created by Vashishtha Jogi on 7/31/11. -// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. -// - -#import -#import "FMDatabase.h" - -@interface Route : NSObject - -@property (nonatomic, strong) NSString * routeLongName; -@property (nonatomic, strong) NSNumber * routeType; -@property (nonatomic, strong) NSString * routeId; -@property (nonatomic, strong) NSString * routeShortName; -@property (nonatomic, strong) NSString * agencyId; - -- (void)addRoute:(Route *)route; -- (id)initWithDB:(FMDatabase *)fmdb; -- (void)cleanupAndCreate; -- (void)receiveRecord:(NSDictionary *)aRecord; -- (NSArray *)getAllRoutes; - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Route.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/Route.m deleted file mode 100644 index 0177dde..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/Route.m +++ /dev/null @@ -1,137 +0,0 @@ -// -// Route.m -// GTFS-VTA -// -// Created by Vashishtha Jogi on 7/31/11. -// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. -// - -#import "Route.h" -#import "CSVParser.h" -#import "FMDatabase.h" -#import "Util.h" - -@interface Route () -{ - FMDatabase *db; -} - -@end - -@implementation Route - -- (id) initWithDB:(FMDatabase *)fmdb -{ - self = [super init]; - if (self) - { - db = fmdb; - } - return self; -} - -- (void)addRoute:(Route *)route -{ - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - [db executeUpdate:@"INSERT into routes(route_long_name,route_type,agency_id,route_id,route_short_name) values(?, ?, ?, ?, ?)", - route.routeLongName, - route.routeType, - route.agencyId, - route.routeId, - route.routeShortName]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } -} - -- (void)cleanupAndCreate -{ - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - //Drop table if it exists - NSString *drop = @"DROP TABLE IF EXISTS routes"; - - [db executeUpdate:drop]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } - - //Create table - NSString *create = @"CREATE TABLE 'routes' ('route_long_name' TEXT DEFAULT NULL,'route_type' int(2) DEFAULT NULL, 'agency_id' TEXT DEFAULT NULL, 'route_id' TEXT NOT NULL, 'route_short_name' TEXT DEFAULT NULL, PRIMARY KEY ('route_id'))"; - - [db executeUpdate:create]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } -} - -- (void)receiveRecord:(NSDictionary *)aRecord -{ - Route *routeRecord = [[Route alloc] init]; - routeRecord.routeId = aRecord[@"route_id"]; - routeRecord.routeLongName = [aRecord[@"route_long_name"] localizedCapitalizedString]; - routeRecord.routeShortName = [aRecord[@"route_short_name"] localizedCapitalizedString]; - routeRecord.routeType = aRecord[@"route_type"]; - routeRecord.agencyId = aRecord[@"agency_id"]; - - [self addRoute:routeRecord]; -} - -- (NSArray *)getAllRoutes -{ - - NSMutableArray *routes = [[NSMutableArray alloc] init]; - - FMDatabase *localdb = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - - [localdb setShouldCacheStatements:YES]; - if (![localdb open]) { - NSLog(@"Could not open db."); - //[db release]; - return nil; - } - - NSString *query = @"select routes.route_short_name, trips.route_id, trips.trip_headsign, trips.trip_id FROM routes, trips WHERE trips.route_id=routes.route_id"; - - FMResultSet *rs = [localdb executeQuery:query]; - while ([rs next]) { - // just print out what we've got in a number of formats. - NSMutableDictionary *route = [[NSMutableDictionary alloc] init]; - route[@"route_id"] = [rs objectForColumnName:@"route_id"]; - route[@"trip_headsign"] = [rs objectForColumnName:@"trip_headsign"]; - route[@"trip_id"] = [rs objectForColumnName:@"trip_id"]; - route[@"route_short_name"] = [rs objectForColumnName:@"route_short_name"]; - - - [routes addObject:route]; - - } - // close the result set. - [rs close]; - [localdb close]; - - return routes; - -} - - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Shape.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/Shape.h deleted file mode 100644 index 976a3b4..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/Shape.h +++ /dev/null @@ -1,25 +0,0 @@ -// -// Shape.h -// -// Created by Kevin Conley on 6/25/2013. -// - -#import -#import "FMDatabase.h" - - -@interface Shape : NSObject - -@property (nonatomic, strong) NSString * shapeId; -@property (nonatomic, strong) NSString * shapePtLat; -@property (nonatomic, strong) NSString * shapePtLon; -@property (nonatomic, strong) NSNumber * shapePtSequence; -@property (nonatomic, strong) NSNumber * shapeDistTraveled; - - -- (void)addShape:(Shape *)shape; -- (id)initWithDB:(FMDatabase *)fmdb; -- (void)cleanupAndCreate; -- (void)receiveRecord:(NSDictionary *)aRecord; - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Shape.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/Shape.m deleted file mode 100644 index 79612e7..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/Shape.m +++ /dev/null @@ -1,104 +0,0 @@ -// -// Shape.m -// -// Created by Kevin Conley on 6/25/2013. -// - -#import "Shape.h" -#import "CSVParser.h" -#import "FMDatabase.h" -#import "Util.h" - -@interface Shape () -{ - FMDatabase *db; -} - -@end - -@implementation Shape - -- (id)initWithDB:(FMDatabase *)fmdb -{ - self = [super init]; - if (self) - { - db = fmdb; - } - return self; -} - -- (void)addShape:(Shape *)shape -{ - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - [db executeUpdate:@"INSERT into shapes(shape_id,shape_pt_lat,shape_pt_lon,shape_pt_sequence,shape_dist_traveled) values(?, ?, ?, ?, ?)", - shape.shapeId, - shape.shapePtLat, - shape.shapePtLon, - shape.shapePtSequence, - shape.shapeDistTraveled]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } - -} - -- (void)cleanupAndCreate -{ - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - //Drop table if it exists - NSString *dropShape = @"DROP TABLE IF EXISTS shapes"; - - [db executeUpdate:dropShape]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } - - //Create table - NSString *createShape = @"CREATE TABLE 'shapes' ('shape_id' TEXT NOT NULL, 'shape_pt_lat' decimal(9,6) DEFAULT NULL, 'shape_pt_lon' decimal(9,6) DEFAULT NULL, 'shape_pt_sequence' INTEGER NOT NULL, 'shape_dist_traveled' decimal(9,6) DEFAULT NULL)"; - - NSString *createIndex = @"CREATE INDEX shape_id_shape ON shapes(shape_id)"; - - [db executeUpdate:createShape]; - [db executeUpdate:createIndex]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } -} - -- (void)receiveRecord:(NSDictionary *)aRecord -{ - - Shape *shapeRecord = [[Shape alloc] init]; - shapeRecord.shapeId = aRecord[@"shape_id"]; - shapeRecord.shapePtLat = aRecord[@"shape_pt_lat"]; - shapeRecord.shapePtLon = aRecord[@"shape_pt_lon"]; - shapeRecord.shapePtSequence = aRecord[@"shape_pt_sequence"]; - shapeRecord.shapeDistTraveled = aRecord[@"shape_dist_traveled"]; - - [self addShape:shapeRecord]; -} - - - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Stop.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/Stop.h deleted file mode 100644 index b8423bc..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/Stop.h +++ /dev/null @@ -1,30 +0,0 @@ -// -// Stop.h -// GTFS-VTA -// -// Created by Vashishtha Jogi on 7/31/11. -// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. -// - -#import -#import "FMDatabase.h" - -@interface Stop : NSObject - -@property (nonatomic, strong) NSNumber * stopLat; -@property (nonatomic, strong) NSNumber * stopLon; -@property (nonatomic, strong) NSString * stopId; -@property (nonatomic, strong) NSString * stopName; -@property (nonatomic, strong) NSString * stopDesc; -@property (nonatomic, strong) NSNumber * locationType; -@property (nonatomic, strong) NSString * zoneId; -@property (nonatomic, strong) NSArray * routes; - -- (void)addStop:(Stop *)stop; -- (id)initWithDB:(FMDatabase *)fmdb; -- (void)cleanupAndCreate; -- (void)receiveRecord:(NSDictionary *)aRecord; -- (void)updateStopWithRoutes:(NSArray *)routes withStopId:(NSString *)stopId; -- (void)updateRoutes; - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Stop.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/Stop.m deleted file mode 100644 index 0d60c2a..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/Stop.m +++ /dev/null @@ -1,162 +0,0 @@ -// -// Stop.m -// GTFS-VTA -// -// Created by Vashishtha Jogi on 7/31/11. -// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. -// - -#import "Stop.h" -#import "FMDatabase.h" -#import "CSVParser.h" -#import "Route.h" -#import "StopTime.h" -#import "Util.h" - -@interface Stop () -{ - FMDatabase *db; -} - -@end - -@implementation Stop - -- (id)initWithDB:(FMDatabase *)fmdb -{ - self = [super init]; - if (self) - { - db = fmdb; - } - return self; -} - -- (void)addStop:(Stop *)stop -{ - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - [db executeUpdate:@"INSERT into stops(stop_lat,zone_id,stop_lon,stop_id,stop_desc,stop_name,location_type) values(?, ?, ?, ?, ?, ?, ?)", - stop.stopLat, - stop.zoneId, - stop.stopLon, - stop.stopId, - stop.stopDesc, - stop.stopName, - stop.locationType]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } -} - -- (void)cleanupAndCreate -{ - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - //Drop table if it exists - NSString *drop = @"DROP TABLE IF EXISTS stops"; - - [db executeUpdate:drop]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } - - //Create table - NSString *create = @"CREATE TABLE 'stops' ('stop_lat' decimal(8,6) DEFAULT NULL, 'zone_id' TEXT DEFAULT NULL, 'stop_lon' decimal(9,6) DEFAULT NULL, 'stop_id' TEXT NOT NULL, 'stop_desc' TEXT DEFAULT NULL, 'stop_name' TEXT DEFAULT NULL, 'location_type' int(2) DEFAULT NULL, 'routes' TEXT DEFAULT NULL, PRIMARY KEY ('stop_id'))"; - - NSString *createIndex = @"CREATE INDEX stop_lat_lon_stops ON stops(stop_lat, stop_lon)"; - - [db executeUpdate:create]; - [db executeUpdate:createIndex]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } -} - -- (void)receiveRecord:(NSDictionary *)aRecord -{ - Stop *stopRecord = [[Stop alloc] init]; - stopRecord.stopId = aRecord[@"stop_id"]; - stopRecord.stopLat = aRecord[@"stop_lat"]; - stopRecord.stopLon = aRecord[@"stop_lon"]; - stopRecord.stopName = [aRecord[@"stop_name"] localizedCapitalizedString]; - stopRecord.stopDesc = aRecord[@"stop_desc"]; - stopRecord.zoneId = aRecord[@"zone_id"]; - stopRecord.locationType = aRecord[@"location_type"]; - - [self addStop:stopRecord]; -} - -- (void)updateStopWithRoutes:(NSArray *)route withStopId:(NSString *)stopId -{ - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - NSString *routeString = [route componentsJoinedByString:@", "]; - - [db executeUpdate:@"UPDATE stops SET routes=? where stop_id=?", - routeString, - stopId]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } -} - -- (void)updateRoutes -{ - @autoreleasepool { - NSMutableDictionary *stopWithRoutes = [[NSMutableDictionary alloc] init]; - //First get all unique route trips - Route *route = [[Route alloc] init]; - NSArray *routeArray = [route getAllRoutes]; - StopTime *stopTime = [[StopTime alloc] init]; - - for (NSDictionary *route in routeArray) { - NSArray *stops = [stopTime getStopsForTripId:route[@"trip_id"]]; - for (NSString *stopId in stops) { - if (stopWithRoutes[stopId]==nil) { - [stopWithRoutes setValue:[[NSMutableArray alloc] init] forKey:stopId]; - } - if ([stopWithRoutes[stopId] containsObject:route[@"route_short_name"]] == NO) { - [stopWithRoutes[stopId] addObject:route[@"route_short_name"]]; - } - } - } - - - // NSLog(@"%@, %lu", stopWithRoutes, [stopWithRoutes count]); - - for (NSString *key in [stopWithRoutes allKeys]) { -// NSLog(@"%@ - %@", key, [[stopWithRoutes objectForKey:key] componentsJoinedByString:@","]); - [self updateStopWithRoutes:stopWithRoutes[key] withStopId:key]; - } - } -} - - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/StopTime.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/StopTime.h deleted file mode 100644 index 25ef6d7..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/StopTime.h +++ /dev/null @@ -1,33 +0,0 @@ -// -// StopTime.h -// GTFS-VTA -// -// Created by Vashishtha Jogi on 7/31/11. -// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. -// - -#import -#import "FMDatabase.h" - -@interface StopTime : NSObject - -@property (nonatomic, strong) NSString *arrivalTime; -@property (nonatomic, strong) NSString *departureTime; -@property (nonatomic, strong) NSNumber *stopSequence; -@property (nonatomic, strong) NSString *tripId; -@property (nonatomic, strong) NSString *stopId; -@property (nonatomic, strong) NSNumber *isTimepoint; -@property (nonatomic, strong) NSNumber *isLastStop; - -- (void)addStopTime:(StopTime *)stopTime; -- (id)initWithDB:(FMDatabase *)fmdb; -- (void)cleanupAndCreate; -- (void)receiveRecord:(NSDictionary *)aRecord; -- (NSArray *)getStopsForTripId:(NSString *)tripId; -- (void)interpolateStopTimes; -- (NSArray *)getTimeInterpolatedStopTimesByTripId:(NSString *)tripId; -- (NSArray *)getStopTimesByTripId:(NSString *)tripId; -- (void)updateStopTimes:(NSArray *)interpolatedStopTimes; - - -@end \ No newline at end of file diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/StopTime.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/StopTime.m deleted file mode 100644 index dfc0e94..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/StopTime.m +++ /dev/null @@ -1,292 +0,0 @@ -// -// StopTime.m -// GTFS-VTA -// -// Created by Vashishtha Jogi on 7/31/11. -// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. -// - -#import "StopTime.h" -#import "Trip.h" -#import "FMDatabase.h" -#import "CSVParser.h" -#import "Util.h" - -@interface StopTime () -{ - FMDatabase *db; -} - -@end - -@implementation StopTime - -- (id)initWithDB:(FMDatabase *)fmdb -{ - self = [super init]; - if (self) - { - db = fmdb; - } - return self; -} - -- (NSSet *)getStopTimeObjects:(NSNumber *)stop_id { - return nil; -} - -- (void)addStopTime:(StopTime *)stopTime -{ - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - [db executeUpdate:@"INSERT into stop_times(trip_id,arrival_time,departure_time,stop_id,stop_sequence) values(?, ?, ?, ?, ?)", - stopTime.tripId, - stopTime.arrivalTime, - stopTime.departureTime, - stopTime.stopId, - stopTime.stopSequence]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } -} - -- (void)cleanupAndCreate -{ - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - //Drop table if it exists - NSString *drop = @"DROP TABLE IF EXISTS stop_times"; - - [db executeUpdate:drop]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } - - //Create table - NSString *create = @"CREATE TABLE 'stop_times' ('trip_id' TEXT DEFAULT NULL, 'arrival_time' time DEFAULT NULL, 'departure_time' time DEFAULT NULL, 'stop_id' TEXT DEFAULT NULL, 'stop_sequence' int(11) DEFAULT NULL, 'is_timepoint' tinyint(1) DEFAULT NULL, 'is_laststop' tinyint(1) DEFAULT NULL )"; - - NSString *createIndex = @"CREATE INDEX stop_id_stop_times ON stop_times(stop_id)"; - NSString *createIndex1 = @"CREATE INDEX trip_id_stop_times ON stop_times(trip_id)"; - - [db executeUpdate:create]; - [db executeUpdate:createIndex]; - [db executeUpdate:createIndex1]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } -} - -- (void)receiveRecord:(NSDictionary *)aRecord -{ - StopTime *stopTimeRecord = [[StopTime alloc] init]; - stopTimeRecord.tripId = aRecord[@"trip_id"]; - stopTimeRecord.departureTime = aRecord[@"departure_time"]; - stopTimeRecord.arrivalTime = aRecord[@"arrival_time"]; - stopTimeRecord.stopId = aRecord[@"stop_id"]; - stopTimeRecord.stopSequence = aRecord[@"stop_sequence"]; - - [self addStopTime:stopTimeRecord]; -} - -- (NSArray *)getStopsForTripId:(NSString *)tripId -{ - NSMutableArray *stops = [[NSMutableArray alloc] init]; - - FMDatabase *localdb = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - - [localdb setShouldCacheStatements:YES]; - if (![localdb open]) { - NSLog(@"Could not open db."); - //[db release]; - return nil; - } - - NSString *query = @"SELECT stop_id FROM stop_times WHERE trip_id=?"; - - FMResultSet *rs = [localdb executeQuery:query, tripId]; - while ([rs next]) { - [stops addObject:[rs stringForColumn:@"stop_id"]]; - } - // close the result set. - [rs close]; - [localdb close]; - - // NSLog(@"getStopTimesByTripId %d", [stop_times count]); - return stops; -} - -- (void)interpolateStopTimes -{ - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - //First get all trip ids - Trip *trip = [[Trip alloc] init]; - NSArray *tripIds = [trip getAllTripIds]; - - //for each trip id interpolate stop times and update database - for (NSString *tripId in tripIds) { - [self updateStopTimes:[self getTimeInterpolatedStopTimesByTripId:tripId]]; - } -} - -- (NSArray *)getTimeInterpolatedStopTimesByTripId:(NSString *)tripId -{ - NSMutableArray *stop_times_i = [[NSMutableArray alloc] init]; - - NSArray *stop_times = [self getStopTimesByTripId:tripId]; - // If there are no stoptimes [] is the correct return value but if the start - // or end are missing times there is no correct return value. - if (stop_times==nil || [stop_times count]==0) - return nil; - - NSMutableDictionary *cur_timepoint=nil; - NSMutableDictionary *next_timepoint = nil; - double distance_between_timepoints = 0; - double distance_traveled_between_timepoints = 0; - - for (int i=0; i < [stop_times count]; i++) - { - NSMutableDictionary *st = stop_times[i]; - if (st[@"arrival_time"] != nil && ![st[@"arrival_time"] isEqualToString:@""]) - { - cur_timepoint = st; - distance_between_timepoints = 0; - distance_traveled_between_timepoints = 0; - if (i + 1 < [stop_times count]) - { - int k = i + 1; - distance_between_timepoints += [Util ApproximateDistanceWithLat1:[stop_times[k-1][@"stop_lat"] doubleValue] - withLon1:[stop_times[k-1][@"stop_lon"] doubleValue] - withLat2:[stop_times[k][@"stop_lat"] doubleValue] - withLon2:[stop_times[k][@"stop_lon"] doubleValue]]; - while (stop_times[k][@"arrival_time"] == nil || [stop_times[k][@"arrival_time"] isEqualToString:@""]) - { - k += 1; - distance_between_timepoints += [Util ApproximateDistanceWithLat1:[stop_times[k-1][@"stop_lat"] doubleValue] - withLon1:[stop_times[k-1][@"stop_lon"] doubleValue] - withLat2:[stop_times[k][@"stop_lat"] doubleValue] - withLon2:[stop_times[k][@"stop_lon"] doubleValue]]; - } - next_timepoint = stop_times[k]; - } - NSMutableDictionary *temp_dict = [[NSMutableDictionary alloc] init]; - temp_dict[@"arrival_time"] = [Util TimeToSecondsSinceMidnight:st[@"arrival_time"]]; - temp_dict[@"stop_id"] = st[@"stop_id"]; - temp_dict[@"trip_id"] = st[@"trip_id"]; - temp_dict[@"stop_sequence"] = st[@"stop_sequence"]; - temp_dict[@"is_timepoint"] = @YES; - temp_dict[@"is_laststop"] = @NO; - [stop_times_i addObject:temp_dict]; - } - else - { - distance_traveled_between_timepoints += [Util ApproximateDistanceWithLat1:[stop_times[i-1][@"stop_lat"] doubleValue] - withLon1:[stop_times[i-1][@"stop_lon"] doubleValue] - withLat2:[st[@"stop_lat"] doubleValue] - withLon2:[st[@"stop_lon"] doubleValue]]; - float distance_percent = distance_traveled_between_timepoints / distance_between_timepoints; - int next_time = [[Util TimeToSecondsSinceMidnight:next_timepoint[@"arrival_time"]] intValue]; - int cur_time = [[Util TimeToSecondsSinceMidnight:cur_timepoint[@"arrival_time"]] intValue]; - int total_time = next_time - cur_time; -// NSLog(@"next- %d, cur - %d, total - %d, cur_timepoint- %@, D: %f, %f", next_time, cur_time, total_time, [cur_timepoint objectForKey:@"arrival_time"], distance_between_timepoints, distance_traveled_between_timepoints); - float time_estimate = distance_percent * total_time + [[Util TimeToSecondsSinceMidnight:cur_timepoint[@"arrival_time"]] intValue]; - NSMutableDictionary *temp_dict = [[NSMutableDictionary alloc] init]; - temp_dict[@"arrival_time"] = @((int)round(time_estimate)); - temp_dict[@"stop_id"] = st[@"stop_id"]; - temp_dict[@"trip_id"] = st[@"trip_id"]; - temp_dict[@"stop_sequence"] = st[@"stop_sequence"]; - temp_dict[@"is_timepoint"] = @NO; - temp_dict[@"is_laststop"] = @NO; - [stop_times_i addObject:temp_dict]; - } - } - - // update the last one - [stop_times_i lastObject][@"is_laststop"] = @YES; - - // NSLog(@"getTimeInterpolatedStopTimesByTripId %d", [stop_times_i count]); - return stop_times_i; -} - -- (NSArray *)getStopTimesByTripId:(NSString *)tripId -{ - NSMutableArray *stop_times = [[NSMutableArray alloc] init]; - - NSString *query = @"SELECT stops.stop_lat, stops.stop_lon, stop_times.trip_id, stop_times.arrival_time, stop_times.stop_id, stop_times.stop_sequence FROM stop_times, stops WHERE stop_times.trip_id=? AND stops.stop_id=stop_times.stop_id ORDER BY stop_times.stop_sequence"; - - FMResultSet *rs = [db executeQuery:query, tripId]; - while ([rs next]) { - // just print out what we've got in a number of formats. - NSMutableDictionary *stop_time = [[NSMutableDictionary alloc] init]; - - stop_time[@"stop_lat"] = [rs objectForColumnName:@"stop_lat"]; - stop_time[@"stop_lon"] = [rs objectForColumnName:@"stop_lon"]; - stop_time[@"stop_id"] = [rs objectForColumnName:@"stop_id"]; - stop_time[@"trip_id"] = [rs objectForColumnName:@"trip_id"]; - stop_time[@"arrival_time"] = [rs objectForColumnName:@"arrival_time"]; - stop_time[@"stop_sequence"] = [rs objectForColumnName:@"stop_sequence"]; - - [stop_times addObject:stop_time]; - } - // close the result set. - [rs close]; - // NSLog(@"getStopTimesByTripId %d", [stop_times count]); - return stop_times; -} - -- (void)updateStopTimes:(NSArray *)interpolatedStopTimes -{ - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - [db beginTransaction]; - - for (NSDictionary *stopTime in interpolatedStopTimes) { - [db executeUpdate:@"UPDATE stop_times SET arrival_time=?, is_timepoint=?, is_laststop=? WHERE trip_id=? AND stop_id=? AND stop_sequence=?", - [Util FormatSecondsSinceMidnight:stopTime[@"arrival_time"]], - stopTime[@"is_timepoint"], - stopTime[@"is_laststop"], - stopTime[@"trip_id"], - stopTime[@"stop_id"], - stopTime[@"stop_sequence"]]; - } - - [db commit]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } -} - - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Transformations.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/Transformations.h deleted file mode 100644 index 0534fd3..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/Transformations.h +++ /dev/null @@ -1,16 +0,0 @@ -// -// Transformations.h -// San Jose Transit GTFS -// -// Created by Vashishtha Jogi on 8/26/11. -// Copyright 2011 Vashishtha Jogi Inc. All rights reserved. -// - -#import -#import "FMDatabase.h" - -@interface Transformations : NSObject - --(void) applyTransformationsFromCSV; - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Transformations.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/Transformations.m deleted file mode 100644 index 8154289..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/Transformations.m +++ /dev/null @@ -1,71 +0,0 @@ -// -// Transformations.m -// San Jose Transit GTFS -// -// Created by Vashishtha Jogi on 8/26/11. -// Copyright 2011 Vashishtha Jogi Inc. All rights reserved. -// - -#import "Transformations.h" -#import "FMDatabase.h" -#import "CSVParser.h" -#import "Util.h" - -@interface Transformations () -{ - FMDatabase *db; -} - -@end - -@implementation Transformations - --(void) applyTransformationsFromCSV -{ - //Open db connection first - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - - NSError *error = nil; - - NSString *inputPath = [Util getTransformationsFilePath]; - NSString *csvString = [NSString stringWithContentsOfFile:inputPath encoding:NSUTF8StringEncoding error:&error]; - - if (!csvString) - { - NSLog(@"Couldn't read file at path %s\n. Error: %s", [inputPath UTF8String], [[error localizedDescription] ? [error localizedDescription] : [error description] UTF8String]); - exit(1); - } - - NSDate *startDate = [NSDate date]; - - CSVParser *parser =[[CSVParser alloc] initWithString:csvString separator:@";" hasHeader:NO fieldNames:nil]; - NSArray *parsed = [parser arrayOfParsedRows]; - - - - for (NSDictionary *record in parsed) - { - for(int i=0;i<[record count];i++) - { - [db beginTransaction]; - [db executeUpdate:[record valueForKey:[NSString stringWithFormat:@"FIELD_%d", i+1]]]; - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - } - [db commit]; - } - } - - NSDate *endDate = [NSDate date]; - - NSLog(@"Transformations successfully done in %f seconds.", [endDate timeIntervalSinceDate:startDate]); - - [db close]; -} - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Trip.h b/iOS/GTFSImporteriOS/GTFSImporter/Model/Trip.h deleted file mode 100644 index 83eb432..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/Trip.h +++ /dev/null @@ -1,28 +0,0 @@ -// -// Trip.h -// GTFS-VTA -// -// Created by Vashishtha Jogi on 7/31/11. -// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. -// - -#import -#import "FMDatabase.h" - -@interface Trip : NSObject - -@property (nonatomic, strong) NSString *tripHeadsign; -@property (nonatomic, strong) NSString *tripId; -@property (nonatomic, strong) NSString *routeId; -@property (nonatomic, strong) NSString *serviceId; -@property (nonatomic, strong) NSString *blockId; -@property (nonatomic, strong) NSNumber *directionId; -@property (nonatomic, strong) NSString *shapeId; - -- (void)addTrip:(Trip *)trip; -- (id)initWithDB:(FMDatabase *)fmdb; -- (void)cleanupAndCreate; -- (void)receiveRecord:(NSDictionary *)aRecord; -- (NSArray *)getAllTripIds; - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Model/Trip.m b/iOS/GTFSImporteriOS/GTFSImporter/Model/Trip.m deleted file mode 100644 index 4a77ecd..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Model/Trip.m +++ /dev/null @@ -1,152 +0,0 @@ -// -// Trip.m -// GTFS-VTA -// -// Created by Vashishtha Jogi on 7/31/11. -// Copyright (c) 2011 Vashishtha Jogi Inc. All rights reserved. -// - -#import "Trip.h" -#import "FMDatabase.h" -#import "CSVParser.h" -#import "Util.h" - -@interface Trip () -{ - FMDatabase *db; -} - -@end - -@implementation Trip - -- (id) initWithDB:(FMDatabase *)fmdb -{ - self = [super init]; - if (self) - { - db = fmdb; - } - return self; -} - -- (void)addTrip:(Trip *)trip -{ - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - [db executeUpdate:@"INSERT into trips(block_id,route_id,direction_id,trip_headsign,service_id,trip_id,shape_id) values(?, ?, ?, ?, ?, ?, ?)", - trip.blockId, - trip.routeId, - trip.directionId, - trip.tripHeadsign, - trip.serviceId, - trip.tripId, - trip.shapeId]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } -} - -- (void)cleanupAndCreate -{ - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - return; - } - } - - //Drop table if it exists - NSString *drop = @"DROP TABLE IF EXISTS trips"; - - [db executeUpdate:drop]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } - - //Create table - NSString *create = @"CREATE TABLE 'trips' ('block_id' TEXT DEFAULT NULL, 'route_id' TEXT DEFAULT NULL, 'direction_id' tinyint(1) DEFAULT NULL, 'trip_headsign' TEXT DEFAULT NULL, 'service_id' TEXT DEFAULT NULL, 'trip_id' TEXT NOT NULL, 'shape_id' TEXT NOT NULL, PRIMARY KEY ('trip_id'))"; - - NSString *createIndex = @"CREATE INDEX route_id_trips ON trips(route_id)"; - - [db executeUpdate:create]; - [db executeUpdate:createIndex]; - - if ([db hadError]) { - NSLog(@"Err %d: %@", [db lastErrorCode], [db lastErrorMessage]); - return; - } -} - -- (void)receiveRecord:(NSDictionary *)aRecord -{ - Trip *tripRecord = [[Trip alloc] init]; - tripRecord.blockId = aRecord[@"block_id"]; - tripRecord.routeId = aRecord[@"route_id"]; - tripRecord.serviceId = aRecord[@"service_id"]; - tripRecord.tripId = aRecord[@"trip_id"]; - tripRecord.shapeId = aRecord[@"shape_id"]; - - if (aRecord[@"trip_headsign"]) { - NSString *headsign = [[[aRecord[@"trip_headsign"] localizedCapitalizedString] stringByReplacingOccurrencesOfString:aRecord[@"route_id"] withString:@""] stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]]; - tripRecord.tripHeadsign = headsign; - } - - // if direction_id is empty, try to derive it - if ([aRecord[@"direction_id"] length] == 0) { - if ([aRecord[@"trip_headsign"] rangeOfString:@"NB"].location != NSNotFound || [aRecord[@"trip_headsign"] rangeOfString:@"WB"].location != NSNotFound) { - tripRecord.directionId = @0; - } else if ([aRecord[@"trip_headsign"] rangeOfString:@"SB"].location != NSNotFound || [aRecord[@"trip_headsign"] rangeOfString:@"EB"].location != NSNotFound) { - tripRecord.directionId = @1; - } else { - tripRecord.directionId = @2; - } - } else { - tripRecord.directionId = aRecord[@"direction_id"]; - } - - [self addTrip:tripRecord]; -} - -- (NSArray *)getAllTripIds -{ - NSMutableArray *tripIds = [[NSMutableArray alloc] init]; - - if (db==nil) { - db = [FMDatabase databaseWithPath:[Util getDatabasePath]]; - if (![db open]) { - NSLog(@"Could not open db."); - db = nil; - return nil; - } - - db.shouldCacheStatements=YES; - } - - NSString *query = @"SELECT trip_id from trips"; - - FMResultSet *rs = [db executeQuery:query]; - while ([rs next]) { - [tripIds addObject:[rs objectForColumnName:@"trip_id"]]; - } - // close the result set. - [rs close]; - [db close]; - - // NSLog(@"getStopTimesByTripId %d", [stop_times count]); - return tripIds; -} - - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Util.h b/iOS/GTFSImporteriOS/GTFSImporter/Util.h deleted file mode 100644 index 83b86a3..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Util.h +++ /dev/null @@ -1,29 +0,0 @@ -// -// Util.h -// GTFSImporter -// -// Created by Vashishtha Jogi on 9/7/11. -// Copyright 2011 Vashishtha Jogi. All rights reserved. -// - -#import -#import "Stop.h" - -@interface Util : NSObject - -+ (NSString *) getTransitFilesBasepath; -+ (NSString *) getTransformationsFilePath; -+ (NSString *) getDatabasePath; -+ (double) ApproximateDistanceWithLat1:(double)lat1 withLon1:(double)lon1 withLat2:(double)lat2 withLon2:(double)lon2; -+ (double) ApproximateDistanceBetweenStop1:(Stop *)stop1 stop2:(Stop *)stop2; -+ (NSNumber *) TimeToSecondsSinceMidnight:(NSString *)time; -+ (NSString *) FormatSecondsSinceMidnight:(NSNumber *)seconds; -+ (NSString *) getDayFromDate:(NSDate *)date; -+ (NSString *) getDateStringFromDate:(NSDate *)date withFormat:(NSString *)format; -+ (NSString *) getTimeStringFromDate:(NSDate *)date withFormat:(NSString *)format; - -+ (void) setTransitFilesBasepath:(NSString *)transitFilesBasepath; -+ (void) setTransformationsFilePath:(NSString *)transformationsFilePath; -+ (void) setDatabasePath:(NSString *)databasePath; - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/Util.m b/iOS/GTFSImporteriOS/GTFSImporter/Util.m deleted file mode 100644 index 7325653..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/Util.m +++ /dev/null @@ -1,181 +0,0 @@ -// -// Util.m -// GTFSImporter -// -// Created by Vashishtha Jogi on 9/7/11. -// Copyright 2011 Vashishtha Jogi. All rights reserved. -// - -#import "Util.h" - -#define kEarthRadius 6378135 //in meters - -@implementation Util - -static NSString *kTransitFilesBasepath; -static NSString *kTransformationsFilePath; -static NSString *kDatabasePath; - -+ (void)initialize -{ - if (self == [Util class]) { - kTransitFilesBasepath = @"~/Desktop/gtfs_source"; - kTransformationsFilePath = @"~/Desktop/gtfs_transformations.txt"; - kDatabasePath = @"~/Desktop/gtfs.db"; - } -} - -/* - This is root directory where all the gtfs files live. This directory will contain agency.txt, routes.txt, etc. - */ -+ (NSString *) getTransitFilesBasepath -{ - return [kTransitFilesBasepath stringByExpandingTildeInPath]; -} - -+ (void) setTransitFilesBasepath:(NSString *)transitFilesBasepath -{ - kTransitFilesBasepath = transitFilesBasepath; -} - -/* - This is something new. After your data is imported, sqlite queries from this file will be executed on the imported data. You may want to delete any extraneous trips, or delete all trips before a certain date, etc. This is a comma separeted file with all queries. For an example see transformations.txt. If you dont need to apply any transformations, leave the file empty. Or if you dont want to apply the transformations just comment out the transformations call in main.m file. - */ -+ (NSString *) getTransformationsFilePath -{ - return [kTransformationsFilePath stringByExpandingTildeInPath]; -} - -+ (void) setTransformationsFilePath:(NSString *)transformationsFilePath -{ - kTransformationsFilePath = transformationsFilePath; -} - -/* - The path where the database will be created. The file is created for you if it does not exist. But the directory in which the file will be created needs to pre-exist. - */ -+ (NSString *) getDatabasePath -{ - return [kDatabasePath stringByExpandingTildeInPath]; -} - -+ (void) setDatabasePath:(NSString *)databasePath -{ - kDatabasePath = databasePath; -} - -/*Compute approximate distance between two points in meters. Assumes the - Earth is a sphere. - # TODO: change to ellipsoid approximation, such as - # http://www.codeguru.com/Cpp/Cpp/algorithms/article.php/c5115/ - */ -+ (double) ApproximateDistanceWithLat1:(double)lat1 withLon1:(double)lon1 withLat2:(double)lat2 withLon2:(double)lon2 -{ - lat1 = lat1 * M_PI/180; - lon1 = lon1 * M_PI/180; - lat2 = lat2 * M_PI/180; - lon2 = lon2 * M_PI/180; - - double dlat = sin(0.5 * (lat2 - lat1)); - double dlng = sin(0.5 * (lon2 - lon1)); - double x = dlat * dlat + dlng * dlng * cos(lat1) * cos(lat2); - - return kEarthRadius * (2 * atan2(sqrt(x), sqrt(MAX(0.0, 1.0 - x)))); -} - -//Compute approximate distance between two stops in meters. Assumes the -//Earth is a sphere. - -+ (double) ApproximateDistanceBetweenStop1:(Stop *)stop1 stop2:(Stop *)stop2 -{ - return [Util ApproximateDistanceWithLat1:[stop1.stopLat doubleValue] withLon1:[stop1.stopLon doubleValue] - withLat2:[stop2.stopLat doubleValue] withLon2:[stop2.stopLon doubleValue]]; -} - -/* - Convert HHH:MM:SS into seconds since midnight. - - For example "01:02:03" returns 3723. The leading zero of the hours may be - omitted. HH may be more than 23 if the time is on the following day. - */ - -+ (NSNumber *) TimeToSecondsSinceMidnight:(NSString *)time -{ - NSArray *timeArray = [time componentsSeparatedByString:@":"]; - return @([timeArray[0] intValue] * 3600 + [timeArray[1] intValue] * 60 + [timeArray[2] intValue]);; -} - -// Formats an int number of seconds past midnight into a string as "HH:MM:SS". - -+ (NSString *) FormatSecondsSinceMidnight:(NSNumber *)seconds -{ - int s = [seconds intValue]; - return [NSString stringWithFormat:@"%02d:%02d:%02d", s / 3600, (s / 60) % 60, s % 60]; -} - -+ (NSString *) getDayFromDate:(NSDate *)date -{ - // setting units we would like to use in future - unsigned units = NSYearCalendarUnit | NSMonthCalendarUnit | NSDayCalendarUnit | NSWeekdayCalendarUnit; - // creating NSCalendar object - NSCalendar *calendar = [[NSCalendar alloc] initWithCalendarIdentifier:NSGregorianCalendar]; - // extracting components from date - NSDateComponents *components = [calendar components:units fromDate:date]; - - - switch ([components weekday]) { - case 1: - return @"sunday"; - break; - case 2: - return @"monday"; - break; - case 3: - return @"tuesday"; - break; - case 4: - return @"wednesday"; - break; - case 5: - return @"thursday"; - break; - case 6: - return @"friday"; - break; - case 7: - return @"saturday"; - break; - default: - return @""; - break; - } -} - -//Converts NSDate to specified format, Default yyyy-MM-dd if nil is passed for format -+ (NSString *) getDateStringFromDate:(NSDate *)date withFormat:(NSString *)format -{ - NSDateFormatter *sDateFormatter = [[NSDateFormatter alloc] init]; - if (format==nil) - [sDateFormatter setDateFormat:@"yyyy-MM-dd"]; - else - [sDateFormatter setDateFormat:format]; - - return [sDateFormatter stringFromDate:date]; - -} - -//Converts NSDate to specified format, Default hh:mm:ss if nil is passed for format -+ (NSString *) getTimeStringFromDate:(NSDate *)date withFormat:(NSString *)format -{ - NSDateFormatter *sDateFormatter = [[NSDateFormatter alloc] init]; - if (format==nil) - [sDateFormatter setDateFormat:@"HH:mm:ss"]; - else - [sDateFormatter setDateFormat:format]; - - return [sDateFormatter stringFromDate:date]; - -} - - -@end diff --git a/iOS/GTFSImporteriOS/GTFSImporter/main.m b/iOS/GTFSImporteriOS/GTFSImporter/main.m deleted file mode 100644 index 85428d2..0000000 --- a/iOS/GTFSImporteriOS/GTFSImporter/main.m +++ /dev/null @@ -1,101 +0,0 @@ -// -// main.m -// GTFSImporter -// -// Created by Vashishtha Jogi on 8/27/11. -// Copyright 2011 Vashishtha Jogi. All rights reserved. -// - -#import -#import "CSVImporter.h" -#import "Util.h" - -int main (int argc, const char * argv[]) -{ - NSLog(@"Originally built by Vashishtha Jogi -> https://github.com/jvashishtha."); - NSLog(@"Modified by Connect Think LLC -> www.connectthink.com "); - NSLog(@"Source available at https://github.com/ConnectThink/GTFSImporter"); - NSLog(@"========================="); - - // SET PATH OVERRIDES - if (argc >= 2) { - NSString *sourcePath = [NSString stringWithUTF8String:argv[1]]; - [Util setTransitFilesBasepath:sourcePath]; - } - - if (argc >= 3) { - NSString *destinationPath = [NSString stringWithUTF8String:argv[2]]; - [Util setDatabasePath:destinationPath]; - } - - // IMPORT - CSVImporter *importer = [[CSVImporter alloc] init]; - - NSLog(@"Importing Agency..."); - [importer addAgency]; - - - NSLog(@"Importing Fare Attributes..."); - [importer addFareAttributes]; - - - NSLog(@"Importing Fare Rules..."); - [importer addFareRules]; - - - NSLog(@"Importing Calendar..."); - [importer addCalendar]; - - - NSLog(@"Importing Calendar Dates..."); - [importer addCalendarDate]; - - - NSLog(@"Importing Routes..."); - [importer addRoute]; - - - NSLog(@"Importing Stops..."); - [importer addStop]; - - - NSLog(@"Importing Trips..."); - [importer addTrip]; - - - NSLog(@"Importing Shapes..."); - [importer addShape]; - - - NSLog(@"Importing StopTime..."); - [importer addStopTime]; - - //Comment this out if you dont want to apply any transformations - //NSLog(@"Sanitizing data..."); - //[importer sanitizeData]; - - NSLog(@"Vacumming..."); - [importer vacuum]; - - - NSLog(@"Reindexing..."); - [importer reindex]; - - - //For convinience. This will add and extra column routes which will contain comma seperated route numbers passing through this stop - NSLog(@"Adding routes to stops..."); - [importer addStopRoutes]; - - NSLog(@"Interpolating stop times"); - [importer addInterpolatedStopTime]; - - NSLog(@"Vacumming..."); - [importer vacuum]; - - NSLog(@"Reindexing..."); - [importer reindex]; - - NSLog(@"Import complete!"); - - return 0; -} diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS.xcodeproj/project.pbxproj b/iOS/GTFSImporteriOS/GTFSImporteriOS.xcodeproj/project.pbxproj index 7230159..3ec5580 100644 --- a/iOS/GTFSImporteriOS/GTFSImporteriOS.xcodeproj/project.pbxproj +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS.xcodeproj/project.pbxproj @@ -13,7 +13,6 @@ 93BA291A1D83EDFC008674E7 /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 93BA29181D83EDFC008674E7 /* Main.storyboard */; }; 93BA291C1D83EDFC008674E7 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 93BA291B1D83EDFC008674E7 /* Assets.xcassets */; }; 93BA291F1D83EDFC008674E7 /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 93BA291D1D83EDFC008674E7 /* LaunchScreen.storyboard */; }; - 93BA29271D83EF09008674E7 /* GTFSImporter in Resources */ = {isa = PBXBuildFile; fileRef = 93BA29261D83EF09008674E7 /* GTFSImporter */; }; 93BA292A1D83EF8B008674E7 /* GTFS Caltrain Devs.zip in Resources */ = {isa = PBXBuildFile; fileRef = 93BA29291D83EF8B008674E7 /* GTFS Caltrain Devs.zip */; }; 93BA29531D83F0B1008674E7 /* aescrypt.c in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29301D83F0B1008674E7 /* aescrypt.c */; }; 93BA29541D83F0B1008674E7 /* aeskey.c in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29311D83F0B1008674E7 /* aeskey.c */; }; @@ -31,28 +30,28 @@ 93BA29601D83F0B1008674E7 /* zip.c in Sources */ = {isa = PBXBuildFile; fileRef = 93BA294C1D83F0B1008674E7 /* zip.c */; }; 93BA29621D83F0B1008674E7 /* SSZipArchive.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29501D83F0B1008674E7 /* SSZipArchive.m */; }; 93BA29641D83F149008674E7 /* libz.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 93BA29631D83F149008674E7 /* libz.tbd */; }; - 93BA29941D83F84D008674E7 /* CSVImporter.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29681D83F84D008674E7 /* CSVImporter.m */; }; - 93BA29951D83F84D008674E7 /* GTFSImporter.1 in Resources */ = {isa = PBXBuildFile; fileRef = 93BA296A1D83F84D008674E7 /* GTFSImporter.1 */; }; - 93BA29961D83F84D008674E7 /* CSVParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA296E1D83F84D008674E7 /* CSVParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; }; - 93BA29971D83F84D008674E7 /* FMDatabase.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29711D83F84D008674E7 /* FMDatabase.m */; }; - 93BA29981D83F84D008674E7 /* FMDatabaseAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29731D83F84D008674E7 /* FMDatabaseAdditions.m */; }; - 93BA29991D83F84D008674E7 /* FMDatabasePool.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29751D83F84D008674E7 /* FMDatabasePool.m */; }; - 93BA299A1D83F84D008674E7 /* FMDatabaseQueue.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29771D83F84D008674E7 /* FMDatabaseQueue.m */; }; - 93BA299B1D83F84D008674E7 /* FMResultSet.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29791D83F84D008674E7 /* FMResultSet.m */; }; - 93BA299D1D83F84D008674E7 /* Agency.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA297D1D83F84D008674E7 /* Agency.m */; }; - 93BA299E1D83F84D008674E7 /* Calendar.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA297F1D83F84D008674E7 /* Calendar.m */; }; - 93BA299F1D83F84D008674E7 /* CalendarDate.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29811D83F84D008674E7 /* CalendarDate.m */; }; - 93BA29A01D83F84D008674E7 /* FareAttributes.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29831D83F84D008674E7 /* FareAttributes.m */; }; - 93BA29A11D83F84D008674E7 /* FareRules.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29851D83F84D008674E7 /* FareRules.m */; }; - 93BA29A21D83F84D008674E7 /* Route.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29871D83F84D008674E7 /* Route.m */; }; - 93BA29A31D83F84D008674E7 /* Shape.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29891D83F84D008674E7 /* Shape.m */; }; - 93BA29A41D83F84D008674E7 /* Stop.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA298B1D83F84D008674E7 /* Stop.m */; }; - 93BA29A51D83F84D008674E7 /* StopTime.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA298D1D83F84D008674E7 /* StopTime.m */; }; - 93BA29A61D83F84D008674E7 /* Transformations.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA298F1D83F84D008674E7 /* Transformations.m */; }; - 93BA29A71D83F84D008674E7 /* Trip.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29911D83F84D008674E7 /* Trip.m */; }; - 93BA29A81D83F84D008674E7 /* Util.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29931D83F84D008674E7 /* Util.m */; }; 93BA29AA1D83F98B008674E7 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 93BA29A91D83F98B008674E7 /* Foundation.framework */; }; 93BA29AC1D83F9B0008674E7 /* libsqlite3.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 93BA29AB1D83F9B0008674E7 /* libsqlite3.tbd */; }; + 93BA29AE1D84C3D5008674E7 /* GTFSImporter in Resources */ = {isa = PBXBuildFile; fileRef = 93BA29AD1D84C3D5008674E7 /* GTFSImporter */; }; + 93BA29B11D84C505008674E7 /* CSVImporter.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29AF1D84C505008674E7 /* CSVImporter.m */; }; + 93BA29B21D84C505008674E7 /* Util.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29B01D84C505008674E7 /* Util.m */; }; + 93BA29BE1D84C53D008674E7 /* Agency.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29B31D84C53D008674E7 /* Agency.m */; }; + 93BA29BF1D84C53D008674E7 /* Calendar.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29B41D84C53D008674E7 /* Calendar.m */; }; + 93BA29C01D84C53D008674E7 /* CalendarDate.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29B51D84C53D008674E7 /* CalendarDate.m */; }; + 93BA29C11D84C53D008674E7 /* FareAttributes.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29B61D84C53D008674E7 /* FareAttributes.m */; }; + 93BA29C21D84C53D008674E7 /* FareRules.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29B71D84C53D008674E7 /* FareRules.m */; }; + 93BA29C31D84C53D008674E7 /* Route.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29B81D84C53D008674E7 /* Route.m */; }; + 93BA29C41D84C53D008674E7 /* Shape.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29B91D84C53D008674E7 /* Shape.m */; }; + 93BA29C51D84C53D008674E7 /* Stop.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29BA1D84C53D008674E7 /* Stop.m */; }; + 93BA29C61D84C53D008674E7 /* StopTime.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29BB1D84C53D008674E7 /* StopTime.m */; }; + 93BA29C71D84C53D008674E7 /* Transformations.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29BC1D84C53D008674E7 /* Transformations.m */; }; + 93BA29C81D84C53D008674E7 /* Trip.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29BD1D84C53D008674E7 /* Trip.m */; }; + 93BA29CF1D84C560008674E7 /* CSVParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29C91D84C560008674E7 /* CSVParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; }; + 93BA29D01D84C560008674E7 /* FMDatabase.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29CA1D84C560008674E7 /* FMDatabase.m */; }; + 93BA29D11D84C560008674E7 /* FMDatabaseAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29CB1D84C560008674E7 /* FMDatabaseAdditions.m */; }; + 93BA29D21D84C560008674E7 /* FMDatabasePool.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29CC1D84C560008674E7 /* FMDatabasePool.m */; }; + 93BA29D31D84C560008674E7 /* FMDatabaseQueue.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29CD1D84C560008674E7 /* FMDatabaseQueue.m */; }; + 93BA29D41D84C560008674E7 /* FMResultSet.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29CE1D84C560008674E7 /* FMResultSet.m */; }; /* End PBXBuildFile section */ /* Begin PBXFileReference section */ @@ -66,7 +65,6 @@ 93BA291B1D83EDFC008674E7 /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = ""; }; 93BA291E1D83EDFC008674E7 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = ""; }; 93BA29201D83EDFC008674E7 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; - 93BA29261D83EF09008674E7 /* GTFSImporter */ = {isa = PBXFileReference; lastKnownFileType = folder; name = GTFSImporter; path = "/Users/aaron/Dropbox/Programming/Projects/Open Source/GTFSImporter/GTFSImporter"; sourceTree = ""; }; 93BA29291D83EF8B008674E7 /* GTFS Caltrain Devs.zip */ = {isa = PBXFileReference; lastKnownFileType = archive.zip; path = "GTFS Caltrain Devs.zip"; sourceTree = ""; }; 93BA292E1D83F0B1008674E7 /* aes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = aes.h; sourceTree = ""; }; 93BA292F1D83F0B1008674E7 /* aes_via_ace.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = aes_via_ace.h; sourceTree = ""; }; @@ -104,49 +102,28 @@ 93BA29511D83F0B1008674E7 /* SSZipCommon.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SSZipCommon.h; sourceTree = ""; }; 93BA29521D83F0B1008674E7 /* ZipArchive.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZipArchive.h; sourceTree = ""; }; 93BA29631D83F149008674E7 /* libz.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libz.tbd; path = usr/lib/libz.tbd; sourceTree = SDKROOT; }; - 93BA29671D83F84D008674E7 /* CSVImporter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSVImporter.h; sourceTree = ""; }; - 93BA29681D83F84D008674E7 /* CSVImporter.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CSVImporter.m; sourceTree = ""; }; - 93BA29691D83F84D008674E7 /* GTFSImporter-Prefix.pch */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "GTFSImporter-Prefix.pch"; sourceTree = ""; }; - 93BA296A1D83F84D008674E7 /* GTFSImporter.1 */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.man; path = GTFSImporter.1; sourceTree = ""; }; - 93BA296D1D83F84D008674E7 /* CSVParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSVParser.h; sourceTree = ""; }; - 93BA296E1D83F84D008674E7 /* CSVParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CSVParser.m; sourceTree = ""; }; - 93BA29701D83F84D008674E7 /* FMDatabase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FMDatabase.h; sourceTree = ""; }; - 93BA29711D83F84D008674E7 /* FMDatabase.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FMDatabase.m; sourceTree = ""; }; - 93BA29721D83F84D008674E7 /* FMDatabaseAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FMDatabaseAdditions.h; sourceTree = ""; }; - 93BA29731D83F84D008674E7 /* FMDatabaseAdditions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FMDatabaseAdditions.m; sourceTree = ""; }; - 93BA29741D83F84D008674E7 /* FMDatabasePool.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FMDatabasePool.h; sourceTree = ""; }; - 93BA29751D83F84D008674E7 /* FMDatabasePool.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FMDatabasePool.m; sourceTree = ""; }; - 93BA29761D83F84D008674E7 /* FMDatabaseQueue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FMDatabaseQueue.h; sourceTree = ""; }; - 93BA29771D83F84D008674E7 /* FMDatabaseQueue.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FMDatabaseQueue.m; sourceTree = ""; }; - 93BA29781D83F84D008674E7 /* FMResultSet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FMResultSet.h; sourceTree = ""; }; - 93BA29791D83F84D008674E7 /* FMResultSet.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FMResultSet.m; sourceTree = ""; }; - 93BA297A1D83F84D008674E7 /* main.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = ""; }; - 93BA297C1D83F84D008674E7 /* Agency.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Agency.h; sourceTree = ""; }; - 93BA297D1D83F84D008674E7 /* Agency.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Agency.m; sourceTree = ""; }; - 93BA297E1D83F84D008674E7 /* Calendar.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Calendar.h; sourceTree = ""; }; - 93BA297F1D83F84D008674E7 /* Calendar.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Calendar.m; sourceTree = ""; }; - 93BA29801D83F84D008674E7 /* CalendarDate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CalendarDate.h; sourceTree = ""; }; - 93BA29811D83F84D008674E7 /* CalendarDate.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CalendarDate.m; sourceTree = ""; }; - 93BA29821D83F84D008674E7 /* FareAttributes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FareAttributes.h; sourceTree = ""; }; - 93BA29831D83F84D008674E7 /* FareAttributes.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FareAttributes.m; sourceTree = ""; }; - 93BA29841D83F84D008674E7 /* FareRules.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FareRules.h; sourceTree = ""; }; - 93BA29851D83F84D008674E7 /* FareRules.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FareRules.m; sourceTree = ""; }; - 93BA29861D83F84D008674E7 /* Route.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Route.h; sourceTree = ""; }; - 93BA29871D83F84D008674E7 /* Route.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Route.m; sourceTree = ""; }; - 93BA29881D83F84D008674E7 /* Shape.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Shape.h; sourceTree = ""; }; - 93BA29891D83F84D008674E7 /* Shape.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Shape.m; sourceTree = ""; }; - 93BA298A1D83F84D008674E7 /* Stop.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Stop.h; sourceTree = ""; }; - 93BA298B1D83F84D008674E7 /* Stop.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Stop.m; sourceTree = ""; }; - 93BA298C1D83F84D008674E7 /* StopTime.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StopTime.h; sourceTree = ""; }; - 93BA298D1D83F84D008674E7 /* StopTime.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = StopTime.m; sourceTree = ""; }; - 93BA298E1D83F84D008674E7 /* Transformations.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Transformations.h; sourceTree = ""; }; - 93BA298F1D83F84D008674E7 /* Transformations.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Transformations.m; sourceTree = ""; }; - 93BA29901D83F84D008674E7 /* Trip.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Trip.h; sourceTree = ""; }; - 93BA29911D83F84D008674E7 /* Trip.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Trip.m; sourceTree = ""; }; - 93BA29921D83F84D008674E7 /* Util.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Util.h; sourceTree = ""; }; - 93BA29931D83F84D008674E7 /* Util.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Util.m; sourceTree = ""; }; 93BA29A91D83F98B008674E7 /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = System/Library/Frameworks/Foundation.framework; sourceTree = SDKROOT; }; 93BA29AB1D83F9B0008674E7 /* libsqlite3.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libsqlite3.tbd; path = usr/lib/libsqlite3.tbd; sourceTree = SDKROOT; }; + 93BA29AD1D84C3D5008674E7 /* GTFSImporter */ = {isa = PBXFileReference; lastKnownFileType = folder; name = GTFSImporter; path = ../../GTFSImporter; sourceTree = ""; }; + 93BA29AF1D84C505008674E7 /* CSVImporter.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = CSVImporter.m; path = ../../GTFSImporter/CSVImporter.m; sourceTree = ""; }; + 93BA29B01D84C505008674E7 /* Util.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = Util.m; path = ../../GTFSImporter/Util.m; sourceTree = ""; }; + 93BA29B31D84C53D008674E7 /* Agency.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = Agency.m; path = ../../GTFSImporter/Model/Agency.m; sourceTree = ""; }; + 93BA29B41D84C53D008674E7 /* Calendar.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = Calendar.m; path = ../../GTFSImporter/Model/Calendar.m; sourceTree = ""; }; + 93BA29B51D84C53D008674E7 /* CalendarDate.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = CalendarDate.m; path = ../../GTFSImporter/Model/CalendarDate.m; sourceTree = ""; }; + 93BA29B61D84C53D008674E7 /* FareAttributes.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = FareAttributes.m; path = ../../GTFSImporter/Model/FareAttributes.m; sourceTree = ""; }; + 93BA29B71D84C53D008674E7 /* FareRules.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = FareRules.m; path = ../../GTFSImporter/Model/FareRules.m; sourceTree = ""; }; + 93BA29B81D84C53D008674E7 /* Route.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = Route.m; path = ../../GTFSImporter/Model/Route.m; sourceTree = ""; }; + 93BA29B91D84C53D008674E7 /* Shape.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = Shape.m; path = ../../GTFSImporter/Model/Shape.m; sourceTree = ""; }; + 93BA29BA1D84C53D008674E7 /* Stop.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = Stop.m; path = ../../GTFSImporter/Model/Stop.m; sourceTree = ""; }; + 93BA29BB1D84C53D008674E7 /* StopTime.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = StopTime.m; path = ../../GTFSImporter/Model/StopTime.m; sourceTree = ""; }; + 93BA29BC1D84C53D008674E7 /* Transformations.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = Transformations.m; path = ../../GTFSImporter/Model/Transformations.m; sourceTree = ""; }; + 93BA29BD1D84C53D008674E7 /* Trip.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = Trip.m; path = ../../GTFSImporter/Model/Trip.m; sourceTree = ""; }; + 93BA29C91D84C560008674E7 /* CSVParser.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = CSVParser.m; path = ../../GTFSImporter/Libraries/CSVParser/CSVParser.m; sourceTree = ""; }; + 93BA29CA1D84C560008674E7 /* FMDatabase.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = FMDatabase.m; path = ../../GTFSImporter/Libraries/SQLite/FMDatabase.m; sourceTree = ""; }; + 93BA29CB1D84C560008674E7 /* FMDatabaseAdditions.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = FMDatabaseAdditions.m; path = ../../GTFSImporter/Libraries/SQLite/FMDatabaseAdditions.m; sourceTree = ""; }; + 93BA29CC1D84C560008674E7 /* FMDatabasePool.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = FMDatabasePool.m; path = ../../GTFSImporter/Libraries/SQLite/FMDatabasePool.m; sourceTree = ""; }; + 93BA29CD1D84C560008674E7 /* FMDatabaseQueue.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = FMDatabaseQueue.m; path = ../../GTFSImporter/Libraries/SQLite/FMDatabaseQueue.m; sourceTree = ""; }; + 93BA29CE1D84C560008674E7 /* FMResultSet.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = FMResultSet.m; path = ../../GTFSImporter/Libraries/SQLite/FMResultSet.m; sourceTree = ""; }; /* End PBXFileReference section */ /* Begin PBXFrameworksBuildPhase section */ @@ -166,10 +143,29 @@ 93BA29031D83EDFC008674E7 = { isa = PBXGroup; children = ( + 93BA29C91D84C560008674E7 /* CSVParser.m */, + 93BA29CA1D84C560008674E7 /* FMDatabase.m */, + 93BA29CB1D84C560008674E7 /* FMDatabaseAdditions.m */, + 93BA29CC1D84C560008674E7 /* FMDatabasePool.m */, + 93BA29CD1D84C560008674E7 /* FMDatabaseQueue.m */, + 93BA29CE1D84C560008674E7 /* FMResultSet.m */, + 93BA29B31D84C53D008674E7 /* Agency.m */, + 93BA29B41D84C53D008674E7 /* Calendar.m */, + 93BA29B51D84C53D008674E7 /* CalendarDate.m */, + 93BA29B61D84C53D008674E7 /* FareAttributes.m */, + 93BA29B71D84C53D008674E7 /* FareRules.m */, + 93BA29B81D84C53D008674E7 /* Route.m */, + 93BA29B91D84C53D008674E7 /* Shape.m */, + 93BA29BA1D84C53D008674E7 /* Stop.m */, + 93BA29BB1D84C53D008674E7 /* StopTime.m */, + 93BA29BC1D84C53D008674E7 /* Transformations.m */, + 93BA29BD1D84C53D008674E7 /* Trip.m */, + 93BA29AF1D84C505008674E7 /* CSVImporter.m */, + 93BA29B01D84C505008674E7 /* Util.m */, 93BA29AB1D83F9B0008674E7 /* libsqlite3.tbd */, 93BA29A91D83F98B008674E7 /* Foundation.framework */, 93BA29631D83F149008674E7 /* libz.tbd */, - 93BA29661D83F84D008674E7 /* GTFSImporter */, + 93BA29AD1D84C3D5008674E7 /* GTFSImporter */, 93BA290E1D83EDFC008674E7 /* GTFSImporteriOS */, 93BA290D1D83EDFC008674E7 /* Products */, ); @@ -283,86 +279,6 @@ path = minizip; sourceTree = ""; }; - 93BA29661D83F84D008674E7 /* GTFSImporter */ = { - isa = PBXGroup; - children = ( - 93BA29671D83F84D008674E7 /* CSVImporter.h */, - 93BA29681D83F84D008674E7 /* CSVImporter.m */, - 93BA29691D83F84D008674E7 /* GTFSImporter-Prefix.pch */, - 93BA296A1D83F84D008674E7 /* GTFSImporter.1 */, - 93BA296B1D83F84D008674E7 /* Libraries */, - 93BA297A1D83F84D008674E7 /* main.m */, - 93BA297B1D83F84D008674E7 /* Model */, - 93BA29921D83F84D008674E7 /* Util.h */, - 93BA29931D83F84D008674E7 /* Util.m */, - ); - path = GTFSImporter; - sourceTree = ""; - }; - 93BA296B1D83F84D008674E7 /* Libraries */ = { - isa = PBXGroup; - children = ( - 93BA296C1D83F84D008674E7 /* CSVParser */, - 93BA296F1D83F84D008674E7 /* SQLite */, - ); - path = Libraries; - sourceTree = ""; - }; - 93BA296C1D83F84D008674E7 /* CSVParser */ = { - isa = PBXGroup; - children = ( - 93BA296D1D83F84D008674E7 /* CSVParser.h */, - 93BA296E1D83F84D008674E7 /* CSVParser.m */, - ); - path = CSVParser; - sourceTree = ""; - }; - 93BA296F1D83F84D008674E7 /* SQLite */ = { - isa = PBXGroup; - children = ( - 93BA29701D83F84D008674E7 /* FMDatabase.h */, - 93BA29711D83F84D008674E7 /* FMDatabase.m */, - 93BA29721D83F84D008674E7 /* FMDatabaseAdditions.h */, - 93BA29731D83F84D008674E7 /* FMDatabaseAdditions.m */, - 93BA29741D83F84D008674E7 /* FMDatabasePool.h */, - 93BA29751D83F84D008674E7 /* FMDatabasePool.m */, - 93BA29761D83F84D008674E7 /* FMDatabaseQueue.h */, - 93BA29771D83F84D008674E7 /* FMDatabaseQueue.m */, - 93BA29781D83F84D008674E7 /* FMResultSet.h */, - 93BA29791D83F84D008674E7 /* FMResultSet.m */, - ); - path = SQLite; - sourceTree = ""; - }; - 93BA297B1D83F84D008674E7 /* Model */ = { - isa = PBXGroup; - children = ( - 93BA297C1D83F84D008674E7 /* Agency.h */, - 93BA297D1D83F84D008674E7 /* Agency.m */, - 93BA297E1D83F84D008674E7 /* Calendar.h */, - 93BA297F1D83F84D008674E7 /* Calendar.m */, - 93BA29801D83F84D008674E7 /* CalendarDate.h */, - 93BA29811D83F84D008674E7 /* CalendarDate.m */, - 93BA29821D83F84D008674E7 /* FareAttributes.h */, - 93BA29831D83F84D008674E7 /* FareAttributes.m */, - 93BA29841D83F84D008674E7 /* FareRules.h */, - 93BA29851D83F84D008674E7 /* FareRules.m */, - 93BA29861D83F84D008674E7 /* Route.h */, - 93BA29871D83F84D008674E7 /* Route.m */, - 93BA29881D83F84D008674E7 /* Shape.h */, - 93BA29891D83F84D008674E7 /* Shape.m */, - 93BA298A1D83F84D008674E7 /* Stop.h */, - 93BA298B1D83F84D008674E7 /* Stop.m */, - 93BA298C1D83F84D008674E7 /* StopTime.h */, - 93BA298D1D83F84D008674E7 /* StopTime.m */, - 93BA298E1D83F84D008674E7 /* Transformations.h */, - 93BA298F1D83F84D008674E7 /* Transformations.m */, - 93BA29901D83F84D008674E7 /* Trip.h */, - 93BA29911D83F84D008674E7 /* Trip.m */, - ); - path = Model; - sourceTree = ""; - }; /* End PBXGroup section */ /* Begin PBXNativeTarget section */ @@ -422,10 +338,9 @@ files = ( 93BA292A1D83EF8B008674E7 /* GTFS Caltrain Devs.zip in Resources */, 93BA291F1D83EDFC008674E7 /* LaunchScreen.storyboard in Resources */, - 93BA29951D83F84D008674E7 /* GTFSImporter.1 in Resources */, 93BA295C1D83F0B1008674E7 /* Info.plist in Resources */, 93BA291C1D83EDFC008674E7 /* Assets.xcassets in Resources */, - 93BA29271D83EF09008674E7 /* GTFSImporter in Resources */, + 93BA29AE1D84C3D5008674E7 /* GTFSImporter in Resources */, 93BA291A1D83EDFC008674E7 /* Main.storyboard in Resources */, ); runOnlyForDeploymentPostprocessing = 0; @@ -439,40 +354,40 @@ files = ( 93BA295B1D83F0B1008674E7 /* sha1.c in Sources */, 93BA295D1D83F0B1008674E7 /* ioapi.c in Sources */, - 93BA29A41D83F84D008674E7 /* Stop.m in Sources */, - 93BA29A21D83F84D008674E7 /* Route.m in Sources */, 93BA29621D83F0B1008674E7 /* SSZipArchive.m in Sources */, - 93BA29971D83F84D008674E7 /* FMDatabase.m in Sources */, 93BA29591D83F0B1008674E7 /* prng.c in Sources */, - 93BA29991D83F84D008674E7 /* FMDatabasePool.m in Sources */, - 93BA29A71D83F84D008674E7 /* Trip.m in Sources */, - 93BA299B1D83F84D008674E7 /* FMResultSet.m in Sources */, - 93BA29981D83F84D008674E7 /* FMDatabaseAdditions.m in Sources */, 93BA295A1D83F0B1008674E7 /* pwd2key.c in Sources */, - 93BA299E1D83F84D008674E7 /* Calendar.m in Sources */, - 93BA29961D83F84D008674E7 /* CSVParser.m in Sources */, 93BA295E1D83F0B1008674E7 /* mztools.c in Sources */, 93BA29571D83F0B1008674E7 /* fileenc.c in Sources */, 93BA295F1D83F0B1008674E7 /* unzip.c in Sources */, - 93BA299A1D83F84D008674E7 /* FMDatabaseQueue.m in Sources */, 93BA29171D83EDFC008674E7 /* ViewController.m in Sources */, 93BA29551D83F0B1008674E7 /* aestab.c in Sources */, - 93BA29A31D83F84D008674E7 /* Shape.m in Sources */, 93BA29601D83F0B1008674E7 /* zip.c in Sources */, - 93BA29A01D83F84D008674E7 /* FareAttributes.m in Sources */, 93BA29141D83EDFC008674E7 /* AppDelegate.m in Sources */, - 93BA29A51D83F84D008674E7 /* StopTime.m in Sources */, - 93BA29941D83F84D008674E7 /* CSVImporter.m in Sources */, - 93BA29A81D83F84D008674E7 /* Util.m in Sources */, - 93BA299F1D83F84D008674E7 /* CalendarDate.m in Sources */, - 93BA29A11D83F84D008674E7 /* FareRules.m in Sources */, 93BA29531D83F0B1008674E7 /* aescrypt.c in Sources */, 93BA29111D83EDFC008674E7 /* main.m in Sources */, - 93BA29A61D83F84D008674E7 /* Transformations.m in Sources */, 93BA29581D83F0B1008674E7 /* hmac.c in Sources */, 93BA29541D83F0B1008674E7 /* aeskey.c in Sources */, - 93BA299D1D83F84D008674E7 /* Agency.m in Sources */, 93BA29561D83F0B1008674E7 /* entropy.c in Sources */, + 93BA29B11D84C505008674E7 /* CSVImporter.m in Sources */, + 93BA29B21D84C505008674E7 /* Util.m in Sources */, + 93BA29BE1D84C53D008674E7 /* Agency.m in Sources */, + 93BA29BF1D84C53D008674E7 /* Calendar.m in Sources */, + 93BA29C01D84C53D008674E7 /* CalendarDate.m in Sources */, + 93BA29C11D84C53D008674E7 /* FareAttributes.m in Sources */, + 93BA29C21D84C53D008674E7 /* FareRules.m in Sources */, + 93BA29C31D84C53D008674E7 /* Route.m in Sources */, + 93BA29C41D84C53D008674E7 /* Shape.m in Sources */, + 93BA29C51D84C53D008674E7 /* Stop.m in Sources */, + 93BA29C61D84C53D008674E7 /* StopTime.m in Sources */, + 93BA29C71D84C53D008674E7 /* Transformations.m in Sources */, + 93BA29C81D84C53D008674E7 /* Trip.m in Sources */, + 93BA29CF1D84C560008674E7 /* CSVParser.m in Sources */, + 93BA29D01D84C560008674E7 /* FMDatabase.m in Sources */, + 93BA29D11D84C560008674E7 /* FMDatabaseAdditions.m in Sources */, + 93BA29D21D84C560008674E7 /* FMDatabasePool.m in Sources */, + 93BA29D31D84C560008674E7 /* FMDatabaseQueue.m in Sources */, + 93BA29D41D84C560008674E7 /* FMResultSet.m in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; @@ -590,6 +505,7 @@ LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks"; PRODUCT_BUNDLE_IDENTIFIER = com.sample.GTFSImporteriOS; PRODUCT_NAME = "$(TARGET_NAME)"; + USER_HEADER_SEARCH_PATHS = "\"$(PROJECT_DIR)/../../GTFSImporter\"/**"; }; name = Debug; }; @@ -601,6 +517,7 @@ LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks"; PRODUCT_BUNDLE_IDENTIFIER = com.sample.GTFSImporteriOS; PRODUCT_NAME = "$(TARGET_NAME)"; + USER_HEADER_SEARCH_PATHS = "\"$(PROJECT_DIR)/../../GTFSImporter\"/**"; }; name = Release; }; diff --git a/GTFSImporter/main.m b/main.m similarity index 100% rename from GTFSImporter/main.m rename to main.m From a6db9416effbd379673cdd091a7e438d3f7b525b Mon Sep 17 00:00:00 2001 From: Aaron Jubbal Date: Tue, 22 Nov 2016 01:07:56 -0800 Subject: [PATCH 3/3] iOS project automatically imports zipped GTFS archives found in main project bundle upon app launch. --- .../GTFSImporteriOS.xcodeproj/project.pbxproj | 5 ++++ .../GTFSImporteriOS/AppDelegate.m | 25 ++++++++++++------ .../capitol_corridor_google_transit.zip | Bin 0 -> 11581 bytes 3 files changed, 22 insertions(+), 8 deletions(-) create mode 100644 iOS/GTFSImporteriOS/GTFSImporteriOS/Resources/capitol_corridor_google_transit.zip diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS.xcodeproj/project.pbxproj b/iOS/GTFSImporteriOS/GTFSImporteriOS.xcodeproj/project.pbxproj index 3ec5580..a8057fb 100644 --- a/iOS/GTFSImporteriOS/GTFSImporteriOS.xcodeproj/project.pbxproj +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS.xcodeproj/project.pbxproj @@ -7,6 +7,7 @@ objects = { /* Begin PBXBuildFile section */ + 933DB41A1DE43E24001182F7 /* capitol_corridor_google_transit.zip in Resources */ = {isa = PBXBuildFile; fileRef = 933DB4171DE43E24001182F7 /* capitol_corridor_google_transit.zip */; }; 93BA29111D83EDFC008674E7 /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29101D83EDFC008674E7 /* main.m */; }; 93BA29141D83EDFC008674E7 /* AppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29131D83EDFC008674E7 /* AppDelegate.m */; }; 93BA29171D83EDFC008674E7 /* ViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = 93BA29161D83EDFC008674E7 /* ViewController.m */; }; @@ -55,6 +56,7 @@ /* End PBXBuildFile section */ /* Begin PBXFileReference section */ + 933DB4171DE43E24001182F7 /* capitol_corridor_google_transit.zip */ = {isa = PBXFileReference; lastKnownFileType = archive.zip; path = capitol_corridor_google_transit.zip; sourceTree = ""; }; 93BA290C1D83EDFC008674E7 /* GTFSImporteriOS.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = GTFSImporteriOS.app; sourceTree = BUILT_PRODUCTS_DIR; }; 93BA29101D83EDFC008674E7 /* main.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = ""; }; 93BA29121D83EDFC008674E7 /* AppDelegate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AppDelegate.h; sourceTree = ""; }; @@ -208,6 +210,7 @@ 93BA29281D83EF8B008674E7 /* Resources */ = { isa = PBXGroup; children = ( + 933DB4171DE43E24001182F7 /* capitol_corridor_google_transit.zip */, 93BA29291D83EF8B008674E7 /* GTFS Caltrain Devs.zip */, ); path = Resources; @@ -341,6 +344,7 @@ 93BA295C1D83F0B1008674E7 /* Info.plist in Resources */, 93BA291C1D83EDFC008674E7 /* Assets.xcassets in Resources */, 93BA29AE1D84C3D5008674E7 /* GTFSImporter in Resources */, + 933DB41A1DE43E24001182F7 /* capitol_corridor_google_transit.zip in Resources */, 93BA291A1D83EDFC008674E7 /* Main.storyboard in Resources */, ); runOnlyForDeploymentPostprocessing = 0; @@ -540,6 +544,7 @@ 93BA29251D83EDFC008674E7 /* Release */, ); defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; }; /* End XCConfigurationList section */ }; diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/AppDelegate.m b/iOS/GTFSImporteriOS/GTFSImporteriOS/AppDelegate.m index a599e31..1ca6abf 100644 --- a/iOS/GTFSImporteriOS/GTFSImporteriOS/AppDelegate.m +++ b/iOS/GTFSImporteriOS/GTFSImporteriOS/AppDelegate.m @@ -17,9 +17,8 @@ @interface AppDelegate () @implementation AppDelegate -- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions { - // Override point for customization after application launch. - NSString *sourcePath = [[NSBundle mainBundle] pathForResource:@"GTFS Caltrain Devs" ofType:@"zip"]; +- (void)importGFTSDataAtPath:(NSString *)path { + NSString *libraryDirectory = [NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask, YES) firstObject]; NSError *error = nil; NSString *destinationPath = libraryDirectory; @@ -28,11 +27,12 @@ - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:( if (error) { NSLog(@"error occured while creating directory! %@", error); } - [SSZipArchive unzipFileAtPath:sourcePath toDestination:destinationPath]; - - NSString *gtfsSourcePath = [destinationPath stringByAppendingPathComponent:@"GTFS Caltrain Devs"]; + [SSZipArchive unzipFileAtPath:path toDestination:destinationPath]; + NSArray *lastPathComponents = [[path lastPathComponent] componentsSeparatedByString:@"."]; + NSString *filename = [lastPathComponents firstObject]; + NSString *gtfsSourcePath = [destinationPath stringByAppendingPathComponent:filename]; [Util setTransitFilesBasepath:gtfsSourcePath]; - [Util setDatabasePath:[gtfsSourcePath stringByAppendingPathComponent:@"gtfs.db"]]; + [Util setDatabasePath:[destinationPath stringByAppendingPathComponent:[NSString stringWithFormat:@"%@.db", filename]]]; // IMPORT CSVImporter *importer = [[CSVImporter alloc] init]; @@ -103,7 +103,16 @@ - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:( NSLog(@"Import complete!"); - NSLog(@"database written to: %@", gtfsSourcePath); + NSLog(@"database written to: %@", destinationPath); +} + +- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions { + // Override point for customization after application launch. + + NSArray *filePaths = [NSBundle pathsForResourcesOfType:@"zip" inDirectory:[[NSBundle mainBundle] bundlePath]]; + for (NSString *path in filePaths) { + [self importGFTSDataAtPath:path]; + } return YES; } diff --git a/iOS/GTFSImporteriOS/GTFSImporteriOS/Resources/capitol_corridor_google_transit.zip b/iOS/GTFSImporteriOS/GTFSImporteriOS/Resources/capitol_corridor_google_transit.zip new file mode 100644 index 0000000000000000000000000000000000000000..94a4c9d929077a0f9c61c1d19c0e752cc8ff85b1 GIT binary patch literal 11581 zcmd^lbzD^2_cq-i(hUaP3>{LUfHV?H4c$Wxoil()stgT+NJ|JP9nv8n2-2W*ONf9- zy)$}$_YU5Bzv}z%o%x*Eb0*e0&)Uygd!M}@ja%p#cqoVmAFG?N*hFrg5mn43D= zf}I>p%$;0aZ7rN!O{|@qtQ{;(z^-v;)iiypiio_I0NdE0gMxS#_; zzZgN=z7RR%inb`JvQx%)p?vpiH8Ik4UUbPsm9NQKh*K&=@mGCl11YF&fB|S(LhbQO zCAdVAy)@8kBkms0F5JrVuOd0%f5VjdA5)uqki2DZWT(XUF(vvw50m0Mm!y2D(OiZx? zpU|9eg>Y}?WbXo|1}33q0)jcF!?>r%(ClNphPK$)r@h&OvG2^DSY$RrAdt+8f;)B* zE_P3oD|`b2eAMhzLLWigZfFL8o>jakEQ4i2YC=nL3L;;WglFXxlw=jcl1m`rg~^4< zp~;V61pxW>v|&@@l)TSUYQXIHC(fV-0<^j+}=fp8Ro7}NiPu7H+&u`X1f>6ERX>2dTgAuo5gqW zP*G5H;KyHCz+q;8E~mJDAq&h+9V|f>rmo0&Fu*$hEx&wU`3Ab!Y2LANwez!zfI`(k z0mjN^IZ!nvTRZ+F&GeL5Y^$|6i#Q4hwXH%j(=*Ys?3XybY<=k3%;5^mJM7`i1>yzX z?7(|yyn5AXAebShwm_WQ^LPmmnTO(BcHdBGoRYFQz`0!T2f@En z>PJ)}zelP61@ON?s`;AM=bo4g#?rB|1|PV!C8uwBzv{FNTUp7e0x9r2sK=)xNQ8|e z1pTt`cT#;cI!`Kr-yoHVg(=w54VhYRn7&hsQ;nOWM@22VU*)Zm5|`4jQn8{MH(Pga zezghU0(Mq4}=@fNw(*KxYs9cgh5T z&Qs=BMq^he_aCT&a_u`+EMuDST4V^WZ$Zz9C3z_%ePDYF?ZJ#1gVO^%B}&~^@uv+s zoHz_vRt#4G9K-plZ%x(daubI{ID+#lqD1b>P;3UeWs^|Y4}Hne+4Wg$*cD}g5g6ar zCUZZtaBGWW}Sv=Ey>2xh?DY!BOV%B#%g%y!H#8F>Pp1_H?dyb4h#^E;y!+#ISe}jah(xO`L z{JWI`d`ZL34l%V$=)~h@csCjT7z_a*0nTrgKotKi``<}e=YF1qJik!4+`vxGCSY5~ z^EKPJruLN3cM>Wrqkg(@7zD^)Ha&RE{<_D*0X5dKDVYlDk1b~$!G+oNVVSJk zsGVi9SQB9UX!GNF`mT0QXW^J(XUGvBl0x(}zhiQud}t&BmRM(>?ZmD90J zN7{Kij627zky}nLfyHQxhf8(5paV=dQnvo*uTCb5(f9K@0_oGAzw+|7#~(3zA{lr# ze4)w?sMpmm9dOcG%%xBEdUsgQPZYO(c~&AUCC(4K!q)Snq&4pc>3 z6uX^!>ozF0@dE|3K7&2aU=~|5YGH(kqH|M`FU?i`4v+luU<~Y{+ALWpL7g0LGiqcD zQ}b6Z=|}H9E;q|6_)LalV3V&pvXT@bE;XB}SvIvqD{kh=WvK`fI*qG}no#tJ&uq%h zP1(|dilsz_D*~9fMEc-8xKS0nV2t%H)@K_`&8P}KQp%;%@X#4RSz9Y@STeoshz*7q z3x`azd2g44?szi$`tLhaQTgvb6py-w%~gxjzP@{^(W|{=;)dlk zA|UBJC@37fqvwPb>2J*!z%3vu)NUK`nW$b`M<#V@A^74mWm-a zg@ijOHG-yJ&z|4rIEDIoR-~x_yVU88i%jXlFd`1TwjnDmye)IU>J#c$Ze7{Ixt9eG zRg~vd%lk-JU_@iL3;HZL@m7i;t@w>m^WnbR##rHPSN;%q30PHw{rodV(~Q_8w4u4c&;s`3tMWFnYWtgWdV?6MFfBVd#Z)ihYfgZk}R`Jdou5jH(k4fDc#QD>USp zx>w8MsQ@}`8|wlM09UEUfMxJz}vaM0HQ>3?h zMd$D1iI=oeaC~|)k6Ji!Wu^LF2naj{dQcTt*H56rVQv^(G(%c{(vovOrPfVO zaQtU)#3z@0*=u22_`-{%e0xy1&$sFz?cDYkz@XzU7>fTKnb7Ho}49D)iyO% zriZQwc&h&PQ8%?&+iTJJhh4@c4{r73F7FV00UD>3a^rLq#8_IExZdPbhE4qgfVB1=r0SEL1=F?jZap|z7m?|YCT`3=bkUv%#t%}mHU!dneyNf0g$FA={ z>*g;au$3^{ADBihNK5>n~Bgg0{aWhkJk+t_UAIGMBBtRMa= zDo=9SOI~y%&v}VMt%;{c@O^j;;hr_9r(SbxK+q|DvW-5l7CRNsL!#1wL*H>CSQV4C zt9cSUgOyqd)NZyLqHy34%^KMjc6^XRM){GNDitqrs|mm-Oz+p4dWBDzyu?fa=pZgy z%Lf09{5@0h(k339n{}KxBUi64*<1<+s96N+5vK*67@5vUY~md_>k)5|^p+O@8#t$0 zjb!;3*0%79)5pQ|5iL3{IK7!{^~9B-Q<-dr%;8OR5y4>_jzkKxgjR7t`Uoh#ZlzZh z|C_O4NzZr!wJre?s;Xhwb>Nh)`hI(LvY+rHAiEc6K|peieV> zbP~j!)~(=@6>xgwo>B#|JaD>0vb9gFI=TiVfi^GPOg~mvOjrzFfNp}8po>TQ1W}Vz zdNXU&9r`qZ06vg;+C%GDPXmd9hUiHQd4cJ=;$0_mZX zqF~9~Ndwx>&Y2`AGE9yPwgxV6h@#ffs5#%G_9x5})Pj#0yozF^wN*?jZDX2J7Q_;8?*;K}^^yzh)Kh?sUVMwHhmsP3wGw9xoEHELotbUU~S5L4SQ;!y(?td_gmfW4a(`xvWp?s25mcG4nLg25Y?mQ^X zdY*#@iy5lERnWq>t%;&(|M1mAk_UPSPRW?22U3XyH7X2jF&bB>vn4xtwz0pp5dX7Mm)y+Wr z9^6Tz=z~iAT70&Tzb*%> zG&4LY*&aa8SR|$o>xikSYs!sqjjwCUnzFidwR9yeyl?`Op#c!d6zd}J_{f#Kt|i#h z3iY}<9qatMAyGzDd|f!x?M%l76iS5Dc>b=b3%(e6YmEYr{&umG?2*+@7w2{^mk`o&^YpaC*V0 z;_>}~FA*-miYcB6Dukw+d0tMAtn<{gw4fY}3+aVoLqIROdY3>aA7Ri%g z*8XZHCSagYEB-Mz>QNz0dRZ|^y};@81J13EsHCjHv}PJXt@q9-FAq`es;CM_m$38u zW}=Gk%#*t9v=q&7XnRR2H<&DU<~0IG)>!-1)!q8Gy(#*|Kv%a#2ShrfF&OA2JEIk? zWDPwX$SnjwZ~5`&au><G(d#6* zR-bff9&tWihc}a)nHd+1ib8k{Z)GvuxtXhJe^xJ|D7(E3?#Ds+p1`=>xZR zFk{U=Yx#u>I=5rLp^3QKO!z{fQH8`1;-7g{|JC6;4Gvrnc}C963v^c3bmjC2nh&8$ z*7yUgxI9a%DDEy_to0&>+h-Y#**#3&MMqkSqr~FyG-mX!Qc-?TzgA643E*jJZXbPt z`8jzU?Q5?Cs=rlb&^3U84E!Uo)W0`^K4TJz~M{otn`R zF?cfO&a9ds79+LN@|^1m)kh2y;TT=PS#@o2s`KcK2nfdD-^oik#Zqs!cDY*BtGN!l z3b&t%dIvOg5%sfg!(_=#j1`~jL4RxV$xl^SKj2+-##Drb@s>)CdWh6NrPo|GOw~PV z0Zd#hbPnb6!jSdt^IZ{O=k3C3?8%-I5{gcB4?zWR!%ym;R;<*jG!BJNRa%oUt$QarCikK=%n>dUy#YoP=lL$)1#&@%9% zC{#wkd_ePJv6Tv7OqGpFWE93_KgC6g*LC#-{+)RU3L|sGiKp*arN-nWqbj|A`T3aemvE8eHnjX z1+;1PloX}&+Cgpd3Pw|j*EDls`wBgaC*To7z|Di_b*bU|E2aSH8HGG4pH!n{O1js~ z@07uxdL}nGr2JmK_05mZ4!b}rV!~;(zr9);ramg=SGzeoB7!@u*p9Q9M#tN-2GzGa0Hx#c1|P}&5vNDTD^p)DOhmjr*kgQI(f^>N z?CeRg|7qQvMvr2~84>5v-Fszmd;q@j_%b?dMB~z7!eE#Dv8bTFeErQTYOr#*wH~!> z6R|AYM@tM;d5p}Li5D@hLNz9~Sk(kwrBeC%T;r+Hy)MP=ABkgGmoE57U6&b^#{mCR zbB2vr3mTUXv%Er#f>H=yi~nnF{>SAAvEN&m{NF1R|B3aWgps0yJMW!ML*Gu4KEQk3 zDjkShCSBrI%O>u#T5O<6(5Yil{%t)dCMQtl@9RMlZjR?RM-UrcKilU*ME%_I_1whb zx1Evr_z$2|KC1RD&OQ2LlzUVJR9if%qs6Nks!DeY>Iw{g8^6+fJ5VfFL@*r=4-NF-$2P)D& zRIc-aa%|;ORGA@znp3q08%>ErH*MP9D>w$Ki(ZV$pC?vPOpBRYC{~xQ3bVI)Nx9ef zsU%6mzB%%^wTYO{&N=So%)m`e;sKXwErT9+>v79!gA?ct6``kdfnUwKuA?f1+_efC zBFob39lWzw>?Rd_w*aZ-F!@+>Bq0KG9vAH@%907oN<6_FFHC^Bopq_u>L)Vm2qc2r5^DrG|wu;$06NjS{xm-bh(aB;W0Nb}uy z%SZZr9mN=4q@9YUt(qIJXOe6g4nGx3vydP<<4wATKS5O5>`c=BWvF>yDqCG>wBT+T zUhm#$0dG@|O`nQL|H?_;KkoULqW;KK`v`QW|iRY zm$iRPu>V9wyS>bMvb@&so!)A6th*lAH;=0@Exh;O*3+!S_qF8h&b@b8h`&`d^!E4b zf3Ik7UCys?|4KyzyV{dLHjIH@alt%h^U&jik!1+KUh&@O`*O5vuhO%T(aOXk9T0MQ;KI;)w0h82XNvb+ zlfd-z37uAN&U#@9sd|;%C^OlE62|Gbonqmi3=5e?&B|`UD2Hpb&|$GMxnz9ogzdqT zjD~a(JoGIKiSw4Vs4R{_8@3Ro3g@*Nx0A+dbr;1QGt@h14M9af$Dwj87H(6a;vgma zCox>KY@mch%cw+Lbc+_W>6`IQ?>NT3pz9F!qLJitvtz0#x9Uz}C1DagbmZnMpcrXP zECD*2d$uglT6fWgrGy01$}6D41Y~l#;NRxoX1FU)#BE0+9Fw#>^3W~vF1kt|N)0nU zm_yz4M$V@d%Rms?`&&$;cuCi2gk#b>-#j!AOF=C!#$*|8xiKl}eJ`V)5s@&>ekF}+ z@cnsKEaZgwvD1DtVg9xM{u>Fyc-Gy`t+qK@V*+R}ALJkn*g9l^iI6GW0jF@e5 zq4xcjFo&TO`hQQDA2mmaeaSziGCU?fnGO7?KKgG&TwR0?=c4XD?}bg1_94HSrcfQU zNj<*mo8KdD+G)F*^)2Ek-n@H%MI0549R1&PUIg$x(r*u$CRs%Lld!`zOgMk4zBFzj zEdM1nLY72vp!{X|BSh^NEF-IpaQ;+)efROtDk)qfA1AU(@a+DRKZwixKTXvCGQob% zL=duxUx~zd7k@<(({^}?_Ln1 zBjoNy$bOI&DI!Q-vLPH8NTL5(+z_dataAEihY0BivZzD=$>B#x0p_p6LROD__l1zX zAcI5rLe@@5A^FON=)p&fKY8`*;C}8FAxJ=$Dx6Q5DeRv^MAjsHhlY@8AVWj=K;Dr* zPsRoK?D03C{oEbmz8d+Cn+GY9A0ejjH2zrtf4sH+4hymAj|>ap2l>WQ49QP6WSi!< zVEvj)#M~Nr){R^_K0;jRehu0m)9df35cjXhs1PoYCzpcfP<1l?Hmd*W4KepYo)w)3 zB!B7WfRLs?-vJ?}ugHK9E|3TR^MJlw{w+X1_4aK-fi&