#import "KxSMBProvider.h"

#import "../sambalibs/libsmbclient.h"

#import "../sambalibs/talloc_stack.h"

NSString * const KxSMBErrorDomain = @"ru.kolyvan.KxSMB";

static NSString * KxSMBErrorMessage (KxSMBError errorCode)

{

switch (errorCode) {

case KxSMBErrorUnknown: return NSLocalizedString(@"SMB Error", nil);

case KxSMBErrorInvalidArg: return NSLocalizedString(@"SMB Invalid argument", nil);

case KxSMBErrorInvalidProtocol: return NSLocalizedString(@"SMB Invalid protocol", nil);

case KxSMBErrorOutOfMemory: return NSLocalizedString(@"SMB Out of memory", nil);

case KxSMBErrorAccessDenied: return NSLocalizedString(@"SMB Access Denied", nil);

case KxSMBErrorInvalidPath: return NSLocalizedString(@"SMB No such file or directory", nil);

case KxSMBErrorPathIsNotDir: return NSLocalizedString(@"SMB Not a directory", nil);

case KxSMBErrorPathIsDir: return NSLocalizedString(@"SMB Is a directory", nil);

case KxSMBErrorWorkgroupNotFound: return NSLocalizedString(@"SMB Workgroup not found", nil);

case KxSMBErrorShareDoesNotExist: return NSLocalizedString(@"SMB Share does not exist", nil);

case KxSMBErrorItemAlreadyExists: return NSLocalizedString(@"SMB Item already exists", nil);

case KxSMBErrorDirNotEmpty: return NSLocalizedString(@"SMB Directory not empty", nil);

case KxSMBErrorFileIO: return NSLocalizedString(@"SMB File I/O failure", nil);

case KxSMBErrorConnRefused: return NSLocalizedString(@"SMB Connection refused", nil);

case KxSMBErrorOpNotPermited: return NSLocalizedString(@"SMB Operation not permitted", nil);

}

}

static NSError * mkKxSMBError(KxSMBError error, NSString *format, ...)

{

NSDictionary *userInfo = nil;

NSString *reason = nil;

if (format) {

va_list args;

va_start(args, format);

reason = [[NSString alloc] initWithFormat:format arguments:args];

va_end(args);

}

if (reason) {

userInfo = @{

NSLocalizedDescriptionKey : KxSMBErrorMessage(error),

NSLocalizedFailureReasonErrorKey : reason

};

} else {

userInfo = @{ NSLocalizedDescriptionKey : KxSMBErrorMessage(error) };

}

return [NSError errorWithDomain:KxSMBErrorDomain

code:error

userInfo:userInfo];

}

static KxSMBError errnoToSMBErr(int err)

{

switch (err) {

case EINVAL: return KxSMBErrorInvalidArg;

case ENOMEM: return KxSMBErrorOutOfMemory;

case EACCES: return KxSMBErrorAccessDenied;

case ENOENT: return KxSMBErrorInvalidPath;

case ENOTDIR: return KxSMBErrorPathIsNotDir;

case EISDIR: return KxSMBErrorPathIsDir;

case EPERM: return KxSMBErrorOpNotPermited;

case ENODEV: return KxSMBErrorShareDoesNotExist;

case EEXIST: return KxSMBErrorItemAlreadyExists;

case ENOTEMPTY: return KxSMBErrorDirNotEmpty;

case ECONNREFUSED: return KxSMBErrorConnRefused;

default: return KxSMBErrorUnknown;

}

}

@implementation KxSMBAuth

+ (instancetype) smbAuthWorkgroup:(NSString *)workgroup

username:(NSString *)username

password:(NSString *)password

{

KxSMBAuth *auth = [[KxSMBAuth alloc] init];

auth.workgroup = workgroup;

auth.username = username;

auth.password = password;

return auth;

}

@interface KxSMBItemStat ()

@property(readwrite, nonatomic, retain) NSDate *lastModified;

