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
}
}