API in Swift

Summary

RouterOS API access library written in Swift 3.

Licensing

Code is provided as is and can be freely used freely. I, as a writer of code, am not responsible for anything that may arise from use of this code.

Usage

Simple example how this can be used.

api = ApiConn(address: "192.168.88.1")
api!.connect()
api!.login(username: "admin", password: "")

api!.sendCommand(command: "/ip/address/print");
while(true) {
    let s = api!.getData()
    if(!s.isEmpty) {
        print(s)
        if(s.contains("!done")) {
            break
        }
    }
}

Code

To use this library, start by adding

#import <CommonCrypto/CommonCrypto.h>

to Bridging Header. This is requred for login hashing.

Connection library uses SwiftSocket library. Add this to projcect Podfile or Carthage.

ApiConn.swift

Main file of API class. Consists of 5 classes:

ApiConn

Main API class. This is class that will be used by user

WriteCommand

Handles message sending to router

ReadCommand

Handles message receiving from router

Queue

Queue for received messages

Hasher

Login message hasher

import Foundation
import SwiftSocket

class ApiConn {
    private var socket : TCPClient?
    private var address = "192.168.88.1"
    private var port : Int32 = 8728
    private var connected = false
    
    private var readCommand : ReadCommand?
    private var writeCommand : WriteCommand?
    
    private var running = false
    
    /**
     Constructor of the connection class
     - parameter address: IP address of the router You want to conenct to
     - parameter port: port used for connection, ROS default is 8728
    */
    init (address: String, port: Int32) {
        self.address = address
        self.port = port
    }

    /**
     Constructor of the connection class. Uses default ROS port 8728 for connection
     - parameter address: IP address of the router You want to conenct to
     */
    init (address: String) {
        self.address = address
    }
    
    /**
     State of conenction
     - returns: if connection is established to router it returns true
     */
    func isConnected() -> Bool {
        return connected
    }
    
    func disconnect() {
        running = false
        connected = false
        readCommand?.stop()
        socket?.close()
    }
    
    private func listen() {
        if(connected) {
            if(readCommand == nil) {
                readCommand = ReadCommand(socket: socket!)
            }
            readCommand?.run()
        }
    }

    /**
     Sets and exectues command (sends it to RouterOS host connected)
     - parameter command: command will be sent to RouterOS for example "/ip/address/print\n=follow="
     - returns:
    */
    func sendCommand(command : String) -> String {
        return writeCommand!.setCommand(command).runCommand()
    }
    
    /**
     Exeecutes already set command.
     - returns: Status of the command sent
     */
    func runCommand() -> String {
        return writeCommand?.runCommand() ?? "failed"
    }
    
    /**
     Tries to fech data that is repllied to commands sent. It will timeout in ~1 second
     - returns: returns data sent by RouterOS or empty response on timeout
    */
    func getData() -> String  {
        var retry = 100
        while((readCommand?.queue.isEmpty)! && retry > 10) {
            usleep(10000)
            retry -= 1
        }
        let s = readCommand?.queue.dequeue()
        return s ?? ""
    }
    
    /**
     - returns: command that is set at this moment. And will be exectued if runCommand is exectued
     */
    func getCommand() -> String {
        return (writeCommand?.getCommand())!
    }
    
    /**
     Set up method that will log you in
     - parameter name: username of the user on the router
     - parameter password: password for the user
     - returns: login status
    */
    func login(username: String, password: String) -> String {
        sendCommand(command: "/login")
        var s = getData()
        if(s.isEmpty) {
            return "failed read #1"
        }
        if(!s.contains("!trap") && s.count > 4) {
            var tmp = s.components(separatedBy: "\n")
            if(tmp.count > 1) {
                tmp = tmp[tmp.count - 1].components(separatedBy: "=ret=")
                s = ""
                var transition = tmp[tmp.count - 1]
                var chal = Data()
                chal.append(0x00)
                chal.append(password.data(using: .ascii)!)
                chal.append(Data(hexStringToBytes(transition)!))
                chal = Hasher.MD5(string: chal)!
                
                let m = "/login\n=name=\(username)\n=response=00\(bytesToHexString(data: chal))"
                s = sendCommand(command: m)
                s = getData()
                if(s.isEmpty) {
                    return "failed read #2"
                }
                if(s.contains("!done")) {
                    if(!s.contains("!trap")) {
                        return "Login successful"
                    }
                }
            }
        }
        return "Login failed"
    }
    
