session server REFACTOR move ch thread data to ch_client

Move Call Home thread data from global server_opts.ch_threads array
to individual ch_client->thread pointer. This simplifies thread
management by eliminating the separate ch_threads_lock and array
manipulation. Each ch_client now directly owns its thread data,
making the lifecycle management more straightforward.

Author: Roytak

src/server_config.c

@@ -5350,10 +5350,9 @@ nc_server_config_reconcile_chclients_dispatch(struct nc_server_config *old_cfg,
 {
     int rc = 0;
     struct nc_ch_client *old_ch_client, *new_ch_client;
-    struct nc_server_ch_thread_arg **ch_thread_arg;
     int found;
-    LY_ARRAY_COUNT_TYPE i = 0;
-    char **started_clients = NULL, **client_name = NULL;
+    LY_ARRAY_COUNT_TYPE i;
+    struct nc_ch_client **started_clients = NULL, **started_client_ptr;
     int dispatch_new_clients = 1;
 
     if (!server_opts.ch_dispatch_data.acquire_ctx_cb || !server_opts.ch_dispatch_data.release_ctx_cb ||
@@ -5369,48 +5368,28 @@ nc_server_config_reconcile_chclients_dispatch(struct nc_server_config *old_cfg,
     /*
      * == PHASE 1: START NEW CLIENTS ==
      * Start clients present in new_cfg that are not already running.
-     * Track successfully started clients for potential rollback.
+     * Track successfully started threads for potential rollback.
      */
     if (dispatch_new_clients) {
         /* only dispatch if all required CBs are set */
         LY_ARRAY_FOR(new_cfg->ch_clients, struct nc_ch_client, new_ch_client) {
-            found = 0;
-
-            /* CH THREADS LOCK (reading server_opts.ch_threads) */
-            if (nc_rwlock_lock(&server_opts.ch_threads_lock, NC_RWLOCK_READ, NC_CH_THREADS_LOCK_TIMEOUT, __func__) != 1) {
-                rc = 1;
-                goto rollback;
+            if (new_ch_client->thread) {
+                /* already running */
+                continue;
             }
 
-            LY_ARRAY_FOR(server_opts.ch_threads, struct nc_server_ch_thread_arg *, ch_thread_arg) {
-                if (!strcmp(new_ch_client->name, (*ch_thread_arg)->client_name)) {
-                    /* already running, do not start again */
-                    found = 1;
-                    break;
-                }
+            /* this is a new Call Home client, dispatch it */
+            rc = _nc_connect_ch_client_dispatch(new_ch_client, server_opts.ch_dispatch_data.acquire_ctx_cb,
+                    server_opts.ch_dispatch_data.release_ctx_cb, server_opts.ch_dispatch_data.ctx_cb_data,
+                    server_opts.ch_dispatch_data.new_session_cb, server_opts.ch_dispatch_data.new_session_cb_data);
+            if (rc) {
+                /* FAILURE! trigger rollback */
+                goto rollback;
             }
 
-            /* CH THREADS UNLOCK */
-            nc_rwlock_unlock(&server_opts.ch_threads_lock, __func__);
-
-            if (!found) {
-                /* this is a new Call Home client, dispatch it */
-                rc = _nc_connect_ch_client_dispatch(new_ch_client, server_opts.ch_dispatch_data.acquire_ctx_cb,
-                        server_opts.ch_dispatch_data.release_ctx_cb, server_opts.ch_dispatch_data.ctx_cb_data,
-                        server_opts.ch_dispatch_data.new_session_cb, server_opts.ch_dispatch_data.new_session_cb_data);
-                if (rc) {
-                    /* FAILURE! trigger rollback */
-                    goto rollback;
-                }
-
-                /* successfully started, track it for potential rollback */
-                LY_ARRAY_NEW_GOTO(NULL, started_clients, client_name, rc, rollback);
-                *client_name = strdup(new_ch_client->name);
-                NC_CHECK_ERRMEM_GOTO(!*client_name, rc = 1, rollback);
-
-                /* ownership transferred to array */
-                client_name = NULL;
-            }
+            /* successfully started, track client for potential rollback */
+            LY_ARRAY_NEW_GOTO(NULL, started_clients, started_client_ptr, rc, rollback);
+            *started_client_ptr = new_ch_client;
         }
     }
 
@@ -5428,9 +5407,9 @@ nc_server_config_reconcile_chclients_dispatch(struct nc_server_config *old_cfg,
             }
         }
 
-        if (!found) {
+        if (!found && old_ch_client->thread) {
             /* this Call Home client was deleted, notify it to stop */
-            if ((rc = nc_session_server_ch_client_dispatch_stop_if_dispatched(old_ch_client->name, NC_RWLOCK_WRITE))) {
+            if ((rc = nc_session_server_ch_client_dispatch_stop(old_ch_client))) {
                 ERR(NULL, "Failed to dispatch stop for Call Home client \"%s\".", old_ch_client->name);
                 goto rollback;
             }
@@ -5448,15 +5427,12 @@ nc_server_config_reconcile_chclients_dispatch(struct nc_server_config *old_cfg,
      * to return to the pre-call state.
      */
     LY_ARRAY_FOR(started_clients, i) {
-        nc_session_server_ch_client_dispatch_stop_if_dispatched(started_clients[i], NC_RWLOCK_WRITE);
+        nc_session_server_ch_client_dispatch_stop(started_clients[i]);
     }
     /* rc is already set to non-zero from the failure point */
 
 cleanup:
-    /* free the tracking list and its contents */
-    LY_ARRAY_FOR(started_clients, i) {
-        free(started_clients[i]);
-    }
+    /* free the tracking list */
     LY_ARRAY_FREE(started_clients);
     return rc;
 }
@@ -6073,6 +6049,8 @@ nc_server_config_dup(const struct nc_server_config *src, struct nc_server_config
         dst_ch_client->max_attempts = src_ch_client->max_attempts;
         dst_ch_client->max_wait = src_ch_client->max_wait;
 
+        dst_ch_client->thread = src_ch_client->thread;
+
         LY_ARRAY_INCREMENT(dst->ch_clients);
     }
 

src/session_p.h

@@ -753,6 +753,8 @@ struct nc_server_config {
         NC_CH_START_WITH start_with;        /**< How to select the Call Home endpoint to connect to. */
         uint8_t max_attempts;               /**< Maximum number of attempts to connect to the given Call Home endpoint. */
         uint16_t max_wait;                  /**< Maximum time to wait for a Call Home connection in seconds. */
+
+        struct nc_server_ch_thread_arg *thread; /**< Call Home client thread data, if dispatched. */
     } *ch_clients;                          /**< Call Home clients (sized-array, see libyang docs). */
 
 #ifdef NC_ENABLED_SSH_TLS
@@ -784,11 +786,6 @@ struct nc_server_opts {
     void *content_id_data;                      /**< Data passed to the content_id_clb callback. */
     void (*content_id_data_free)(void *data);   /**< Callback to free the content_id_data. */
 
-    /* ACCESS locked - call home thread creation/deletion - WRITE lock
-     *               - call home threads data access (e.g. to signal thread to end) - READ lock */
-    pthread_rwlock_t ch_threads_lock;  /**< Lock for data of Call Home threads. */
-    struct nc_server_ch_thread_arg **ch_threads;  /**< Call Home threads' data, one for each CH client (sized-array, see libyang docs). */
-
     /* ACCESS locked - options modified by YANG data/API - WRITE lock
      *               - options read when accepting sessions - READ lock */
     pthread_rwlock_t config_lock;       /**< Lock for the server configuration. */
@@ -1389,20 +1386,19 @@ NC_MSG_TYPE nc_connect_callhome(const char *host, uint16_t port, NC_TRANSPORT_IM
 #ifdef NC_ENABLED_SSH_TLS
 
 /**
- * @brief Stop a dispatched Call Home client thread, if such thread was dispatched for the given client name.
+ * @brief Stop a dispatched Call Home client thread, if such thread was dispatched for the given client.
+ *
+ * @warning The caller MUST hold both WRITE config lock and CONFIG APPLY mutex when calling this function.
  *
- * @param[in] client_name Name of the Call Home client to stop the thread for.
- * @param[in] config_lock_mode Lock mode of the configuration lock, if it is held by the caller.
- * If NC_RWLOCK_WRITE is passed, config lock will be briefly unlocked and then locked again.
- * The caller MUST ensure that it holds the CONFIG APPLY mutex, so that nobody steals the wrlock from him.
- * @return 0 if the thread was successfully stopped or not found, 1 on error.
+ * @param[in] ch_client Call Home client to stop the thread for, can be NULL.
+ * @return 0 if the thread was successfully stopped, 1 on error.
  */
-int nc_session_server_ch_client_dispatch_stop_if_dispatched(const char *client_name, enum nc_rwlock_mode config_lock_mode);
+int nc_session_server_ch_client_dispatch_stop(struct nc_ch_client *ch_client);
 
 /**
  * @brief Dispatch a thread connecting to a listening NETCONF client and creating Call Home sessions.
  *
- * @note The config lock MUST be held.
+ * @note The config WRITE lock MUST be held.
  *
  * @param[in] ch_client Call Home client to dispatch the thread for.
  * @param[in] acquire_ctx_cb Callback for acquiring new session context.
@@ -1412,7 +1408,7 @@ int nc_session_server_ch_client_dispatch_stop_if_dispatched(const char *client_n
  * @param[in] new_session_cb_data Arbitrary user data passed to @p new_session_cb.
  * @return 0 if the thread was successfully created, -1 on error.
  */
-int _nc_connect_ch_client_dispatch(const struct nc_ch_client *ch_client, nc_server_ch_session_acquire_ctx_cb acquire_ctx_cb,
+int _nc_connect_ch_client_dispatch(struct nc_ch_client *ch_client, nc_server_ch_session_acquire_ctx_cb acquire_ctx_cb,
         nc_server_ch_session_release_ctx_cb release_ctx_cb, void *ctx_cb_data, nc_server_ch_new_session_cb new_session_cb,
         void *new_session_cb_data);