@property(readwrite, nonatomic, retain) NSDate *lastAccess;

@property(readwrite, nonatomic, retain) NSDate *creationTime;

@property(readwrite, nonatomic) SInt64 size;

@property(readwrite, nonatomic) UInt16 mode;

@implementation KxSMBItemStat

@implementation KxSMBItem

- (id) initWithType:(KxSMBItemType) type

path:(NSString *) path

stat:(KxSMBItemStat *)stat

auth:(KxSMBAuth *)auth

{

self = [super init];

if (self) {

_type = type;

_path = path;

_stat = stat;

_auth = auth;

}

return self;

}

- (NSString *) description

{

NSString *stype = @"";

switch (_type) {

case KxSMBItemTypeUnknown: stype = @"?"; break;

case KxSMBItemTypeWorkgroup: stype = @"group"; break;

case KxSMBItemTypeServer: stype = @"server"; break;

case KxSMBItemTypeFileShare: stype = @"fileshare"; break;

case KxSMBItemTypePrinter: stype = @"printer"; break;

case KxSMBItemTypeComms: stype = @"comms"; break;

case KxSMBItemTypeIPC: stype = @"ipc"; break;

case KxSMBItemTypeDir: stype = @"dir"; break;

case KxSMBItemTypeFile: stype = @"file"; break;

case KxSMBItemTypeLink: stype = @"link"; break;

}

return [NSString stringWithFormat:@"<smb %@ '%@' %lld>",

stype, _path, _stat.size];

}

static void my_smbc_get_auth_data_fn(const char *srv,

const char *shr,

char *workgroup, int wglen,

char *username, int unlen,

char *password, int pwlen);

static void my_smbc_get_auth_data_with_context_fn(SMBCCTX *c,

const char *srv,

const char *shr,

char *wg, int wglen,

char *un, int unlen,

char *pw, int pwlen);

@interface KxSMBItemFile()

- (id) createFile:(BOOL)overwrite;

@implementation KxSMBConfig

- (id) init

{

if ((self = [super init])) {

_timeout = 10000; // ms

#ifdef DEBUG

_debugLevel = 1;

#else

_debugLevel = 0;

#endif

_debugToStderr = YES;

_fullTimeNames = YES;

_shareMode = KxSMBConfigShareModeDenyNone;

_encryptionLevel = KxSMBConfigEncryptLevelNone;

_caseSensitive = NO;

_browseMaxLmbCount = 3;

_urlEncodeReaddirEntries = NO;

_oneSharePerServer = NO;

_useKerberos = NO;

_fallbackAfterKerberos = YES;

_noAutoAnonymousLogin = NO;

_useCCache = NO;

_useNTHash = NO;

}

return self;

}

- (void) configureSmbContext:(SMBCCTX *)smbContext

{

smbc_setTimeout(smbContext, (int)_timeout);

smbc_setDebug(smbContext, (int)_debugLevel);

smbc_setOptionDebugToStderr(smbContext, (smbc_bool)_debugToStderr);

smbc_setOptionFullTimeNames(smbContext, (smbc_bool)_fullTimeNames);

smbc_setOptionOpenShareMode(smbContext, (smbc_share_mode)_shareMode);

smbc_setOptionSmbEncryptionLevel(smbContext, (smbc_smb_encrypt_level)_encryptionLevel);

smbc_setOptionCaseSensitive(smbContext, (smbc_bool)_caseSensitive);

smbc_setOptionBrowseMaxLmbCount(smbContext, (int)_browseMaxLmbCount);

smbc_setOptionUrlEncodeReaddirEntries(smbContext, (smbc_bool)_urlEncodeReaddirEntries);

smbc_setOptionOneSharePerServer(smbContext, (smbc_bool)_oneSharePerServer);

smbc_setOptionUseKerberos(smbContext, (smbc_bool)_useKerberos);

smbc_setOptionFallbackAfterKerberos(smbContext, (smbc_bool)_fallbackAfterKerberos);

smbc_setOptionNoAutoAnonymousLogin(smbContext, (smbc_bool)_noAutoAnonymousLogin);

smbc_setOptionUseCCache(smbContext, (smbc_bool)_useCCache);

smbc_setOptionUseNTHash(smbContext, (smbc_bool)_useNTHash);

if (_netbiosName.length) {

smbc_setNetbiosName(smbContext, (char *)_netbiosName.UTF8String);

}

if (_workgroup.length) {

smbc_setWorkgroup(smbContext, (char *)_workgroup.UTF8String);

}

if (_username.length) {

smbc_setUser(smbContext, (char *)_username.UTF8String);

}

}