    /**
     Open connection socket
     - returns: connection status
     */
    func connect() -> String {
        var status = "unknown"
        socket = TCPClient(address: address, port: port)
        if(socket?.connect(timeout: 3).isSuccess)! {
            status = "success"
            print("c: connected")
        } else {
            connected = false
            running = false
            print("c: failed")
            return "failure"
        }
        
        running = true
        connected = true
        writeCommand = WriteCommand(socket: socket!)
        readCommand = ReadCommand(socket: socket!)
        listen()
        return status
    }
    /**
     
     Converts hex string to byte array
     - parameter string: hex string to convert to
     - returns: converted string
     */
    func hexStringToBytes(_ string: String) -> [UInt8]? {
        let length = string.characters.count
        if length & 1 != 0 {
            return nil
        }
        var bytes = [UInt8]()
        bytes.reserveCapacity(length/2)
        var index = string.startIndex
        for _ in 0..<length/2 {
            let nextIndex = string.index(index, offsetBy: 2)
            if let b = UInt8(string[index..<nextIndex], radix: 16) {
                bytes.append(b)
            } else {
                return nil
            }
            index = nextIndex
        }
        return bytes
    }
    
    /**
     Converts hex value string to normal string for use with RouterOS API
     - parameter data: hex string to convert to
     - parameter separator: string to separate bytes (default is none)
     - returns: converted string
     */
    func bytesToHexString(data : Data, separator : String = "") -> String {
        return (data.map { String(format: "%02X", $0) }).joined(separator: separator)
    }
}

fileprivate class WriteCommand {
    var len : [UInt8] = [0]
    var socket : TCPClient
    var command = ""
    
    /**
     Creates a new instance of WriteCommand
     - parameter socket: API socket
     */
    init(socket: TCPClient) {
        self.socket = socket
    }
    
    func setCommand(_ command: String) -> WriteCommand {
        self.command = command
        return self
    }
    
    func getCommand() -> String {
        return command
    }
    
    private func writeLen(_ command : String) -> Data {
        let data = command.data(using: String.Encoding.utf8)
        var len = data?.count ?? 0
        var dat = Data()
        
        if len < 0x80 {
            dat.append([UInt8(len)], count: 1)
        }else if len < 0x4000 {
            len = len | 0x8000;
            dat.append(Data(bytes: [UInt8(len >> 8)]))
            dat.append(Data(bytes: [UInt8(len)]))
        }else if len < 0x20000 {
            len = len | 0xC00000;
            dat.append(Data(bytes: [UInt8(len >> 16)]))
            dat.append(Data(bytes: [UInt8(len >> 8)]))
            dat.append(Data(bytes: [UInt8(len)]))
        }
        else if len < 0x10000000 {
            len = len | 0xE0000000;
            dat.append(Data(bytes: [UInt8(len >> 24)]))
            dat.append(Data(bytes: [UInt8(len >> 16)]))
            dat.append(Data(bytes: [UInt8(len >> 8)]))
            dat.append(Data(bytes: [UInt8(len)]))
        }else{
            dat.append(Data(bytes: [0xF0]))
            dat.append(Data(bytes: [UInt8(len >> 24)]))
            dat.append(Data(bytes: [UInt8(len >> 16)]))
            dat.append(Data(bytes: [UInt8(len >> 8)]))
            dat.append(Data(bytes: [UInt8(len)]))
        }
        
        return dat
    }
    
    func runCommand() -> String {
        var ret = Data()
        if(!command.contains("\n")) {
            var i = 0
            var b = writeLen(command)
            var retLen = b.count + command.count + 1
            ret.append(b)
            ret.append(command.data(using: String.Encoding.ascii)!)
        } else {
            var str = command.components(separatedBy: "\n")
            var i = 0
            var iTmp : [Int] = []
            for s in str {
                let len = writeLen(s).count + s.count
                iTmp.append(len)
            }
            for b in iTmp {
                i += b
            }
            
            for s in str {
                var j = 0
                var b = writeLen(s)
                for bb in b {
                    ret.append(bb)
                }
                let dat = s.data(using: .utf8)
                ret.append(dat!)
            }
        }
        ret.append(0)
        socket.send(data: ret)
        return "OK"
    }
}

