daemon: rename tls_ctx and tls_client_ctx structs

The trailing _t implies the type is a typedef like:

typedef struct tls_ctx {
...
} tls_ctx_t;

But it is a plain struct - so remove it to avoid confusion.

diff --git a/daemon/io.c b/daemon/io.c
index 902b45759bc510fe01b1d1c1f4bf7074aef6ee53..48d2640780742fc888c68fe5c052c4dae6f2ea0f 100644 (file)
--- a/daemon/io.c
+++ b/daemon/io.c
@@ -374,7 +374,7 @@ static void _tcp_accept(uv_stream_t *master, int status, bool tls)
        uint64_t timeout = KR_CONN_RTT_MAX / 2;
        if (tls) {
                timeout += TLS_MAX_HANDSHAKE_TIME;
-               struct tls_ctx_t *ctx = session_tls_get_server_ctx(s);
+               struct tls_ctx *ctx = session_tls_get_server_ctx(s);
                if (!ctx) {
                        ctx = tls_new(worker);
                        if (!ctx) {

diff --git a/daemon/io.h b/daemon/io.h
index eec5dd55b49e6852d4966552cb214bab631beac2..15d2e70bebbd046d5ea76b7db30c03091b5dcae9 100644 (file)
--- a/daemon/io.h
+++ b/daemon/io.h
@@ -12,8 +12,8 @@
 #include "daemon/worker.h"
 #include "daemon/engine.h"
 
-struct tls_ctx_t;
-struct tls_client_ctx_t;
+struct tls_ctx;
+struct tls_client_ctx;
 
 /** Bind address into a file-descriptor (only, no libuv).  type is e.g. SOCK_DGRAM */
 int io_bind(const struct sockaddr *addr, int type, const endpoint_flags_t *flags);

diff --git a/daemon/session.c b/daemon/session.c
index dc60cc8a154e44f789ec2ae7aed76bbc104e52dd..606b1399262bd2d4dc3813a920fa42ceaf61a77e 100644 (file)
--- a/daemon/session.c
+++ b/daemon/session.c
@@ -29,8 +29,8 @@ struct session {
        uv_handle_t *handle;          /**< libuv handle for IO operations. */
        uv_timer_t timeout;           /**< libuv handle for timer. */
 
-       struct tls_ctx_t *tls_ctx;    /**< server side tls-related data. */
-       struct tls_client_ctx_t *tls_client_ctx; /**< client side tls-related data. */
+       struct tls_ctx *tls_ctx;      /**< server side tls-related data. */
+       struct tls_client_ctx *tls_client_ctx;  /**< client side tls-related data. */
 
        trie_t *tasks;                /**< list of tasks assotiated with given session. */
        queue_t(struct qr_task *) waiting;  /**< list of tasks waiting for sending to upstream. */
@@ -257,22 +257,22 @@ struct sockaddr *session_get_sockname(struct session *session)
        return &session->sockname.ip;
 }
 
-struct tls_ctx_t *session_tls_get_server_ctx(const struct session *session)
+struct tls_ctx *session_tls_get_server_ctx(const struct session *session)
 {
        return session->tls_ctx;
 }
 
-void session_tls_set_server_ctx(struct session *session, struct tls_ctx_t *ctx)
+void session_tls_set_server_ctx(struct session *session, struct tls_ctx *ctx)
 {
        session->tls_ctx = ctx;
 }
 
-struct tls_client_ctx_t *session_tls_get_client_ctx(const struct session *session)
+struct tls_client_ctx *session_tls_get_client_ctx(const struct session *session)
 {
        return session->tls_client_ctx;
 }
 
-void session_tls_set_client_ctx(struct session *session, struct tls_client_ctx_t *ctx)
+void session_tls_set_client_ctx(struct session *session, struct tls_client_ctx *ctx)
 {
        session->tls_client_ctx = ctx;
 }
@@ -521,7 +521,7 @@ knot_pkt_t *session_produce_packet(struct session *session, knot_mm_t *mm)
                session->wire_buf_end_idx = 0;
                return NULL;
        }
-       
+
        if (session->wire_buf_start_idx > session->wire_buf_end_idx) {
                session->sflags.wirebuf_error = true;
                session->wire_buf_start_idx = 0;
@@ -533,7 +533,7 @@ knot_pkt_t *session_produce_packet(struct session *session, knot_mm_t *mm)
        uint8_t *msg_start = &session->wire_buf[session->wire_buf_start_idx];
        ssize_t wirebuf_msg_data_size = session->wire_buf_end_idx - session->wire_buf_start_idx;
        uint16_t msg_size = 0;
-       
+
        if (!handle) {
                session->sflags.wirebuf_error = true;
                return NULL;
@@ -636,7 +636,7 @@ int session_discard_packet(struct session *session, const knot_pkt_t *pkt)
                session->wire_buf_start_idx += pkt_msg_size;
        }
        session->sflags.wirebuf_error = false;
-       
+
        wirebuf_data_size = session->wire_buf_end_idx - session->wire_buf_start_idx;
        if (wirebuf_data_size == 0) {
                session_wirebuf_discard(session);

diff --git a/daemon/session.h b/daemon/session.h
index 8750335d23dd2c8248dfd11766e7d159e0461c9f..0de2b3aa31f2fe6f3d56af677af54ed2d7db4bce 100644 (file)
--- a/daemon/session.h
+++ b/daemon/session.h
@@ -84,13 +84,13 @@ struct sockaddr *session_get_peer(struct session *session);
 /** Get pointer to sockname (address of our end, not meaningful for UDP downstream). */
 struct sockaddr *session_get_sockname(struct session *session);
 /** Get pointer to server-side tls-related data. */
-struct tls_ctx_t *session_tls_get_server_ctx(const struct session *session);
+struct tls_ctx *session_tls_get_server_ctx(const struct session *session);
 /** Set pointer to server-side tls-related data. */
-void session_tls_set_server_ctx(struct session *session, struct tls_ctx_t *ctx);
+void session_tls_set_server_ctx(struct session *session, struct tls_ctx *ctx);
 /** Get pointer to client-side tls-related data. */
-struct tls_client_ctx_t *session_tls_get_client_ctx(const struct session *session);
+struct tls_client_ctx *session_tls_get_client_ctx(const struct session *session);
 /** Set pointer to client-side tls-related data. */
-void session_tls_set_client_ctx(struct session *session, struct tls_client_ctx_t *ctx);
+void session_tls_set_client_ctx(struct session *session, struct tls_client_ctx *ctx);
 /** Get pointer to that part of tls-related data which has common structure for 
  *  server and client. */
 struct tls_common_ctx *session_tls_get_common_ctx(const struct session *session);

diff --git a/daemon/tls.c b/daemon/tls.c
index 1c69a4b9dd0334ea11fb2aa252b94f04412b9acf..43787f63ad6cc375bef29e92babd6dc4a93f3ece 100644 (file)
--- a/daemon/tls.c
+++ b/daemon/tls.c
@@ -272,7 +272,7 @@ static int tls_handshake(struct tls_common_ctx *ctx, tls_handshake_cb handshake_
 }
 
 
-struct tls_ctx_t *tls_new(struct worker_ctx *worker)
+struct tls_ctx *tls_new(struct worker_ctx *worker)
 {
        assert(worker != NULL);
        assert(worker->engine != NULL);
@@ -311,7 +311,7 @@ struct tls_ctx_t *tls_new(struct worker_ctx *worker)
                }
        }
 
-       struct tls_ctx_t *tls = calloc(1, sizeof(struct tls_ctx_t));
+       struct tls_ctx *tls = calloc(1, sizeof(struct tls_ctx));
        if (tls == NULL) {
                kr_log_error("[tls] failed to allocate TLS context\n");
                return NULL;
@@ -369,7 +369,7 @@ void tls_close(struct tls_common_ctx *ctx)
        }
 }
 
-void tls_free(struct tls_ctx_t *tls)
+void tls_free(struct tls_ctx *tls)
 {
        if (!tls) {
                return;
@@ -1015,7 +1015,7 @@ static int client_verify_certchain(gnutls_session_t tls_session, const char *hos
  */
 static int client_verify_certificate(gnutls_session_t tls_session)
 {
-       struct tls_client_ctx_t *ctx = gnutls_session_get_ptr(tls_session);
+       struct tls_client_ctx *ctx = gnutls_session_get_ptr(tls_session);
        assert(ctx->params != NULL);
 
        if (ctx->params->insecure) {
@@ -1043,10 +1043,10 @@ static int client_verify_certificate(gnutls_session_t tls_session)
                return client_verify_certchain(ctx->c.tls_session, ctx->params->hostname);
 }
 
-struct tls_client_ctx_t *tls_client_ctx_new(tls_client_param_t *entry,
+struct tls_client_ctx *tls_client_ctx_new(tls_client_param_t *entry,
                                            struct worker_ctx *worker)
 {
-       struct tls_client_ctx_t *ctx = calloc(1, sizeof (struct tls_client_ctx_t));
+       struct tls_client_ctx *ctx = calloc(1, sizeof (struct tls_client_ctx));
        if (!ctx) {
                return NULL;
        }
@@ -1095,7 +1095,7 @@ struct tls_client_ctx_t *tls_client_ctx_new(tls_client_param_t *entry,
        return ctx;
 }
 
-void tls_client_ctx_free(struct tls_client_ctx_t *ctx)
+void tls_client_ctx_free(struct tls_client_ctx *ctx)
 {
        if (ctx == NULL) {
                return;
@@ -1126,7 +1126,7 @@ int  tls_pull_timeout_func(gnutls_transport_ptr_t h, unsigned int ms)
        return avail;
 }
 
-int tls_client_connect_start(struct tls_client_ctx_t *client_ctx,
+int tls_client_connect_start(struct tls_client_ctx *client_ctx,
                             struct session *session,
                             tls_handshake_cb handshake_cb)
 {
@@ -1176,7 +1176,7 @@ int tls_set_hs_state(struct tls_common_ctx *ctx, tls_hs_state_t state)
        return kr_ok();
 }
 
-int tls_client_ctx_set_session(struct tls_client_ctx_t *ctx, struct session *session)
+int tls_client_ctx_set_session(struct tls_client_ctx *ctx, struct session *session)
 {
        if (!ctx) {
                return kr_error(EINVAL);

diff --git a/daemon/tls.h b/daemon/tls.h
index c4f4dfb49463cd2ea35e977b8b49613bdd62318d..8417bf0cc168c3fda971c90336a2a0e034eb6f95 100644 (file)
--- a/daemon/tls.h
+++ b/daemon/tls.h
@@ -34,8 +34,8 @@
 /** Transport session (opaque). */
 struct session;
 
-struct tls_ctx_t;
-struct tls_client_ctx_t;
+struct tls_ctx;
+struct tls_client_ctx;
 struct tls_credentials {
        int count;
        char *tls_cert;
@@ -125,9 +125,9 @@ struct tls_common_ctx {
        size_t write_queue_size;
 };
 
-struct tls_ctx_t {
+struct tls_ctx {
        /*
-        * Since pointer to tls_ctx_t needs to be casted
+        * Since pointer to tls_ctx needs to be casted
         * to  tls_ctx_common in some functions,
         * this field must be always at first position
         */
@@ -135,9 +135,9 @@ struct tls_ctx_t {
        struct tls_credentials *credentials;
 };
 
-struct tls_client_ctx_t {
+struct tls_client_ctx {
        /*
-        * Since pointer to tls_client_ctx_t needs to be casted
+        * Since pointer to tls_client_ctx needs to be casted
         * to  tls_ctx_common in some functions,
         * this field must be always at first position
         */
@@ -146,13 +146,13 @@ struct tls_client_ctx_t {
 };
 
 /*! Create an empty TLS context in query context */
-struct tls_ctx_t* tls_new(struct worker_ctx *worker);
+struct tls_ctx* tls_new(struct worker_ctx *worker);
 
 /*! Close a TLS context (call gnutls_bye()) */
 void tls_close(struct tls_common_ctx *ctx);
 
 /*! Release a TLS context */
-void tls_free(struct tls_ctx_t* tls);
+void tls_free(struct tls_ctx* tls);
 
 /*! Push new data to TLS context for sending */
 int tls_write(uv_write_t *req, uv_handle_t* handle, knot_pkt_t * pkt, uv_write_cb cb);
@@ -189,17 +189,17 @@ int tls_set_hs_state(struct tls_common_ctx *ctx, tls_hs_state_t state);
 
 
 /*! Allocate new client TLS context */
-struct tls_client_ctx_t *tls_client_ctx_new(tls_client_param_t *entry,
+struct tls_client_ctx *tls_client_ctx_new(tls_client_param_t *entry,
                                            struct worker_ctx *worker);
 
 /*! Free client TLS context */
-void tls_client_ctx_free(struct tls_client_ctx_t *ctx);
+void tls_client_ctx_free(struct tls_client_ctx *ctx);
 
-int tls_client_connect_start(struct tls_client_ctx_t *client_ctx,
+int tls_client_connect_start(struct tls_client_ctx *client_ctx,
                             struct session *session,
                             tls_handshake_cb handshake_cb);
 
-int tls_client_ctx_set_session(struct tls_client_ctx_t *ctx, struct session *session);
+int tls_client_ctx_set_session(struct tls_client_ctx *ctx, struct session *session);
 
 
 /* Session tickets, server side.  Implementation in ./tls_session_ticket-srv.c */

diff --git a/daemon/worker.c b/daemon/worker.c
index c4374c3a6979cffee9c65418b55c61bc1a3a6124..d28c26befdd52a8d567534a5e7c560b2299aa358 100644 (file)
--- a/daemon/worker.c
+++ b/daemon/worker.c
@@ -693,7 +693,7 @@ static int session_tls_hs_cb(struct session *session, int status)
        }
 
        /* handshake was completed successfully */
-       struct tls_client_ctx_t *tls_client_ctx = session_tls_get_client_ctx(session);
+       struct tls_client_ctx *tls_client_ctx = session_tls_get_client_ctx(session);
        tls_client_param_t *tls_params = tls_client_ctx->params;
        gnutls_session_t tls_session = tls_client_ctx->c.tls_session;
        if (gnutls_session_is_resumed(tls_session) != 0) {
@@ -888,7 +888,7 @@ static void on_connect(uv_connect_t *req, int status)
 
        int ret = kr_ok();
        if (session_flags(session)->has_tls) {
-               struct tls_client_ctx_t *tls_ctx = session_tls_get_client_ctx(session);
+               struct tls_client_ctx *tls_ctx = session_tls_get_client_ctx(session);
                ret = tls_client_connect_start(tls_ctx, session, session_tls_hs_cb);
                if (ret == kr_error(EAGAIN)) {
                        session_timer_stop(session);
@@ -1290,7 +1290,7 @@ static int tcp_task_make_connection(struct qr_task *task, const struct sockaddr
        struct worker_ctx *worker = ctx->worker;
 
        /* Check if there must be TLS */
-       struct tls_client_ctx_t *tls_ctx = NULL;
+       struct tls_client_ctx *tls_ctx = NULL;
        struct network *net = &worker->engine->net;
        tls_client_param_t *entry = tls_client_param_get(net->tls_client_params, addr);
        if (entry) {
@@ -1728,13 +1728,13 @@ int worker_end_tcp(struct session *session)
        worker_del_tcp_connected(the_worker, peer);
        session_flags(session)->connected = false;
 
-       struct tls_client_ctx_t *tls_client_ctx = session_tls_get_client_ctx(session);
+       struct tls_client_ctx *tls_client_ctx = session_tls_get_client_ctx(session);
        if (tls_client_ctx) {
                /* Avoid gnutls_bye() call */
                tls_set_hs_state(&tls_client_ctx->c, TLS_HS_NOT_STARTED);
        }
 
-       struct tls_ctx_t *tls_ctx = session_tls_get_server_ctx(session);
+       struct tls_ctx *tls_ctx = session_tls_get_server_ctx(session);
        if (tls_ctx) {
                /* Avoid gnutls_bye() call */
                tls_set_hs_state(&tls_ctx->c, TLS_HS_NOT_STARTED);