static KxSMBProvider *gSmbProvider;

@interface KxSMBProvider ()

@implementation KxSMBProvider {

dispatch_queue_t _dispatchQueue;

}

+ (instancetype) sharedSmbProvider

{

static dispatch_once_t onceToken;

dispatch_once(&onceToken, ^{

gSmbProvider = [[KxSMBProvider alloc] init];

});

return gSmbProvider;

}

- (id) init

{

NSAssert(!gSmbProvider, @"singleton object");

self = [super init];

if (self) {

_config = [KxSMBConfig new];

_dispatchQueue = dispatch_queue_create("KxSMBProvider", DISPATCH_QUEUE_SERIAL);

_completionQueue = dispatch_get_main_queue();

}

return self;

}

- (void) dealloc

{

if (_dispatchQueue) {

#if __IPHONE_OS_VERSION_MIN_REQUIRED < 60000

dispatch_release(_dispatchQueue);

#endif

_dispatchQueue = NULL;

}

}

#pragma mark - class methods

+ (SMBCCTX *) openSmbContext:(KxSMBAuth *)auth

{

//NSParameterAssert(auth);

SMBCCTX *smbContext = smbc_new_context();

if (!smbContext) {

return NULL;

}

if (auth) {

smbc_setFunctionAuthDataWithContext(smbContext, my_smbc_get_auth_data_with_context_fn);

smbc_setOptionUserData(smbContext, (void *)CFBridgingRetain(auth));

} else {

smbc_setFunctionAuthData(smbContext, my_smbc_get_auth_data_fn);

}

KxSMBConfig *cfg = [KxSMBProvider sharedSmbProvider].config;

[cfg configureSmbContext:smbContext];

if (!smbc_init_context(smbContext)) {

void *userdata = smbc_getOptionUserData(smbContext);

if (userdata) {

CFBridgingRelease(userdata);

}

smbc_free_context(smbContext, NO);

return NULL;

}

smbc_set_context(smbContext);

return smbContext;

}

+ (void) closeSmbContext:(SMBCCTX *)smbContext

{

if (smbContext) {

void *userdata = smbc_getOptionUserData(smbContext);

if (userdata) {

CFBridgingRelease(userdata);

}

// fixes warning: no talloc stackframe at libsmb/cliconnect.c:2637, leaking memory

TALLOC_CTX *frame = talloc_stackframe();

smbc_getFunctionPurgeCachedServers(smbContext)(smbContext);

TALLOC_FREE(frame);

smbc_free_context(smbContext, NO);

}

}

+ (id) fetchTreeAtPath:(NSString *)path

auth:(KxSMBAuth *)auth