fileprivate class ReadCommand {
    var socket : TCPClient
    var queue : Queue<String> = Queue()
    var running = false
    
    /**
     Creates a new instance of ReadCommand
     - parameter socket: API socket
     */
    init (socket: TCPClient) {
        self.socket = socket
    }
    
    func stop() {
        running = false
    }
    
    func run() {
        running = true
        
        DispatchQueue.global(qos: .utility).async {
            var b : UInt8 = 0
            var s = ""
            var ch : Character?
            var a : UInt32 = 0
            while(self.running) {
                var sk : UInt32 = 0
                let res = self.read()
                if(!res.1) {
                    continue
                }
                a = res.0

                if(a != 0 && a > 0) {
                    if(a < 0x80) {
                        sk = UInt32(a)
                    } else {
                        if(a < 0xC0) {
                            a = a << 8
                            a +=  self.read().0
                            sk = UInt32(a) ^ 0x8000
                        } else {
                            if(a < 0xE0) {
                                for i in 0...1 {
                                  a = a << 8
                                  a += self.read().0
                                }
                                sk = UInt32(a ^ 0xC00000)
                            } else {
                                if (a < 0xF0) {
                                    for i in 0...2 {
                                        a = a << 8;
                                        a += self.read().0
                                    }
                                    
                                    sk = UInt32(a ^ 0xE0000000);
                                } else {
                                    if (a < 0xF8) {
                                        a = 0;
                                        for i in 0...4 {
                                            a = a << 8;
                                            a += self.read().0
                                        }
                                    } else {
                                    }
                                }
                            }
                        }
                    }
                    s += "\n"
                    let len = Int(sk)
                    var rx = self.socket.read(len, timeout: 500)
                   
                    if(rx == nil) {
                        a = 0
                    } else {
                        let rxd = Data(rx!)
                        a = UInt32(rx!.count)
                    }
                    
                    if(a > 0) {
                        s += String(data: Data(rx!), encoding: String.Encoding.ascii)!
                    }
                } else if (b == 0xFF) {
                    print("Error. Wrong port?")
                } else {
                    self.queue.enqueue(s)
                    s = ""
                }
            }
        }
    }
    
    private func read() -> (UInt32,Bool) {
        let rx = socket.read(1, timeout: 1)
        if(rx != nil) {
            return (UInt32(rx![0]),true)
        }
        return (0xFF,false)
    }
    
}

/*
 First-in first-out queue (FIFO)
 
 New elements are added to the end of the queue. Dequeuing pulls elements from
 the front of the queue.
 
 Enqueuing and dequeuing are O(1) operations.
 */
fileprivate class Queue<T> {
    fileprivate var array = [T?]()
    fileprivate var head = 0
    
    public var isEmpty: Bool {
        return count == 0
    }
    
    public var count: Int {
        return array.count - head
    }
    
    public func enqueue(_ element: T) {
        array.append(element)
    }
    
    public func dequeue() -> T? {
        guard head < array.count, let element = array[head] else { return nil }
        
        array[head] = nil
        head += 1
        
        let percentage = Double(head)/Double(array.count)
        if array.count > 50 && percentage > 0.25 {
            array.removeFirst(head)
            head = 0
        }
        
        return element
    }
    
    public var front: T? {
        if isEmpty {
            return nil
        } else {
            return array[head]
        }
    }
}

fileprivate class Hasher {
    /**
     Makes MD5 hash of string for use with RouterOS API
     - parameter string: variable to make hacsh from
     - returns: hashed string
     */
    static func MD5(string: Data) -> Data? {
        let messageData = string
        var digestData = Data(count: Int(CC_MD5_DIGEST_LENGTH))
        
        _ = digestData.withUnsafeMutableBytes {digestBytes in
            messageData.withUnsafeBytes {messageBytes in
                CC_MD5(messageBytes, CC_LONG(messageData.count), digestBytes)
            }
        }
        
        return digestData
    }
}