ziti.h

Go to the documentation of this file.

// Copyright (c) 2022-2024. NetFoundry Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
//
// You may obtain a copy of the License at
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#ifndef ZITI_ZITI_H
#define ZITI_ZITI_H
 
#include <stdint.h>
#include <tlsuv/tlsuv.h>
#include <uv.h>
#include "errors.h"
 
#include "externs.h"
#include "ziti_model.h"
#include "enums.h"
#include "ziti_events.h"
#include "enroll.h"
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define ZITI_CAN_DIAL 1U
 
#define ZITI_CAN_BIND 2U
 
#define ZITI_DEFAULT_TIMEOUT 10000
 
typedef struct ziti_ctx *ziti_context;
 
typedef struct ziti_conn *ziti_connection;
 
typedef void (*ziti_service_cb)(ziti_context ztx, const ziti_service *, int status, void *data);
 
typedef void (*ziti_terminator_cb)(ziti_context ztx, const ziti_terminator* const * terminators , int status, void *ctx);
 
typedef void (*ziti_pr_mac_cb)(ziti_context ztx, const char *id, char **mac_addresses, int num_mac);
 
typedef void (*ziti_pq_mac_cb)(ziti_context ztx, const char *id, ziti_pr_mac_cb response_cb);
 
typedef void (*ziti_pr_domain_cb)(ziti_context ztx, const char *id, const char *domain);
 
typedef void (*ziti_pq_domain_cb)(ziti_context ztx, const char *id, ziti_pr_domain_cb response_cb);
 
typedef void (*ziti_pr_os_cb)(ziti_context ztx, const char *id, const char *os_type, const char *os_version, const char *os_build);
 
typedef void (*ziti_pq_os_cb)(ziti_context ztx, const char *id, ziti_pr_os_cb response_cb);
 
 
typedef void(*ziti_pr_process_cb)(ziti_context ztx, const char *id, const char *path, bool is_running,
                                  const char *sha_512_hash, char **signers, int num_signers);
 
typedef void (*ziti_pq_process_cb)(ziti_context ztx, const char *id, const char *path,
                                   ziti_pr_process_cb response_cb);
 
typedef void (*ziti_event_cb)(ziti_context ztx, const ziti_event_t *event);
 
typedef struct ziti_options_s {
    bool disabled; // if true initial state will be disabled
    const char **config_types;
    ziti_crypto_method e2ee_mode;
 
    unsigned int api_page_size;
    long refresh_interval; //the duration in seconds between checking for updates from the controller
    rate_type metrics_type; //an enum describing the metrics to collect
 
    //posture query cbs
    ziti_pq_mac_cb pq_mac_cb;
    ziti_pq_os_cb pq_os_cb;
    ziti_pq_process_cb pq_process_cb;
    ziti_pq_domain_cb pq_domain_cb;
 
    void *app_ctx;
 
    unsigned int events;
 
    ziti_event_cb event_cb;
 
    unsigned int cert_extension_window;
 
    ziti_enroll_mode enroll_mode;
} ziti_options;
 
typedef struct ziti_dial_opts_s {
    bool stream;
    int connect_timeout_seconds;
    const char *identity;
    const char *group;
    void *app_data;
    size_t app_data_sz;
} ziti_dial_opts;
 
typedef struct ziti_client_ctx_s {
    char *caller_id;
    const uint8_t *app_data;
    size_t app_data_sz;
} ziti_client_ctx;
 
 
typedef struct ziti_listen_opts_s {
    uint16_t terminator_cost;
    uint8_t terminator_precedence;
    int connect_timeout_seconds;
    int max_connections;
    char *identity;
    bool bind_using_edge_identity;
} ziti_listen_opts;
 
typedef ssize_t (*ziti_data_cb)(ziti_connection conn, const uint8_t *data, ssize_t length);
 
typedef void (*ziti_conn_cb)(ziti_connection conn, int status);
 
typedef void (*ziti_client_cb)(ziti_connection serv, ziti_connection client, int status, const ziti_client_ctx *ctx);
 
typedef ziti_conn_cb ziti_listen_cb;
 
typedef void (*ziti_write_cb)(ziti_connection conn, ssize_t status, void *write_ctx);
 
 
 
typedef void (*ziti_close_cb)(ziti_connection conn);
 
ZITI_FUNC
extern void ziti_set_app_info(const char *app_id, const char *app_version);
 
ZITI_FUNC
extern void ziti_set_device_id(const char *device_id);
 
ZITI_FUNC
extern void ziti_set_hostname(const char *hostname);
 