{

NSParameterAssert(path);

SMBCCTX *smbContext = [self openSmbContext:auth];

if (!smbContext) {

const int err = errno;

return mkKxSMBError(errnoToSMBErr(err),

NSLocalizedString(@"Unable init SMB context (errno:%d)", nil), err);

}

id result = nil;

SMBCFILE *smbFile = smbc_getFunctionOpendir(smbContext)(smbContext, path.UTF8String);

if (smbFile) {

NSMutableArray *ma = [NSMutableArray array];

struct smbc_dirent *dirent;

smbc_readdir_fn readdirFn = smbc_getFunctionReaddir(smbContext);

while((dirent = readdirFn(smbContext, smbFile)) != NULL) {

if (!strlen(dirent->name)) continue;

if (!strcmp(dirent->name, ".") || !strcmp(dirent->name, "..") || !strcmp(dirent->name, "IPC$")) continue;

NSString *name = [NSString stringWithUTF8String:dirent->name];

NSString *itemPath;

if ([path characterAtIndex:path.length-1] == '/')

itemPath = [path stringByAppendingString:name] ;

else

itemPath = [NSString stringWithFormat:@"%@/%@", path, name];

KxSMBItemStat *stat = nil;

if (dirent->smbc_type != SMBC_WORKGROUP &&

dirent->smbc_type != SMBC_SERVER) {

id r = [self fetchStat:smbContext atPath:itemPath];

if ([r isKindOfClass:[KxSMBItemStat class]]) {

stat = r;

}

}

switch(dirent->smbc_type)

{

case SMBC_WORKGROUP:

case SMBC_SERVER: {

KxSMBItem *item = [[KxSMBItemTree alloc] initWithType:dirent->smbc_type

path:[NSString stringWithFormat:@"smb://%@", name]

stat:nil

auth:auth];

[ma addObject:item];

break;

}

case SMBC_FILE_SHARE:

case SMBC_IPC_SHARE:

case SMBC_DIR: {

KxSMBItem *item = [[KxSMBItemTree alloc] initWithType:dirent->smbc_type

path:itemPath

stat:stat

auth:auth];

[ma addObject:item];

break;

}

case SMBC_FILE: {

KxSMBItem *item = [[KxSMBItemFile alloc] initWithType:KxSMBItemTypeFile

path:itemPath

stat:stat

auth:auth];

[ma addObject:item];

break;

}

case SMBC_PRINTER_SHARE:

case SMBC_COMMS_SHARE:

case SMBC_LINK: {

KxSMBItem *item = [[KxSMBItem alloc] initWithType:dirent->smbc_type

path:itemPath

stat:stat

auth:auth];

[ma addObject:item];

break;

}

}

}

smbc_getFunctionClose(smbContext)(smbContext, smbFile);

result = [ma copy];

} else {

const int err = errno;

result = mkKxSMBError(errnoToSMBErr(err),

NSLocalizedString(@"Unable open dir:%@ (errno:%d)", nil), path, err);

}

[self closeSmbContext:smbContext];

return result;

}

+ (id) fetchStat:(SMBCCTX *)smbContext

atPath:(NSString *)path

{

NSParameterAssert(smbContext);

NSParameterAssert(path);

struct stat st;

int r = smbc_getFunctionStat(smbContext)(smbContext, path.UTF8String, &st);

if (r < 0) {

const int err = errno;

return mkKxSMBError(errnoToSMBErr(err),

NSLocalizedString(@"Unable get stat:%@ (errno:%d)", nil), path, err);

}

KxSMBItemStat *stat = [[KxSMBItemStat alloc] init];

stat.lastModified = [NSDate dateWithTimeIntervalSince1970: st.st_mtime];

stat.lastAccess = [NSDate dateWithTimeIntervalSince1970: st.st_atime];

stat.creationTime = [NSDate dateWithTimeIntervalSince1970: st.st_ctime];

stat.size = st.st_size;

stat.mode = st.st_mode;

return stat;

}

+ (id) fetchAtPath:(NSString *)path

expandDir:(BOOL)expandDir

auth:(KxSMBAuth *)auth

