Simple application for ZeroTier SDK (libzt)

Dockerfile

# Use ZeroTier SDK image to build the binary
FROM quay.io/soukron/zerotier-libzt-sdk:v1.3.1 as sdk 
COPY . /tmp/src
RUN cd /tmp/src && \
    make build-simple

# Copy the binary to the ZeroTier Runtime image
FROM quay.io/soukron/zerotier-libzt-runtime:v1.3.1
COPY --from=sdk /tmp/src/simple /usr/local/bin/simple

Makefile

.DEFAULT_GOAL := build-image
FILE ?= simple

build-image:
	docker build -t zerotier-simple .

local:	clean build-local run-local

build-local:
	clang++ $(FILE).cpp -o $(FILE) \
		-I lib/libzt-1.3.1/include \
		-L lib/libzt-1.3.1 \
		-lzt

run-local:
	LD_LIBRARY_PATH=lib/libzt-1.3.1 ./$(FILE)

build-simple:
	clang++ $(FILE).cpp -o $(FILE) \
		-I /lib64/libzt/include \
		-L /lib64/libzt/ \
		-lzt

clean:
	ls -1 | egrep -ve 'Dockerfile|lib|Makefile|*.cpp|creds' | xargs rm -frv

force-clean:
	ls -1 | egrep -ve 'Dockerfile|lib|Makefile|*.cpp' | xargs rm -frv

simple.cpp

#include <arpa/inet.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "ZeroTier.h"

bool node_ready = false;
bool network_ready = false;