ZITI_FUNC
extern int ziti_load_config(ziti_config *config, const char* conf_str);
 
ZITI_FUNC
extern int ziti_context_init(ziti_context *ztx, const ziti_config *config);
 
ZITI_FUNC
extern int ziti_context_set_options(ziti_context ztx, const ziti_options *options);
 
ZITI_FUNC
extern int ziti_context_run(ziti_context ztx, uv_loop_t *loop);
 
ZITI_FUNC
extern int ziti_refresh(ziti_context ztx);
 
ZITI_FUNC
extern bool ziti_is_enabled(ziti_context ztx);
 
ZITI_FUNC
extern void ziti_set_enabled(ziti_context ztx, bool enabled);
 
ZITI_FUNC
extern void *ziti_app_ctx(ziti_context ztx);
 
ZITI_FUNC
extern void ziti_set_app_ctx(ziti_context ztx, void *app_ctx);
 
ZITI_FUNC
extern const ziti_version *ziti_get_version();
 
ZITI_FUNC
extern const ziti_version *ziti_get_controller_version(ziti_context ztx);
 
ZITI_FUNC
extern const char *ziti_get_controller(ziti_context ztx);
 
ZITI_FUNC
extern const ziti_identity *ziti_get_identity(ziti_context ztx);
 
 
typedef void (*ziti_ext_signers_cb)(ziti_context, int err, ziti_jwt_signer_array, void*);
 
ZITI_FUNC
extern int ziti_get_ext_jwt_signers(ziti_context ztx, ziti_ext_signers_cb cb, void *ctx);
 
ZITI_FUNC
extern int ziti_use_ext_jwt_signer(ziti_context ztx, const char *name);
 
ZITI_FUNC
extern int ziti_get_transfer_rates(ziti_context ztx, double *up, double *down);
 
ZITI_FUNC
extern int ziti_shutdown(ziti_context ztx);
 
ZITI_FUNC
extern void ziti_dump(ziti_context ztx, int (*printer)(void *ctx, const char *fmt, ...), void *ctx);
 
ZITI_FUNC
const char *ziti_get_appdata_raw(ziti_context ztx, const char *key);
 
ZITI_FUNC
int ziti_get_appdata(ziti_context ztx, const char *key, void *data,
                     int (*parse_func)(void *, const char *, size_t));
 
ZITI_FUNC
extern int ziti_conn_init(ziti_context ztx, ziti_connection *conn, void *data);
 
ZITI_FUNC
extern ziti_context ziti_conn_context(ziti_connection conn);
 
ZITI_FUNC
extern void *ziti_conn_data(ziti_connection conn);
 
ZITI_FUNC
extern void ziti_conn_set_data(ziti_connection conn, void *data);
 
ZITI_FUNC
extern int ziti_conn_set_data_cb(ziti_connection conn, ziti_data_cb cb);
 
ZITI_FUNC
extern const char *ziti_conn_source_identity(ziti_connection conn);
 
ZITI_FUNC
extern int ziti_service_available(ziti_context ztx, const char *service, ziti_service_cb cb, void *ctx);
 
ZITI_FUNC
extern int ziti_list_terminators(ziti_context ztx, const char *service, ziti_terminator_cb cb, void *ctx);
 
ZITI_FUNC
extern const ziti_service *ziti_service_for_addr_str(ziti_context ztx, ziti_protocol proto, const char *addr, int port);
 
ZITI_FUNC
extern const ziti_service *ziti_service_for_addr(ziti_context ztx, ziti_protocol proto, const ziti_address *addr, int port);
 
ZITI_FUNC
extern const ziti_service* ziti_dial_opts_for_addr(ziti_dial_opts *opts, ziti_context ztx, ziti_protocol proto,
                                                   const char *dest_host, int dest_port,
                                                   const char *src_host, int src_port);
 
ZITI_FUNC
extern void ziti_dial_opts_free(ziti_dial_opts *opts);
ZITI_FUNC
extern int ziti_dial(ziti_connection conn, const char *service, ziti_conn_cb cb, ziti_data_cb data_cb);
 
ZITI_FUNC
extern int ziti_dial_with_options(ziti_connection conn, const char *service,
                                  const ziti_dial_opts *dial_opts,
                                  ziti_conn_cb cb, ziti_data_cb data_cb);
 
ZITI_FUNC
extern int ziti_listen(ziti_connection serv_conn, const char *service, ziti_listen_cb lcb, ziti_client_cb cb);
 