{

NSParameterAssert(path);

if (![path hasPrefix:@"smb://"]) {

return mkKxSMBError(KxSMBErrorInvalidProtocol,

NSLocalizedString(@"Path:%@", nil), path);

}

NSString *sPath = [path substringFromIndex:@"smb://".length];

if (!sPath.length) {

return [self fetchTreeAtPath:path auth:auth];

}

if ([sPath hasSuffix:@"/"]) {

sPath = [sPath substringToIndex:sPath.length - 1];

}

if (sPath.pathComponents.count == 1) {

// smb:// or smb://server/ or smb://workgroup/

return [self fetchTreeAtPath:path auth:auth];

}

id result = nil;

SMBCCTX *smbContext = [self openSmbContext:auth];

if (!smbContext) {

const int err = errno;

return mkKxSMBError(errnoToSMBErr(err),

NSLocalizedString(@"Unable init SMB context (errno:%d)", nil), err);

}

result = [self fetchStat:smbContext atPath:path];

if ([result isKindOfClass:[KxSMBItemStat class]]) {

KxSMBItemStat *stat = result;

if (S_ISDIR(stat.mode)) {

if (expandDir) {

result = [self fetchTreeAtPath:path auth:auth];

} else {

result = [[KxSMBItemTree alloc] initWithType:KxSMBItemTypeDir

path:path

stat:stat

auth:auth];

}

} else if (S_ISREG(stat.mode)) {

result = [[KxSMBItemFile alloc] initWithType:KxSMBItemTypeFile

path:path

stat:stat

auth:auth];

} else {

result = [[KxSMBItem alloc] initWithType:S_ISLNK(stat.mode) ? KxSMBItemTypeLink : KxSMBItemTypeUnknown

path:path

stat:stat

auth:auth];

}

}

[self closeSmbContext:smbContext];

return result;

}

+ (id) removeAtPath:(NSString *)path

auth:(KxSMBAuth *)auth

{

NSParameterAssert(path);

if (![path hasPrefix:@"smb://"]) {

return mkKxSMBError(KxSMBErrorInvalidProtocol,

NSLocalizedString(@"Path:%@", nil), path);

}

SMBCCTX *smbContext = [self openSmbContext:auth];

if (!smbContext) {

const int err = errno;

return mkKxSMBError(errnoToSMBErr(err),

NSLocalizedString(@"Unable init SMB context (errno:%d)", nil), err);

}

id result;

int r = smbc_getFunctionUnlink(smbContext)(smbContext, path.UTF8String);

if (r < 0) {

int err = errno;

if (err == EISDIR || err == EINVAL) {

r = smbc_getFunctionRmdir(smbContext)(smbContext, path.UTF8String);

if (r < 0) {

err = errno;

result = mkKxSMBError(errnoToSMBErr(err),

NSLocalizedString(@"Unable rmdir file:%@ (errno:%d)", nil), path, err);

}

} else {

result = mkKxSMBError(errnoToSMBErr(err),

NSLocalizedString(@"Unable unlink file:%@ (errno:%d)", nil), path, err);

}

}

[self closeSmbContext:smbContext];

return result;

}

+ (id) createFolderAtPath:(NSString *)path

auth:(KxSMBAuth *)auth

{

NSParameterAssert(path);

if (![path hasPrefix:@"smb://"]) {

return mkKxSMBError(KxSMBErrorInvalidProtocol,

NSLocalizedString(@"Path:%@", nil), path);

}

SMBCCTX *smbContext = [self openSmbContext:auth];

if (!smbContext) {

const int err = errno;

return mkKxSMBError(errnoToSMBErr(err),

NSLocalizedString(@"Unable init SMB context (errno:%d)", nil), err);

}

id result;

int r = smbc_getFunctionMkdir(smbContext)(smbContext, path.UTF8String, 0);

if (r < 0) {

const int err = errno;

result = mkKxSMBError(errnoToSMBErr(err),

NSLocalizedString(@"Unable mkdir:%@ (errno:%d)", nil), path, err);

} else {

id stat = [self fetchStat:smbContext atPath: path];

if ([stat isKindOfClass:[KxSMBItemStat class]]) {

result = [[KxSMBItemTree alloc] initWithType:KxSMBItemTypeDir

path:path

stat:stat

auth:auth];

} else {

result = stat;

}

}

[self closeSmbContext:smbContext];

return result;

}

+ (id) createFileAtPath:(NSString *)path

