ziti-sdk-c/inc_internal/ziti_ctrl.h at 10a2f430143d530a0431b99c0f107297b76cc4e8 · openziti/ziti-sdk-c · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
// Copyright (c) 2019-2026.  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_SDK_CONTROLLER_H
#define ZITI_SDK_CONTROLLER_H

#include <tlsuv/http.h>
#include "internal_model.h"
#include "ziti/ziti_model.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef void (*ziti_ctrl_redirect_cb)(const char *new_address, void *ctx);

typedef void (*ziti_ctrl_change_cb)(void *ctx, const model_map *endpoints);

typedef void (*ctrl_version_cb)(const ziti_version *, const ziti_error *, void *);

typedef void(*routers_cb)(ziti_service_routers *srv_routers, const ziti_error *, void *);

typedef struct ziti_controller_s {
    uv_loop_t *loop;
    tlsuv_http_t *client;

    char *url;
    model_map endpoints;

    unsigned int active_reqs;

    // tuning options
    unsigned int page_size;

    bool legacy;
    bool is_ha;
    ziti_version version;
    ctrl_version_cb version_cb;
    void *version_cb_ctx;
    void *version_req;

    bool has_token;
    char *instance_id;

    ziti_ctrl_change_cb change_cb;
    ziti_ctrl_redirect_cb redirect_cb;
    void *cb_ctx;
} ziti_controller;

int ziti_ctrl_init(uv_loop_t *loop, ziti_controller *ctrl, model_list *urls, tls_context *tls);

int ziti_ctrl_set_token(ziti_controller *ctrl, const char *access_token);
int ziti_ctrl_set_ext_token(ziti_controller *ctrl, const char *jwt);

void ziti_ctrl_set_legacy(ziti_controller *ctrl, bool legacy);

int ziti_ctrl_cancel(ziti_controller *ctrl);

void ziti_ctrl_set_page_size(ziti_controller *ctrl, unsigned int size);

void ziti_ctrl_set_callbacks(ziti_controller *ctrl, void *ctx,
                             ziti_ctrl_redirect_cb redirect_cb,
                             ziti_ctrl_change_cb change_cb);

int ziti_ctrl_close(ziti_controller *ctrl);

void ziti_ctrl_clear_auth(ziti_controller *ctrl);

void ziti_ctrl_get_version(ziti_controller *ctrl, ctrl_version_cb cb, void *ctx);

void ziti_ctrl_list_ext_jwt_signers(ziti_controller *ctrl,
                                    void (*cb)(ziti_jwt_signer_array, const ziti_error*, void*),
                                    void *ctx);

void ziti_ctrl_get_network_jwt(ziti_controller *ctrl,
                               void(*cb)(ziti_network_jwt_array, const ziti_error*, void *ctx),
                               void *ctx);

void ziti_ctrl_list_controllers(ziti_controller *ctrl,
                                void (*cb)(ziti_controller_detail_array, const ziti_error*, void *ctx), void *ctx);

void ziti_ctrl_current_api_session(ziti_controller *ctrl, void(*cb)(ziti_api_session *, const ziti_error *, void *), void *ctx);

void ziti_ctrl_create_api_certificate(ziti_controller *ctrl, const char *csr_pem, void(*cb)(ziti_create_api_cert_resp *, const ziti_error *, void *), void *ctx);

void ziti_ctrl_current_identity(ziti_controller *ctrl, void(*cb)(ziti_identity_data *, const ziti_error *, void *), void *ctx);

void ziti_ctrl_current_edge_routers(ziti_controller *ctrl, void(*cb)(ziti_edge_router_array, const ziti_error *, void *),
                                    void *ctx);

void ziti_ctrl_logout(ziti_controller *ctrl, void(*cb)(void *, const ziti_error *, void *), void *ctx);

void ziti_ctrl_get_services_update(ziti_controller *ctrl, void (*cb)(ziti_service_update *, const ziti_error *, void *),
                                   void *ctx);

void ziti_ctrl_get_services(ziti_controller *ctrl, void (*srv_cb)(ziti_service_array, const ziti_error *, void *),
                            void *ctx);

void ziti_ctrl_get_service(ziti_controller *ctrl, const char *service_name,
                           void (*srv_cb)(ziti_service *, const ziti_error *, void *), void *ctx);

void ziti_ctrl_list_terminators(ziti_controller *ctrl, const char *service_id,
                                void (*cb)(const ziti_terminator_array, const ziti_error*, void *ctx), void *ctx);

void ziti_ctrl_list_service_routers(ziti_controller *ctrl, const ziti_service *srv, routers_cb, void *ctx);

void ziti_ctrl_create_session(
        ziti_controller *ctrl, const char *service_id, ziti_session_type type,
        void (*cb)(ziti_session *, const ziti_error *, void *), void *ctx);

void ziti_ctrl_get_session(
        ziti_controller *ctrl, const char *session_id,
        void (*cb)(ziti_session *, const ziti_error *, void *), void *ctx);

void ziti_ctrl_get_well_known_certs(ziti_controller *ctrl, void (*cb)(char *, const ziti_error *, void *), void *ctx);

void ziti_ctrl_enroll(ziti_controller *ctrl, ziti_enrollment_method method, const char *token, const char *csr,
                      const char *name,
                      void (*cb)(ziti_enrollment_resp *, const ziti_error *, void *), void *ctx);

void ziti_ctrl_enroll_token(ziti_controller *ctrl, const char *token, const char *csr,
                            void (*cb)(ziti_create_api_cert_resp *, const ziti_error *, void *), void *ctx);

//Posture
void ziti_pr_post_bulk(ziti_controller *ctrl, char *body, size_t body_len, void(*cb)(ziti_pr_response *, const ziti_error *, void *), void *ctx);

void ziti_pr_post(ziti_controller *ctrl, char *body, size_t body_len, void(*cb)(ziti_pr_response *, const ziti_error *, void *), void *ctx);

void ziti_ctrl_post_mfa(ziti_controller *ctrl, void(*cb)(void *, const ziti_error *, void *), void *ctx);

void ziti_ctrl_get_mfa(ziti_controller *ctrl, void(*cb)(ziti_mfa_enrollment *, const ziti_error *, void *), void *ctx);

void ziti_ctrl_delete_mfa(ziti_controller *ctrl, char *code, void(*cb)(void *, const ziti_error *, void *), void *ctx);

void ziti_ctrl_post_mfa_verify(ziti_controller *ctrl, char *body, size_t body_len, void(*cb)(void *, const ziti_error *, void *), void *ctx);

void ziti_ctrl_get_mfa_recovery_codes(ziti_controller *ctrl, char *code, void(*cb)(ziti_mfa_recovery_codes *, const ziti_error *, void *), void *ctx);

void ziti_ctrl_post_mfa_recovery_codes(ziti_controller *ctrl, char *body, size_t body_len, void(*cb)(void *, const ziti_error *, void *), void *ctx);

//Authenticators

void ziti_ctrl_extend_cert_authenticator(ziti_controller *ctrl, const char *authenticatorId, const char *csr, void(*cb)(ziti_extend_cert_authenticator_resp*, const ziti_error *, void *), void *ctx);

void ziti_ctrl_verify_extend_cert_authenticator(ziti_controller *ctrl, const char *authenticatorId, const char *client_cert, void(*cb)(void *, const ziti_error *, void *), void *ctx);

#ifdef __cplusplus
}
#endif

#endif //ZITI_SDK_CONTROLLER_H