Swiftpack.co - Package - amosavian/AMSMB2

AMSMB2

This is small Swift library for iOS, macOS and tvOS which wraps libsmb2 and allows to connect a SMB2/3 share and do file operation.

Swift Version Platform License

Build Status Release version CocoaPods version Carthage compatible Accio supported

Install

Cocoapods / Carthage

Add this line to your pods file:

pod "AMSMB2"

Or add this to Cartfile:

github "amosavian/AMSMB2"

Accio

Add the following to your Package.swift:

.package(url: "https://github.com/amosavian/AMSMB2.git", .upToNextMajor(from: "2.0.0")),

Next, add AMSMB2 to your App targets dependencies like so:

.target(
    name: "App",
    dependencies: [
        "AMSMB2",
    ]
),

Then run accio update.

Manually

To have latest updates with ease, use this command on terminal to get a clone:

git clone https://github.com/amosavian/AMSMB2

You can update your library using this command in AMSMB2 folder:

git pull

if you have a git based project, use this command in your project's directory to add this project as a submodule to your project:

git submodule add https://github.com/amosavian/AMSMB2

Then drop AMSMB2.xcodeproj to you Xcode workspace and add the framework to your Embeded Binaries in target.

Usage

Just read inline help to find what each function does. It's straightforward. It's thread safe and any queue.

To do listing files in directory and file operations you must use this template:

import AMSMB2

class SMBClient {
    /// connect to: `smb://guest@XXX.XXX.XX.XX/share`
    
    let serverURL = URL(string: "smb://XXX.XXX.XX.XX")!
    let credential = URLCredential(user: "guest", password: "", persistence: URLCredential.Persistence.forSession)
    let share = "share"
    
    lazy private var client = AMSMB2(url: self.serverURL, credential: self.credential)!
    
    private func connect(handler: @escaping (Result<AMSMB2, Error>) -> Void) {
        // AMSMB2 can handle queueing connection requests
        client.connectShare(name: self.share) { error in
            if let error = error {
                handler(.failure(error))
            } else {
                handler(.success(self.client))
            }
        }
    }
    
    func listDirectory(path: String) {
        connect { result in
            switch result {
            case .success(let client):
                client.contentsOfDirectory(atPath: path) { result in
                    switch result {
                    case .success(let files):
                        for entry in files {
                            print("name:", entry[.nameKey] as! String,
                                  ", path:", entry[.pathKey] as! String,
                                  ", type:", entry[.fileResourceTypeKey] as! URLFileResourceType,
                                  ", size:", entry[.fileSizeKey] as! Int64,
                                  ", modified:", entry[.contentModificationDateKey] as! Date,
                                  ", created:", entry[.creationDateKey] as! Date)
                        }
                        
                    case .failure(let error):
                        print(error)
                    }
                }
                
            case .failure(let error):
                print(error)
            }
        }
    }
    
    func moveItem(path: String, to toPath: String) {
        self.connect { result in
            switch result {
            case .success(let client):
                client.moveItem(atPath: path, toPath: toPath) { error in
                    if let error = error {
                        print(error)
                    } else {
                        print("\(path) moved successfully.")
                    }
                    
                    // Disconnecting is optional, it will be called eventually
                    // when `AMSMB2` object is freed.
                    // You may call it explicitly to detect errors.
                    client.disconnectShare(completionHandler: { (error) in
                        if let error = error {
                            print(error)
                        }
                    })
                }
                
            case .failure(let error):
                print(error)
            }
        }
    }
}

License

While source code shipped with project is MIT licensed, but it has static link to libsmb2 which is LGPL v2.1, consequently the whole project becomes LGPL v2.1.

You must link this library dynamically to your app if you intend to distribute your app on App Store.

Github

link
Stars: 50
Help us keep the lights on

Dependencies

Used By

Total: 1

Releases

2.2.0 - May 27, 2019

  • Added custom port support
  • Prevent appending/overwriting files
  • Fix: attributesOfFileSystem() to handle slash opening/ending
  • Enhanced test coverage

2.0.0 - Apr 28, 2019

This version changes AMSMB2's public API to exploit new Swift features, while providing an Objective-C compatibility layer.

  • Return Result in completion handler instead of nullable pairs
    • You can use switch to handle result or error, see readme
  • Accepting DataProtocol instead of concrete Data
    • You can pass [UInt8] or DispatchData to write(data:) method without casting
  • Accepting Range instead of offset-length pair
    • Use the same range you already use to subscript data for contents(atPath:range:) method
  • Disconnect gracefully
    • disconnect(graceful: true) will wait until all queued file operations are done and their completion handler is executed.
  • Reading from / writing to InputStream/OutputStream directly.
  • Fixed reporting incorrect creation date of file

1.9.0 - Apr 26, 2019

Fixed #24 and added tests to prevent issue in future.

1.8.0 - Apr 4, 2019

  • Fixed timeout issue of listShares() on Swift 5.0

1.7.0 - Sep 10, 2018

  • Added debugDescription and customMirror (CustomReflectable)
  • Proper reconnecting handling after server timeout
  • Fixed various crashes