overwrite:(BOOL)overwrite

auth:(KxSMBAuth *)auth

{

NSParameterAssert(path);

if (![path hasPrefix:@"smb://"]) {

return mkKxSMBError(KxSMBErrorInvalidProtocol,

NSLocalizedString(@"Path:%@", nil), path);

}

KxSMBItemFile *itemFile = [[KxSMBItemFile alloc] initWithType:KxSMBItemTypeFile

path:path

stat:nil

auth:auth];

id result = [itemFile createFile:overwrite];

if ([result isKindOfClass:[NSError class]]) {

return result;

}

return itemFile;

}

+ (NSError *) ensureLocalFolderExists:(NSString *)folderPath

{

NSFileManager *fm = [[NSFileManager alloc] init];

BOOL isDir;

if ([fm fileExistsAtPath:folderPath isDirectory:&isDir]) {

if (!isDir) {

return mkKxSMBError(KxSMBErrorFileIO,

NSLocalizedString(@"Cannot overwrite file %@", nil),

folderPath);

}

} else {

NSError *error;

if (![fm createDirectoryAtPath:folderPath

withIntermediateDirectories:NO

attributes:nil

error:&error]) {

return error;

}

}

return nil;

}

+ (NSFileHandle *) createLocalFile:(NSString *)path

overwrite:(BOOL) overwrite

error:(NSError **)outError

{

NSFileManager *fm = [[NSFileManager alloc] init];

if ([fm fileExistsAtPath:path]) {

if (overwrite) {

if (![fm removeItemAtPath:path error:outError]) {

return nil;

}

} else {

return nil;

}

}

NSString *folder = path.stringByDeletingLastPathComponent;

if (![fm fileExistsAtPath:folder] &&

![fm createDirectoryAtPath:folder

withIntermediateDirectories:YES

attributes:nil

error:outError]) {

return nil;

}

if (![fm createFileAtPath:path

contents:nil

attributes:nil]) {

if (outError) {

*outError = mkKxSMBError(KxSMBErrorFileIO,

NSLocalizedString(@"Unable create file", nil),

path.lastPathComponent);

}

return nil;

}

return [NSFileHandle fileHandleForWritingToURL:[NSURL fileURLWithPath:path]

error:outError];

}

+ (void) readSMBFile:(KxSMBItemFile *)smbFile

fileHandle:(NSFileHandle *)fileHandle

progress:(KxSMBBlockProgress)progress

block:(KxSMBBlock)block

{

[smbFile readDataOfLength:1024*1024

block:^(id result)

{

if ([result isKindOfClass:[NSData class]]) {

NSData *data = result;

if (data.length) {

[fileHandle writeData:data];

if (progress) {

BOOL stop = NO;

progress(smbFile, fileHandle.offsetInFile, &stop);

if (stop) {

// remove the local file from a disk

NSString *filePath;

char buffer[PATH_MAX] = {0};

if (fcntl(fileHandle.fileDescriptor, F_GETPATH, buffer) != -1) {

filePath = [[NSString alloc] initWithUTF8String:buffer];

}

//[fileHandle truncateFileAtOffset:0];

[fileHandle closeFile];

if (filePath.length) {

[[NSFileManager defaultManager] removeItemAtPath:filePath error:nil];

}

block(nil);

return;

}

}

[self readSMBFile:smbFile

fileHandle:fileHandle

progress:progress

block:block];

} else {

[fileHandle closeFile];

block(@(YES)); // complete

}

return;

}

[fileHandle closeFile];

block([result isKindOfClass:[NSError class]] ? result : nil);

}];

}

+ (void) copySMBFile:(KxSMBItemFile *)smbFile

localPath:(NSString *)localPath

overwrite:(BOOL)overwrite

progress:(KxSMBBlockProgress)progress

block:(KxSMBBlock)block