ZITI_FUNC
extern int ziti_listen_with_options(ziti_connection serv_conn, const char *service, ziti_listen_opts *listen_opts,
                                    ziti_listen_cb lcb, ziti_client_cb cb);
 
ZITI_FUNC
extern int ziti_accept(ziti_connection clt, ziti_conn_cb cb, ziti_data_cb data_cb);
 
ZITI_FUNC
extern int ziti_close(ziti_connection conn, ziti_close_cb close_cb);
 
ZITI_FUNC
extern int ziti_close_write(ziti_connection conn);
 
ZITI_FUNC
extern int ziti_write(ziti_connection conn, const uint8_t *data, size_t length, ziti_write_cb write_cb, void *write_ctx);
 
ZITI_FUNC
extern int ziti_conn_bridge(ziti_connection conn, uv_handle_t *handle, uv_close_cb on_close);
 
ZITI_FUNC
extern int ziti_conn_bridge_idle_timeout(ziti_connection conn, unsigned long millis);
 
ZITI_FUNC
extern int ziti_conn_bridge_fds(ziti_connection conn, uv_os_sock_t input, uv_os_sock_t output, void (*close_cb)(void *ctx), void *ctx);
 
typedef void (*ziti_mfa_enroll_cb)(ziti_context ztx, int status, ziti_mfa_enrollment *mfa_enrollment, void *ctx);
 
typedef void (*ziti_mfa_cb)(ziti_context ztx, int status, void *ctx);
 
typedef void (*ziti_ext_auth_launch_cb)(ziti_context ztx, const char *url, void *ctx);
 
typedef struct ziti_auth_query_param_s {
    const char *name;
    const char *value;
} ziti_auth_query_param;
 
typedef void (*ziti_mfa_recovery_codes_cb)(ziti_context ztx, int status, const char **recovery_codes, void *ctx);
 
ZITI_FUNC
extern void ziti_mfa_enroll(ziti_context ztx, ziti_mfa_enroll_cb enroll_cb, void *ctx);
 
ZITI_FUNC
extern void ziti_mfa_remove(ziti_context ztx, const char *code, ziti_mfa_cb remove_cb, void *ctx);
 
ZITI_FUNC
extern void ziti_mfa_verify(ziti_context ztx, char *code, ziti_mfa_cb verify_cb, void *ctx);
 
 
ZITI_FUNC
extern void ziti_mfa_get_recovery_codes(ziti_context ztx, const char *code, ziti_mfa_recovery_codes_cb get_cb, void *ctx);
 
ZITI_FUNC
extern void ziti_mfa_new_recovery_codes(ziti_context ztx, char *code, ziti_mfa_recovery_codes_cb new_cb, void *ctx);
 
ZITI_FUNC
extern void ziti_mfa_auth(ziti_context ztx, const char *code, ziti_mfa_cb auth_cb, void *ctx);
 
ZITI_FUNC
extern int ziti_ext_auth(ziti_context ztx, ziti_ext_auth_launch_cb launch_cb, void *ctx);
 
ZITI_FUNC
extern int ziti_ext_auth_set_params(ziti_context ztx, const ziti_auth_query_param *params, int count);
 
ZITI_FUNC
extern int ziti_ext_auth_token(ziti_context ztx, const char *token);
 
typedef int (*ziti_enroll_key_cb)(ziti_context ztx, char **key_pem, void *ctx);
 
ZITI_FUNC
extern void ziti_set_enroll_key_cb(ziti_context ztx, ziti_enroll_key_cb cb, void *ctx);
 
ZITI_FUNC
extern void ziti_endpoint_state_change(ziti_context ztx, bool woken, bool unlocked);
 
typedef void (*ziti_extend_cert_authenticator_cb)(ziti_context ztx, const char* cert_pem, int status, void *ctx);
 
ZITI_FUNC
extern int ziti_extend_cert_authenticator(ziti_context ztx, const char *csr_pem, ziti_extend_cert_authenticator_cb cb, void *ctx);
 
typedef void (*ziti_verify_extend_cert_authenticator_cb)(ziti_context ztx, int status, void *ctx);
 
ZITI_FUNC
extern int ziti_verify_extend_cert_authenticator(ziti_context ztx, const char *new_cert, ziti_verify_extend_cert_authenticator_cb cb, void *ctx);
 
ZITI_FUNC
extern int ziti_set_client_cert(ziti_context ztx, const char *cert_buf, size_t cert_len, const char *key_buf, size_t key_len);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZITI_ZITI_H */