void myZeroTierEventCallback(struct zts_callback_msg *msg)
{
    switch (msg->eventCode)
    {
        case ZTS_EVENT_NONE:
            printf("ZTS_EVENT_NONE\n");
            break;
        case ZTS_EVENT_NODE_UP:
            printf("ZTS_EVENT_NODE_UP\n");
            break;
        //case ZTS_EVENT_NODE_OFFLINE:
        //    printf("ZTS_EVENT_NODE_OFFLINE\n");
        //    break;
        //case ZTS_EVENT_NODE_ONLINE:
        //    printf("ZTS_EVENT_NODE_ONLINE\n");
        //    break;
        case ZTS_EVENT_NODE_DOWN:
            printf("ZTS_EVENT_NODE_DOWN\n");
            break;
        case ZTS_EVENT_NODE_IDENTITY_COLLISION:
            printf("ZTS_EVENT_NODE_IDENTITY_COLLISION\n");
            break;
        case ZTS_EVENT_NODE_UNRECOVERABLE_ERROR:
            printf("ZTS_EVENT_NODE_UNRECOVERABLE_ERROR\n");
            break;
        case ZTS_EVENT_NODE_NORMAL_TERMINATION:
            printf("ZTS_EVENT_NODE_NORMAL_TERMINATION\n");
            break;
        case ZTS_EVENT_NETWORK_NOT_FOUND:
            printf("ZTS_EVENT_NETWORK_NOT_FOUND\n");
            break;
        case ZTS_EVENT_NETWORK_CLIENT_TOO_OLD:
            printf("ZTS_EVENT_NETWORK_CLIENT_TOO_OLD\n");
            break;
        case ZTS_EVENT_NETWORK_REQUESTING_CONFIG:
            printf("ZTS_EVENT_NETWORK_REQUESTING_CONFIG\n");
            break;
        case ZTS_EVENT_NETWORK_OK:
            printf("ZTS_EVENT_NETWORK_OK\n");
            break;
        case ZTS_EVENT_NETWORK_ACCESS_DENIED:
            printf("ZTS_EVENT_NETWORK_ACCESS_DENIED\n");
            break;
        //case ZTS_EVENT_NETWORK_READY_IP4:
        //    printf("ZTS_EVENT_NETWORK_READY_IP4\n");
        //    break;
        case ZTS_EVENT_NETWORK_READY_IP6:
            printf("ZTS_EVENT_NETWORK_READY_IP6\n");
            break;
        case ZTS_EVENT_NETWORK_READY_IP4_IP6:
            printf("ZTS_EVENT_NETWORK_READY_IP4_IP6\n");
            break;
        case ZTS_EVENT_NETWORK_DOWN:
            printf("ZTS_EVENT_NETWORK_DOWN\n");
            break;
        case ZTS_EVENT_STACK_UP:
            printf("ZTS_EVENT_STACK_UP\n");
            break;
        case ZTS_EVENT_STACK_DOWN:
            printf("ZTS_EVENT_STACK_DOWN\n");
            break;
        case ZTS_EVENT_NETIF_UP:
            printf("ZTS_EVENT_NETIF_UP\n");
            break;
        case ZTS_EVENT_NETIF_DOWN:
            printf("ZTS_EVENT_NETIF_DOWN\n");
            break;
        case ZTS_EVENT_NETIF_REMOVED:
            printf("ZTS_EVENT_NETIF_REMOVED\n");
            break;
        case ZTS_EVENT_NETIF_LINK_UP:
            printf("ZTS_EVENT_NETIF_LINK_UP\n");
            break;
        case ZTS_EVENT_NETIF_LINK_DOWN:
            printf("ZTS_EVENT_NETIF_LINK_DOWN\n");
            break;
        //case ZTS_EVENT_PEER_P2P:
        //    printf("ZTS_EVENT_PEER_P2P\n");
        //    break;
        //case ZTS_EVENT_PEER_RELAY:
        //    printf("ZTS_EVENT_PEER_RELAY\n");
        //    break;
        case ZTS_EVENT_PEER_UNREACHABLE:
            printf("ZTS_EVENT_PEER_UNREACHABLE\n");
            break;
        case ZTS_EVENT_PATH_DISCOVERED:
            printf("ZTS_EVENT_PATH_DISCOVERED\n");
            break;
        case ZTS_EVENT_PATH_ALIVE:
            printf("ZTS_EVENT_PATH_ALIVE\n");
            break;
        case ZTS_EVENT_PATH_DEAD:
            printf("ZTS_EVENT_PATH_DEAD\n");
            break;
        case ZTS_EVENT_ROUTE_ADDED:
            printf("ZTS_EVENT_ROUTE_ADDED\n");
            break;
        case ZTS_EVENT_ROUTE_REMOVED:
            printf("ZTS_EVENT_ROUTE_REMOVED\n");
            break;
        case ZTS_EVENT_ADDR_ADDED_IP4:
            printf("ZTS_EVENT_ADDR_ADDED_IP4\n");
            break;
        case ZTS_EVENT_ADDR_REMOVED_IP4:
            printf("ZTS_EVENT_ADDR_REMOVED_IP4\n");
            break;
        case ZTS_EVENT_ADDR_ADDED_IP6:
            printf("ZTS_EVENT_ADDR_ADDED_IP6\n");
            break;
        case ZTS_EVENT_ADDR_REMOVED_IP6:
            printf("ZTS_EVENT_ADDR_REMOVED_IP6\n");
            break;

        case ZTS_EVENT_NODE_ONLINE:
            printf("ZTS_EVENT_NODE_ONLINE, nodeId=%lx\n", msg->node->address);
            node_ready = true;
            break;
        case ZTS_EVENT_NODE_OFFLINE:
            printf("ZTS_EVENT_NODE_OFFLINE\n");
            node_ready = false;
            break;
        case ZTS_EVENT_NETWORK_READY_IP4:
            printf("ZTS_EVENT_NETWORK_READY_IP4, networkId=%lx\n", msg->network->nwid);
            network_ready = true;
            break;
        case ZTS_EVENT_PEER_P2P:
            printf("ZTS_EVENT_PEER_P2P, nodeId=%lx\n", msg->peer->address);
            break;
        case ZTS_EVENT_PEER_RELAY:
            printf("ZTS_EVENT_PEER_RELAY, nodeId=%lx\n", msg->peer->address);
            break;
        default:
            printf("Unknown event code received (%d).\n", msg->eventCode);
            break;
    }
}

int main()
{
    int port = ZTS_DEFAULT_PORT;
    uint64_t nwid = 0xe5cd7a9e1c21a60f;
    int connectionTimeout = 3600;

    zts_start("creds", &myZeroTierEventCallback, port);
    printf("Waiting for node to come online...\n");
    while (!node_ready) { printf("Node not ready yet...\n"); sleep(1); }

    zts_join(nwid);
    printf("Joined virtual network. Requesting configuration...\n");
    while (!network_ready) { printf("Network not ready yet...\n"); sleep(1); }

    printf("Network configured. Staying online for %d seconds more...\n", connectionTimeout);
    sleep(connectionTimeout);

    printf("Disconnecting...\n");
    zts_stop();

    return 0;
}