transmission/macosx/BlocklistDownloader.mm

406 lines
11 KiB
Plaintext
Raw Normal View History

// This file Copyright © Transmission authors and contributors.
// It may be used under the MIT (SPDX: MIT) license.
// License text can be found in the licenses/ folder.
2008-03-29 23:38:38 +00:00
#import "BlocklistDownloader.h"
#import "BlocklistDownloaderViewController.h"
#import "BlocklistScheduler.h"
#import "Controller.h"
2008-03-29 23:38:38 +00:00
@interface BlocklistDownloader ()
2008-03-29 23:38:38 +00:00
@property(nonatomic) NSURLSession* fSession;
@property(nonatomic) NSUInteger fCurrentSize;
@property(nonatomic) long long fExpectedSize;
@property(nonatomic) BlocklistDownloadState fState;
2008-03-29 23:38:38 +00:00
@end
@implementation BlocklistDownloader
BlocklistDownloader* fBLDownloader = nil;
+ (BlocklistDownloader*)downloader
2008-03-29 23:38:38 +00:00
{
if (!fBLDownloader)
{
fBLDownloader = [[BlocklistDownloader alloc] init];
[fBLDownloader startDownload];
}
return fBLDownloader;
2008-03-29 23:38:38 +00:00
}
+ (BOOL)isRunning
{
return fBLDownloader != nil;
}
- (void)setViewController:(BlocklistDownloaderViewController*)viewController
{
_viewController = viewController;
if (_viewController)
{
switch (self.fState)
{
case BlocklistDownloadStateStart:
[_viewController setStatusStarting];
break;
case BlocklistDownloadStateDownloading:
[_viewController setStatusProgressForCurrentSize:self.fCurrentSize expectedSize:self.fExpectedSize];
break;
case BlocklistDownloadStateProcessing:
[_viewController setStatusProcessing];
break;
}
}
}
- (void)cancelDownload
2008-03-29 23:38:38 +00:00
{
[_viewController setFinished];
[self.fSession invalidateAndCancel];
[BlocklistScheduler.scheduler updateSchedule];
fBLDownloader = nil;
2008-03-29 23:38:38 +00:00
}
- (void)URLSession:(NSURLSession*)session
downloadTask:(NSURLSessionDownloadTask*)downloadTask
didWriteData:(int64_t)bytesWritten
totalBytesWritten:(int64_t)totalBytesWritten
totalBytesExpectedToWrite:(int64_t)totalBytesExpectedToWrite
2008-03-29 23:38:38 +00:00
{
dispatch_async(dispatch_get_main_queue(), ^{
self.fState = BlocklistDownloadStateDownloading;
self.fCurrentSize = totalBytesWritten;
self.fExpectedSize = totalBytesExpectedToWrite;
[self.viewController setStatusProgressForCurrentSize:self.fCurrentSize expectedSize:self.fExpectedSize];
});
2008-03-29 23:38:38 +00:00
}
- (void)URLSession:(NSURLSession*)session task:(NSURLSessionTask*)task didCompleteWithError:(NSError*)error
2008-03-29 23:38:38 +00:00
{
dispatch_async(dispatch_get_main_queue(), ^{
if (error)
{
[self.viewController setFailed:error.localizedDescription];
}
[NSUserDefaults.standardUserDefaults setObject:[NSDate date] forKey:@"BlocklistNewLastUpdate"];
[BlocklistScheduler.scheduler updateSchedule];
[self.fSession finishTasksAndInvalidate];
fBLDownloader = nil;
});
2008-03-29 23:38:38 +00:00
}
- (void)URLSession:(NSURLSession*)session
downloadTask:(NSURLSessionDownloadTask*)downloadTask
didFinishDownloadingToURL:(NSURL*)location
2008-03-29 23:38:38 +00:00
{
self.fState = BlocklistDownloadStateProcessing;
dispatch_async(dispatch_get_main_queue(), ^{
[self.viewController setStatusProcessing];
});
NSString* filename = downloadTask.response.suggestedFilename;
if (filename == nil)
{
filename = @"transmission-blocklist.tmp";
}
NSString* tempFile = [NSTemporaryDirectory() stringByAppendingPathComponent:filename];
NSString* blocklistFile = [NSTemporaryDirectory() stringByAppendingPathComponent:@"transmission-blocklist"];
[NSFileManager.defaultManager moveItemAtPath:location.path toPath:tempFile error:nil];
if ([@"text/plain" isEqualToString:downloadTask.response.MIMEType])
{
blocklistFile = tempFile;
}
else
{
[self decompressFrom:[NSURL fileURLWithPath:tempFile] to:[NSURL fileURLWithPath:blocklistFile] error:nil];
[NSFileManager.defaultManager removeItemAtPath:tempFile error:nil];
}
dispatch_async(dispatch_get_main_queue(), ^{
auto const count = tr_blocklistSetContent(((Controller*)NSApp.delegate).sessionHandle, blocklistFile.UTF8String);
//delete downloaded file
[NSFileManager.defaultManager removeItemAtPath:blocklistFile error:nil];
if (count > 0)
{
[self.viewController setFinished];
}
else
{
[self.viewController
setFailed:NSLocalizedString(@"The specified blocklist file did not contain any valid rules.", "blocklist fail message")];
}
//update last updated date for schedule
NSDate* date = [NSDate date];
[NSUserDefaults.standardUserDefaults setObject:date forKey:@"BlocklistNewLastUpdate"];
[NSUserDefaults.standardUserDefaults setObject:date forKey:@"BlocklistNewLastUpdateSuccess"];
[BlocklistScheduler.scheduler updateSchedule];
[NSNotificationCenter.defaultCenter postNotificationName:@"BlocklistUpdated" object:nil];
[self.fSession finishTasksAndInvalidate];
fBLDownloader = nil;
});
2008-03-29 23:38:38 +00:00
}
#pragma mark - Private
- (void)startDownload
2008-03-29 23:38:38 +00:00
{
self.fState = BlocklistDownloadStateStart;
self.fSession = [NSURLSession sessionWithConfiguration:NSURLSessionConfiguration.ephemeralSessionConfiguration delegate:self
delegateQueue:nil];
[BlocklistScheduler.scheduler cancelSchedule];
NSString* urlString = [NSUserDefaults.standardUserDefaults stringForKey:@"BlocklistURL"];
if (!urlString)
{
urlString = @"";
}
else
{
urlString = [urlString stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]];
if (![urlString isEqualToString:@""] && [urlString rangeOfString:@"://"].location == NSNotFound)
{
urlString = [@"https://" stringByAppendingString:urlString];
}
}
NSURLSessionDownloadTask* task = [self.fSession downloadTaskWithURL:[NSURL URLWithString:urlString]];
[task resume];
2008-03-29 23:38:38 +00:00
}
2022-04-29 22:51:40 +00:00
- (BOOL)decompressFrom:(NSURL*)file to:(NSURL*)destination error:(NSError**)error
{
if ([self untarFrom:file to:destination])
{
2022-04-29 22:51:40 +00:00
return YES;
}
if ([self unzipFrom:file to:destination])
{
2022-04-29 22:51:40 +00:00
return YES;
}
if ([self gunzipFrom:file to:destination])
{
2022-04-29 22:51:40 +00:00
return YES;
}
// If it doesn't look like archive just copy it to destination
else
{
2022-04-29 22:51:40 +00:00
return [NSFileManager.defaultManager copyItemAtURL:file toURL:destination error:error];
}
}
- (BOOL)untarFrom:(NSURL*)file to:(NSURL*)destination
{
// We need to check validity of archive before listing or unpacking.
NSTask* tarListCheck = [[NSTask alloc] init];
tarListCheck.launchPath = @"/usr/bin/tar";
tarListCheck.arguments = @[ @"--list", @"--file", file.path ];
tarListCheck.standardOutput = nil;
tarListCheck.standardError = nil;
@try
{
[tarListCheck launch];
[tarListCheck waitUntilExit];
if (tarListCheck.terminationStatus != 0)
{
return NO;
}
}
@catch (NSException* exception)
{
return NO;
}
NSTask* tarList = [[NSTask alloc] init];
tarList.launchPath = @"/usr/bin/tar";
tarList.arguments = @[ @"--list", @"--file", file.path ];
NSPipe* pipe = [[NSPipe alloc] init];
tarList.standardOutput = pipe;
tarList.standardError = nil;
NSString* filename;
@try
{
[tarList launch];
[tarList waitUntilExit];
if (tarList.terminationStatus != 0)
{
return NO;
}
NSData* data = [pipe.fileHandleForReading readDataToEndOfFile];
NSString* output = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
filename = [output componentsSeparatedByCharactersInSet:NSCharacterSet.newlineCharacterSet].firstObject;
}
@catch (NSException* exception)
{
return NO;
}
// It's a directory, skip
if ([filename hasSuffix:@"/"])
{
return NO;
}
NSURL* destinationDir = destination.URLByDeletingLastPathComponent;
NSTask* untar = [[NSTask alloc] init];
untar.launchPath = @"/usr/bin/tar";
untar.currentDirectoryPath = destinationDir.path;
untar.arguments = @[ @"--extract", @"--file", file.path, filename ];
@try
{
[untar launch];
[untar waitUntilExit];
if (untar.terminationStatus != 0)
{
return NO;
}
}
@catch (NSException* exception)
{
return NO;
}
NSURL* result = [destinationDir URLByAppendingPathComponent:filename];
[NSFileManager.defaultManager moveItemAtURL:result toURL:destination error:nil];
return YES;
}
- (BOOL)gunzipFrom:(NSURL*)file to:(NSURL*)destination
{
NSURL* destinationDir = destination.URLByDeletingLastPathComponent;
NSTask* gunzip = [[NSTask alloc] init];
gunzip.launchPath = @"/usr/bin/gunzip";
gunzip.currentDirectoryPath = destinationDir.path;
gunzip.arguments = @[ @"--keep", @"--force", file.path ];
@try
{
[gunzip launch];
[gunzip waitUntilExit];
if (gunzip.terminationStatus != 0)
{
return NO;
}
}
@catch (NSException* exception)
{
return NO;
}
NSURL* result = file.URLByDeletingPathExtension;
[NSFileManager.defaultManager moveItemAtURL:result toURL:destination error:nil];
return YES;
}
- (BOOL)unzipFrom:(NSURL*)file to:(NSURL*)destination
{
NSTask* zipinfo = [[NSTask alloc] init];
zipinfo.launchPath = @"/usr/bin/zipinfo";
zipinfo.arguments = @[
@"-1", /* just the filename */
file.path /* source zip file */
];
NSPipe* pipe = [[NSPipe alloc] init];
zipinfo.standardOutput = pipe;
zipinfo.standardError = nil;
NSString* filename;
@try
{
[zipinfo launch];
[zipinfo waitUntilExit];
if (zipinfo.terminationStatus != 0)
{
return NO;
}
NSData* data = [pipe.fileHandleForReading readDataToEndOfFile];
NSString* output = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
filename = [output componentsSeparatedByCharactersInSet:NSCharacterSet.newlineCharacterSet].firstObject;
}
@catch (NSException* exception)
{
return NO;
}
// It's a directory, skip
if ([filename hasSuffix:@"/"])
{
return NO;
}
NSURL* destinationDir = destination.URLByDeletingLastPathComponent;
NSTask* unzip = [[NSTask alloc] init];
unzip.launchPath = @"/usr/bin/unzip";
unzip.currentDirectoryPath = destinationDir.path;
unzip.arguments = @[ file.path, filename ];
@try
{
[unzip launch];
[unzip waitUntilExit];
if (unzip.terminationStatus != 0)
{
return NO;
}
}
@catch (NSException* exception)
{
return NO;
}
NSURL* result = [destinationDir URLByAppendingPathComponent:filename];
[NSFileManager.defaultManager moveItemAtURL:result toURL:destination error:nil];
return YES;
}
2008-03-29 23:38:38 +00:00
@end