354 lines
13 KiB
Swift
354 lines
13 KiB
Swift
/**
|
|
* I'll order you a pizza if you can rewrite this in modern idomatic Swift
|
|
*/
|
|
|
|
import Swift
|
|
import Foundation
|
|
|
|
/**
|
|
*
|
|
* IDENTITIES and AUTHORIZATION:
|
|
*
|
|
* - Upon the first execution of this code, a new identity will be generated and placed in
|
|
* the location given in the first argument to zts_start(path, ...). If you accidentally
|
|
* duplicate the identity files and use them simultaneously in a different node instance
|
|
* you will experience undefined behavior and it is likely nothing will work.
|
|
*
|
|
* - You must authorize the node ID provided by the ZTS_EVENT_NODE_ONLINE callback to join
|
|
* your network, otherwise nothing will happen. This can be done manually or via
|
|
* our web API: https://my.zerotier.com/help/api
|
|
*
|
|
* - An exception to the above rule is if you are using an Ad-hoc network, it has no
|
|
* controller and therefore requires no authorization.
|
|
*
|
|
*
|
|
* ESTABLISHING A CONNECTION:
|
|
*
|
|
* - Creating a standard socket connection generally works the same as it would using
|
|
* an ordinary socket interface, however with libzt there is a subtle difference in
|
|
* how connections are established which may cause confusion:
|
|
*
|
|
* The underlying virtual ZT layer creates what are called "transport-triggered links"
|
|
* between nodes. That is, links are not established until an attempt to communicate
|
|
* with a peer has taken place. The side effect is that the first few packets sent from
|
|
* a libzt instance are usually relayed via our free infrastructure and it isn't until a
|
|
* root server has passed contact information to both peers that a direct connection will be
|
|
* established. Therefore, it is required that multiple connection attempts be undertaken
|
|
* when initially communicating with a peer. After a transport-triggered link is
|
|
* established libzt will inform you via ZTS_EVENT_PEER_DIRECT for a specific peer ID. No
|
|
* action is required on your part for this callback event.
|
|
*
|
|
* Note: In these initial moments before ZTS_EVENT_PEER_DIRECT has been received for a
|
|
* specific peer, traffic may be slow, jittery and there may be high packet loss.
|
|
* This will subside within a couple of seconds.
|
|
*
|
|
*
|
|
* ERROR HANDLING:
|
|
*
|
|
* - libzt's API is actually composed of two categories of functions with slightly
|
|
* different error reporting mechanisms.
|
|
*
|
|
* Category 1: Control functions (zts_start, zts_join, zts_get_peer_status, etc). Errors
|
|
* returned by these functions can be any of the following:
|
|
*
|
|
* ZTS_ERR_OK // No error
|
|
* ZTS_ERR_SOCKET // Socket error, see zts_errno
|
|
* ZTS_ERR_SERVICE // You probably did something at the wrong time
|
|
* ZTS_ERR_ARG // Invalid argument
|
|
* ZTS_ERR_NO_RESULT // No result (not necessarily an error)
|
|
* ZTS_ERR_GENERAL // Consider filing a bug report
|
|
*
|
|
* Category 2: Sockets (zts_socket, zts_bind, zts_connect, zts_listen, etc).
|
|
* Errors returned by these functions can be the same as the above. With
|
|
* the added possibility of zts_errno being set. Much like standard
|
|
* errno this will provide a more specific reason for an error's occurrence.
|
|
* See ZeroTierSockets.h for values.
|
|
*
|
|
*
|
|
* API COMPATIBILITY WITH HOST OS:
|
|
*
|
|
* - While the ZeroTier socket interface can coexist with your host OS's own interface in
|
|
* the same file with no type and naming conflicts, try not to mix and match host
|
|
* OS/libzt structures, functions, or constants. It may look similar and may even work
|
|
* some of the time but there enough differences that it will cause headaches. Here
|
|
* are a few guidelines:
|
|
*
|
|
* If you are calling a zts_* function, use the appropriate ZTS_* constants:
|
|
*
|
|
* zts_socket(ZTS_AF_INET6, ZTS_SOCK_DGRAM, 0); (CORRECT)
|
|
* zts_socket(AF_INET6, SOCK_DGRAM, 0); (INCORRECT)
|
|
*
|
|
* If you are calling a zts_* function, use the appropriate zts_* structure:
|
|
*
|
|
* struct zts_sockaddr_in in4; <------ Note the zts_* prefix
|
|
* ...
|
|
* zts_bind(fd, (struct zts_sockaddr *)&in4, sizeof(struct zts_sockaddr_in)) < 0)
|
|
*
|
|
*/
|
|
|
|
let printNodeDetails : @convention(c) (UnsafeMutableRawPointer?) -> Void =
|
|
{
|
|
(msgPtr) -> Void in
|
|
let msg = msgPtr?.bindMemory(to: zts_callback_msg.self, capacity: 1)
|
|
let d = msg?.pointee.node;
|
|
print(String(format: "\t- id : %llx", d!.pointee.address));
|
|
print(String(format: "\t- version : %d.%d.%d", d!.pointee.versionMajor, d!.pointee.versionMinor, d!.pointee.versionRev));
|
|
print(String(format: "\t- primaryPort : %d", d!.pointee.primaryPort));
|
|
print(String(format: "\t- secondaryPort : %d", d!.pointee.secondaryPort));
|
|
}
|
|
|
|
/*
|
|
func convertTupleToArray<Tuple, Value>(from tuple: Tuple) -> [Value] {
|
|
let tupleMirror = Mirror(reflecting: tuple)
|
|
func convert(child: Mirror.Child) -> Value? {
|
|
let valueMirror = Mirror(reflecting: child.value)
|
|
return child.value as? Value
|
|
}
|
|
return tupleMirror.children.flatMap(convert)
|
|
}
|
|
*/
|
|
|
|
let printNetworkDetails : @convention(c) (UnsafeMutableRawPointer?) -> Void =
|
|
{
|
|
(msgPtr) -> Void in
|
|
let msg = msgPtr?.bindMemory(to: zts_callback_msg.self, capacity: 1)
|
|
let d = msg?.pointee.network;
|
|
let name = ""; // String(d!.pointee.name);
|
|
|
|
print(String(format: "\t- nwid : %llx", d!.pointee.nwid));
|
|
print(String(format: "\t- mac : %lx", d!.pointee.mac));
|
|
print(String(format: "\t- name : %s", name));
|
|
print(String(format: "\t- type : %d", Int(d!.pointee.type.rawValue)));
|
|
/* MTU for the virtual network can be set via our web API */
|
|
print(String(format: "\t- mtu : %d", d!.pointee.mtu));
|
|
print(String(format: "\t- dhcp : %d", d!.pointee.dhcp));
|
|
print(String(format: "\t- bridge : %d", d!.pointee.bridge));
|
|
print(String(format: "\t- broadcastEnabled : %d", d!.pointee.broadcastEnabled));
|
|
print(String(format: "\t- portError : %d", d!.pointee.portError));
|
|
print(String(format: "\t- netconfRevision : %d", d!.pointee.netconfRevision));
|
|
print(String(format: "\t- routeCount : %d", d!.pointee.routeCount));
|
|
print(String(format: "\t- multicastSubscriptionCount : %d", d!.pointee.multicastSubscriptionCount));
|
|
/*
|
|
var addresses: [zts_sockaddr_storage] = convertTupleToArray(from: d!.pointee.assignedAddresses)
|
|
|
|
print("\t- addresses:\n");
|
|
for i in 0...d!.pointee.assignedAddressCount {
|
|
if (addresses[Int(i)].ss_family == ZTS_AF_INET) {
|
|
// Allocate a byte array that can hold the largest possible IPv4 human-readable string
|
|
var ipCharByteArray = Array<Int8>(repeating: 0, count: Int(ZTS_INET_ADDRSTRLEN))
|
|
// Cast unsafe pointer from zts_sockaddr_storage to zts_sockaddr_in
|
|
var addr:zts_sockaddr_in = withUnsafePointer(to: &(addresses[Int(i)])) {
|
|
$0.withMemoryRebound(to: zts_sockaddr_in.self, capacity: 1) {
|
|
$0.pointee
|
|
}
|
|
}
|
|
// Pass unsafe pointer (addr) to a ntop to convert into human-readable byte array
|
|
zts_inet_ntop(ZTS_AF_INET, &(addr.sin_addr), &ipCharByteArray, UInt32(ZTS_INET_ADDRSTRLEN))
|
|
//print(ipCharByteArray) // [49, 55, 50, 46, 50, 55, 46, 49, 49, 54, 46, 49, 54, 55, 0, 0]
|
|
// Somehow convery Int8 byte array to Swift String ???
|
|
//let ipString = String(bytes: ipStr, encoding: .utf8)
|
|
//print(ipString)
|
|
|
|
// Pass unsafe pointer (addr) to a ntop to convert into human-readable byte array
|
|
// convert to UInt8 byte array
|
|
let uintArray = ipCharByteArray.map { UInt8(bitPattern: $0) }
|
|
if let string = String(bytes: uintArray, encoding: .utf8) {
|
|
print("\t\t-", string)
|
|
}
|
|
}
|
|
if (addresses[Int(i)].ss_family == ZTS_AF_INET6) {
|
|
// ...
|
|
}
|
|
}
|
|
*/
|
|
/*
|
|
print("\t- routes:\n");
|
|
|
|
for i in 0...d!.pointee.routeCount {
|
|
// ...
|
|
}
|
|
*/
|
|
}
|
|
|
|
let printPeerDetails : @convention(c) (UnsafeMutableRawPointer?) -> Void =
|
|
{
|
|
(msgPtr) -> Void in
|
|
let msg = msgPtr?.bindMemory(to: zts_callback_msg.self, capacity: 1)
|
|
let d = msg?.pointee.peer;
|
|
print(String(format: "\t- peer : %llx", d!.pointee.address));
|
|
print(String(format: "\t- role : %d", Int(d!.pointee.role.rawValue)));
|
|
print(String(format: "\t- latency : %llx", d!.pointee.latency));
|
|
print(String(format: "\t- pathCount : %llx", d!.pointee.pathCount));
|
|
print(String(format: "\t- version : %d.%d.%d", d!.pointee.versionMajor, d!.pointee.versionMinor, d!.pointee.versionRev));
|
|
print(String(format: "\t- paths:\n"));
|
|
|
|
/*
|
|
for i in 0...d!.pointee.pathCount {
|
|
// ...
|
|
}
|
|
*/
|
|
}
|
|
|
|
let printNetifDetails : @convention(c) (UnsafeMutableRawPointer?) -> Void =
|
|
{
|
|
(msgPtr) -> Void in
|
|
let msg = msgPtr?.bindMemory(to: zts_callback_msg.self, capacity: 1)
|
|
let d = msg?.pointee.netif;
|
|
print(String(format: "\t- nwid : %llx", d!.pointee.nwid));
|
|
print(String(format: "\t- mac : %llx", d!.pointee.mac));
|
|
print(String(format: "\t- mtu : %d", d!.pointee.mtu));
|
|
}
|
|
|
|
var nodeReady:Bool = false
|
|
var networkReady:Bool = false
|
|
|
|
let on_zts_event : @convention(c) (UnsafeMutableRawPointer?) -> Void =
|
|
{
|
|
(msgPtr) -> Void in
|
|
let msg = msgPtr?.bindMemory(to: zts_callback_msg.self, capacity: 1)
|
|
|
|
let eventCode = msg!.pointee.eventCode
|
|
let network = msg?.pointee.network;
|
|
let peer = msg?.pointee.peer;
|
|
|
|
switch Int32(eventCode)
|
|
{
|
|
case ZTS_EVENT_NODE_UP:
|
|
print("ZTS_EVENT_NODE_UP (you can ignore this)\n")
|
|
|
|
case ZTS_EVENT_NODE_ONLINE:
|
|
print("ZTS_EVENT_NODE_ONLINE\n")
|
|
printNodeDetails(msg)
|
|
nodeReady = true;
|
|
|
|
case ZTS_EVENT_NODE_OFFLINE:
|
|
print("ZTS_EVENT_NODE_OFFLINE\n")
|
|
nodeReady = false;
|
|
|
|
case ZTS_EVENT_NODE_NORMAL_TERMINATION:
|
|
print("ZTS_EVENT_NODE_NORMAL_TERMINATION\n")
|
|
|
|
case ZTS_EVENT_NETWORK_NOT_FOUND:
|
|
let networkId:UInt64 = network!.pointee.nwid
|
|
print(String(format: "ZTS_EVENT_NETWORK_NOT_FOUND (%llx)", networkId))
|
|
|
|
case ZTS_EVENT_NETWORK_REQ_CONFIG:
|
|
let networkId:UInt64 = network!.pointee.nwid
|
|
print(String(format: "ZTS_EVENT_NETWORK_REQ_CONFIG (%llx)", networkId))
|
|
|
|
case ZTS_EVENT_NETWORK_ACCESS_DENIED:
|
|
let networkId:UInt64 = network!.pointee.nwid
|
|
print(String(format: "ZTS_EVENT_NETWORK_ACCESS_DENIED (%llx)", networkId))
|
|
|
|
case ZTS_EVENT_NETWORK_READY_IP4:
|
|
let networkId:UInt64 = network!.pointee.nwid
|
|
print(String(format: "ZTS_EVENT_NETWORK_READY_IP4 (%llx)", networkId))
|
|
networkReady = true;
|
|
|
|
case ZTS_EVENT_NETWORK_READY_IP6:
|
|
let networkId:UInt64 = network!.pointee.nwid
|
|
print(String(format: "ZTS_EVENT_NETWORK_READY_IP6 (%llx)", networkId))
|
|
networkReady = true;
|
|
|
|
case ZTS_EVENT_NETWORK_DOWN:
|
|
let networkId:UInt64 = network!.pointee.nwid
|
|
print(String(format: "ZTS_EVENT_NETWORK_DOWN (%llx)", networkId))
|
|
|
|
case ZTS_EVENT_NETWORK_UPDATE:
|
|
print("ZTS_EVENT_NETWORK_UPDATE\n")
|
|
printNetworkDetails(msg)
|
|
|
|
|
|
case ZTS_EVENT_ADDR_ADDED_IP4:
|
|
print("ZTS_EVENT_ADDR_ADDED_IP4\n")
|
|
|
|
case ZTS_EVENT_ADDR_ADDED_IP6:
|
|
print("ZTS_EVENT_ADDR_ADDED_IP6\n")
|
|
|
|
case ZTS_EVENT_ADDR_REMOVED_IP4:
|
|
print("ZTS_EVENT_ADDR_REMOVED_IP4\n")
|
|
|
|
case ZTS_EVENT_ADDR_REMOVED_IP6:
|
|
print("ZTS_EVENT_ADDR_REMOVED_IP6\n")
|
|
|
|
|
|
case ZTS_EVENT_PEER_DIRECT:
|
|
let peerId:UInt64 = peer!.pointee.address
|
|
print(String(format: "ZTS_EVENT_PEER_DIRECT (%llx)", peerId))
|
|
printPeerDetails(msg)
|
|
|
|
case ZTS_EVENT_PEER_RELAY:
|
|
let peerId:UInt64 = peer!.pointee.address
|
|
print(String(format: "ZTS_EVENT_PEER_RELAY (%llx)", peerId))
|
|
printPeerDetails(msg)
|
|
|
|
case ZTS_EVENT_PEER_PATH_DISCOVERED:
|
|
let peerId:UInt64 = peer!.pointee.address
|
|
print(String(format: "ZTS_EVENT_PEER_PATH_DISCOVERED (%llx)", peerId))
|
|
printPeerDetails(msg)
|
|
|
|
case ZTS_EVENT_PEER_PATH_DEAD:
|
|
let peerId:UInt64 = peer!.pointee.address
|
|
print(String(format: "ZTS_EVENT_PEER_PATH_DEAD (%llx)", peerId))
|
|
printPeerDetails(msg)
|
|
|
|
|
|
case ZTS_EVENT_NETIF_UP:
|
|
print("ZTS_EVENT_NETIF_UP\n")
|
|
|
|
case ZTS_EVENT_NETIF_DOWN:
|
|
print("ZTS_EVENT_NETIF_DOWN\n")
|
|
|
|
case ZTS_EVENT_NETIF_REMOVED:
|
|
print("ZTS_EVENT_NETIF_REMOVED\n")
|
|
|
|
case ZTS_EVENT_NETIF_LINK_UP:
|
|
print("ZTS_EVENT_NETIF_LINK_UP\n")
|
|
|
|
case ZTS_EVENT_NETIF_LINK_DOWN:
|
|
print("ZTS_EVENT_NETIF_LINK_DOWN\n")
|
|
|
|
case ZTS_EVENT_STACK_UP:
|
|
print("ZTS_EVENT_STACK_UP\n")
|
|
|
|
case ZTS_EVENT_STACK_DOWN:
|
|
print("ZTS_EVENT_STACK_DOWN\n")
|
|
|
|
default:
|
|
print("UNKNOWN_EVENT: ", eventCode)
|
|
}
|
|
}
|
|
|
|
func main()
|
|
{
|
|
print("waiting for node to come online...")
|
|
zts_start("config_path", on_zts_event, 0)
|
|
while(!nodeReady) {
|
|
sleep(1)
|
|
}
|
|
print("Joining network")
|
|
|
|
let nwId : UInt64 = 0x0123456789abcdef; // Specify your network ID here
|
|
zts_join(nwId);
|
|
|
|
// create address structure
|
|
let addr_str = "0.0.0.0"
|
|
let port = 8080
|
|
var in4 = zts_sockaddr_in(sin_len: UInt8(MemoryLayout<zts_sockaddr_in>.size),
|
|
sin_family: UInt8(ZTS_AF_INET),
|
|
sin_port: UInt16(port).bigEndian,
|
|
sin_addr: zts_in_addr(s_addr: 0),
|
|
sin_zero: (0,0,0,0,0,0,0,0))
|
|
zts_inet_pton(ZTS_AF_INET, addr_str, &(in4.sin_addr));
|
|
|
|
print("fd=", zts_socket(ZTS_AF_INET, ZTS_SOCK_STREAM, 0));
|
|
|
|
// ...
|
|
|
|
while(true) {
|
|
sleep(1);
|
|
}
|
|
}
|
|
|
|
main()
|