{

NSError *error = nil;

NSFileHandle *fileHandle = [self createLocalFile:localPath overwrite:overwrite error:&error];

if (fileHandle) {

[self readSMBFile:smbFile

fileHandle:fileHandle

progress:progress

block:block];

} else {

if (!error) {

error = mkKxSMBError(KxSMBErrorFileIO,

NSLocalizedString(@"Cannot overwrite file %@", nil),

localPath.lastPathComponent);

}

block(error);

}

}

+ (void) enumerateSMBFolders:(NSArray *)folders

items:(NSMutableArray *)items

block:(KxSMBBlock)block

{

KxSMBItemTree *folder = folders[0];

NSMutableArray *mfolders = [folders mutableCopy];

[mfolders removeObjectAtIndex:0];

[folder fetchItems:^(id result)

{

if ([result isKindOfClass:[NSArray class]]) {

for (KxSMBItem *item in result ) {

if ([item isKindOfClass:[KxSMBItemFile class]]) {

[items addObject:item];

} else if ([item isKindOfClass:[KxSMBItemTree class]] &&

(item.type == KxSMBItemTypeDir ||

item.type == KxSMBItemTypeFileShare ||

item.type == KxSMBItemTypeServer))

{

[mfolders addObject:item];

[items addObject:item];

}

}

if (mfolders.count) {

[self enumerateSMBFolders:mfolders items:items block:block];

} else {

block(items);

}

} else {

block([result isKindOfClass:[NSError class]] ? result : nil);

}

}];

}

+ (void) copySMBItems:(NSArray *)smbItems

smbFolder:(NSString *)smbFolder

localFolder:(NSString *)localFolder

overwrite:(BOOL)overwrite

progress:(KxSMBBlockProgress)progress

block:(KxSMBBlock)block

{

KxSMBItem *item = smbItems[0];

if (smbItems.count > 1) {

smbItems = [smbItems subarrayWithRange:NSMakeRange(1, smbItems.count - 1)];

} else {

smbItems = nil;

}

if ([item isKindOfClass:[KxSMBItemFile class]]) {

NSString *destPath = localFolder;

NSString *itemFolder = item.path.stringByDeletingLastPathComponent;

if (itemFolder.length > smbFolder.length) {

NSString *relPath = [itemFolder substringFromIndex:smbFolder.length];

destPath = [destPath stringByAppendingPathComponent:relPath];

}

destPath = [destPath stringByAppendingSMBPathComponent:item.path.lastPathComponent];

[self copySMBFile:(KxSMBItemFile *)item

localPath:destPath

overwrite:overwrite

progress:progress

block:^(id result)

{

if ([result isKindOfClass:[NSError class]]) {

block(result);

} else {

if (smbItems.count) {

[self copySMBItems:smbItems

smbFolder:smbFolder

localFolder:localFolder

overwrite:overwrite

progress:progress

block:block];

} else {

block(@(YES)); // complete

}

}

}];

} else if ([item isKindOfClass:[KxSMBItemTree class]]) {

NSString *destPath = localFolder;

NSString *itemFolder = item.path;

if (itemFolder.length > smbFolder.length) {

NSString *relPath = [itemFolder substringFromIndex:smbFolder.length];

destPath = [destPath stringByAppendingPathComponent:relPath];

}

NSError *error = [self ensureLocalFolderExists:destPath];

if (error) {

block(error);

return;

}

if (smbItems.count) {

[self copySMBItems:smbItems

smbFolder:smbFolder

localFolder:localFolder

overwrite:overwrite

progress:progress

block:block];

} else {

block(@(YES)); // complete

}

}

}

+ (void) writeSMBFile:(KxSMBItemFile *)smbFile

fileHandle:(NSFileHandle *)fileHandle

progress:(KxSMBBlockProgress)progress

block:(KxSMBBlock)block

{

NSData *data;

@try {

data = [fileHandle readDataOfLength:1024*1024];

}

@catch (NSException *exception) {

[fileHandle closeFile];

block(mkKxSMBError(KxSMBErrorFileIO, [exception description]));

return;

}

if (data.length) {