1 files changed, 79 insertions, 78 deletions

diff --git a/src/server_register.c b/src/server_register.c
index 1514c92..de333a5 100644
--- a/src/server_register.c
+++ b/src/server_register.c
@@ -21,12 +21,12 @@
 #include <string.h>
 #include <time.h>
 
-volatile UA_Boolean running = true;
+volatile UA_Boolean g_running = true;
 
 static void
-stopHandler (int sign)
+_s_stop_handler (int sign)
 {
-  running = false;
+  g_running = false;
 }
 
 /* ========================================================================
@@ -39,30 +39,30 @@ stopHandler (int sign)
  */
 typedef struct
 {
-  const char *appUri;
-  SecurityConfig sec;
-  AuthConfig auth;
-  int logLevel;
-} LdsClientParams;
+  const char *app_uri;
+  security_config sec;
+  auth_config auth;
+  int log_level;
+} lds_client_params;
 
 /**
- * Builds a fresh UA_ClientConfig from LdsClientParams.
+ * Builds a fresh UA_ClientConfig from lds_client_params.
  *
  * UA_Server_registerDiscovery / deregisterDiscovery consume (clear) the
  * client config, so a new one must be created before every call.
  */
 static UA_StatusCode
-makeLdsClientConfig (UA_ClientConfig *cc, const LdsClientParams *p)
+_s_make_lds_client_config (UA_ClientConfig *cc, const lds_client_params *p)
 {
   memset (cc, 0, sizeof (UA_ClientConfig));
   UA_StatusCode rv;
-  if (p->sec.certPath)
-    rv = createSecureClientConfig (cc, p->appUri, &p->sec, &p->auth);
+  if (p->sec.cert_path)
+    rv = create_secure_client_config (cc, p->app_uri, &p->sec, &p->auth);
   else
-    rv = createUnsecureClientConfig (cc, p->appUri, &p->auth);
+    rv = create_unsecure_client_config (cc, p->app_uri, &p->auth);
   if (rv != UA_STATUSCODE_GOOD)
     return rv;
-  cc->logging->context = (void *)(uintptr_t)p->logLevel;
+  cc->logging->context = (void *)(uintptr_t)p->log_level;
   return UA_STATUSCODE_GOOD;
 }
 
@@ -73,8 +73,8 @@ makeLdsClientConfig (UA_ClientConfig *cc, const LdsClientParams *p)
 int
 main (int argc, char **argv)
 {
-  signal (SIGINT, stopHandler);
-  signal (SIGTERM, stopHandler);
+  signal (SIGINT, _s_stop_handler);
+  signal (SIGTERM, _s_stop_handler);
 
   if (argc < 4 || argc > 5)
     {
@@ -85,90 +85,90 @@ main (int argc, char **argv)
       return EXIT_FAILURE;
     }
 
-  const char *discoveryEndpoint = argv[3];
+  const char *discovery_endpoint = argv[3];
 
-  const char *logLevelStr = (argc == 5) ? argv[4] : "info";
-  int logLevel = parseLogLevel (logLevelStr);
-  if (logLevel < 0)
+  const char *log_level_str = (argc == 5) ? argv[4] : "info";
+  int log_level = parse_log_level (log_level_str);
+  if (log_level < 0)
     {
       UA_LOG_FATAL (UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
                     "Unknown log level: %s "
                     "(expected trace, debug, info, warning, error, fatal)",
-                    logLevelStr);
+                    log_level_str);
       return EXIT_FAILURE;
     }
 
   /* ── Load server config ─────────────────────────────────────── */
 
   int rc = EXIT_FAILURE;
-  Config serverCfg = { 0 };
-  Config clientCfg = { 0 };
-  SecurityConfig serverSec = { 0 };
-  SecurityConfig clientSec = { 0 };
+  config server_cfg = { 0 };
+  config client_cfg = { 0 };
+  security_config server_sec = { 0 };
+  security_config client_sec = { 0 };
   UA_Server *server = NULL;
 
-  if (configLoad (argv[1], &serverCfg) != 0)
+  if (config_load (argv[1], &server_cfg) != 0)
     goto cleanup;
 
-  int port = configRequireInt (&serverCfg, "port", "ServerRegister");
-  const char *applicationUri
-      = configRequire (&serverCfg, "applicationUri", "ServerRegister");
-  int registerInterval
-      = configRequireInt (&serverCfg, "registerInterval", "ServerRegister");
+  int port = config_require_int (&server_cfg, "port", "ServerRegister");
+  const char *application_uri
+      = config_require (&server_cfg, "applicationUri", "ServerRegister");
+  int register_interval
+      = config_require_int (&server_cfg, "registerInterval", "ServerRegister");
 
-  if (!applicationUri || port < 0 || registerInterval < 0)
+  if (!application_uri || port < 0 || register_interval < 0)
     goto cleanup;
 
-  if (parseSecurityConfig (&serverCfg, "ServerRegister", false, &serverSec)
+  if (parse_security_config (&server_cfg, "ServerRegister", false, &server_sec)
       != 0)
     goto cleanup;
 
-  AuthConfig serverAuth;
-  if (parseAuthConfig (&serverCfg, "ServerRegister", &serverAuth) != 0)
+  auth_config server_auth;
+  if (parse_auth_config (&server_cfg, "ServerRegister", &server_auth) != 0)
     goto cleanup;
 
   /* ── Load client config ─────────────────────────────────────── */
 
-  if (configLoad (argv[2], &clientCfg) != 0)
+  if (config_load (argv[2], &client_cfg) != 0)
     goto cleanup;
 
-  const char *clientAppUri
-      = configRequire (&clientCfg, "applicationUri", "ServerRegister");
-  if (!clientAppUri)
+  const char *client_app_uri
+      = config_require (&client_cfg, "applicationUri", "ServerRegister");
+  if (!client_app_uri)
     goto cleanup;
 
-  if (parseSecurityConfig (&clientCfg, "ServerRegister", true, &clientSec)
+  if (parse_security_config (&client_cfg, "ServerRegister", true, &client_sec)
       != 0)
     goto cleanup;
 
-  AuthConfig clientAuth;
-  if (parseAuthConfig (&clientCfg, "ServerRegister", &clientAuth) != 0)
+  auth_config client_auth;
+  if (parse_auth_config (&client_cfg, "ServerRegister", &client_auth) != 0)
     goto cleanup;
 
   /* ── Create and configure server ────────────────────────────── */
 
   UA_StatusCode retval;
-  server
-      = createServer ((UA_UInt16)port, applicationUri,
-                      serverSec.certPath ? &serverSec : NULL, true, &retval);
+  server = create_server ((UA_UInt16)port, application_uri,
+                          server_sec.cert_path ? &server_sec : NULL, true,
+                          &retval);
   if (!server)
     goto cleanup;
 
-  UA_ServerConfig *serverConfig = UA_Server_getConfig (server);
-  serverConfig->logging->context = (void *)(uintptr_t)logLevel;
+  UA_ServerConfig *server_config = UA_Server_getConfig (server);
+  server_config->logging->context = (void *)(uintptr_t)log_level;
 
-  retval = configureAccessControl (serverConfig, &serverAuth);
+  retval = configure_access_control (server_config, &server_auth);
   if (retval != UA_STATUSCODE_GOOD)
     goto cleanup;
 
-  serverConfig->applicationDescription.applicationType
+  server_config->applicationDescription.applicationType
       = UA_APPLICATIONTYPE_SERVER;
 
-  LdsClientParams ldsParams = {
-    .appUri = clientAppUri,
-    .sec = clientSec,
-    .auth = clientAuth,
-    .logLevel = logLevel,
+  lds_client_params lds_params = {
+    .app_uri = client_app_uri,
+    .sec = client_sec,
+    .auth = client_auth,
+    .log_level = log_level,
   };
 
   /* Use run_startup + manual event loop (instead of UA_Server_run) so we
@@ -176,59 +176,60 @@ main (int argc, char **argv)
   UA_Server_run_startup (server);
 
   /* UA_Server_registerDiscovery consumes (clears) the client config,
-     so makeLdsClientConfig builds a fresh one for every call. */
-  UA_ClientConfig clientConfig;
-  retval = makeLdsClientConfig (&clientConfig, &ldsParams);
+     so _s_make_lds_client_config builds a fresh one for every call. */
+  UA_ClientConfig client_config;
+  retval = _s_make_lds_client_config (&client_config, &lds_params);
   if (retval != UA_STATUSCODE_GOOD)
     {
       UA_Server_run_shutdown (server);
       goto cleanup;
     }
 
-  UA_String discoveryUrl = UA_STRING_ALLOC (discoveryEndpoint);
-  retval = UA_Server_registerDiscovery (server, &clientConfig, discoveryUrl,
+  UA_String discovery_url = UA_STRING_ALLOC (discovery_endpoint);
+  retval = UA_Server_registerDiscovery (server, &client_config, discovery_url,
                                         UA_STRING_NULL);
-  UA_String_clear (&discoveryUrl);
+  UA_String_clear (&discovery_url);
   if (retval != UA_STATUSCODE_GOOD)
     UA_LOG_WARNING (UA_Log_Stdout, UA_LOGCATEGORY_SERVER,
                     "Initial register failed: %s",
                     UA_StatusCode_name (retval));
 
   /* Periodic re-registration loop.  Re-register with the LDS every
-     registerInterval seconds so the LDS does not purge us. */
-  time_t lastRegister = time (NULL);
+     register_interval seconds so the LDS does not purge us. */
+  time_t last_register = time (NULL);
 
-  while (running)
+  while (g_running)
     {
       UA_Server_run_iterate (server, true);
 
       time_t now = time (NULL);
-      if (now - lastRegister >= registerInterval)
+      if (now - last_register >= register_interval)
         {
-          retval = makeLdsClientConfig (&clientConfig, &ldsParams);
+          retval = _s_make_lds_client_config (&client_config, &lds_params);
           if (retval == UA_STATUSCODE_GOOD)
             {
-              UA_String reregUrl = UA_STRING_ALLOC (discoveryEndpoint);
-              retval = UA_Server_registerDiscovery (server, &clientConfig,
-                                                    reregUrl, UA_STRING_NULL);
-              UA_String_clear (&reregUrl);
+              UA_String rereg_url = UA_STRING_ALLOC (discovery_endpoint);
+              retval = UA_Server_registerDiscovery (server, &client_config,
+                                                    rereg_url, UA_STRING_NULL);
+              UA_String_clear (&rereg_url);
               if (retval != UA_STATUSCODE_GOOD)
                 UA_LOG_WARNING (UA_Log_Stdout, UA_LOGCATEGORY_SERVER,
                                 "Re-register failed: %s",
                                 UA_StatusCode_name (retval));
             }
-          lastRegister = now;
+          last_register = now;
         }
     }
 
   /* Deregister from the LDS before shutting down so the LDS removes
      our entry immediately rather than waiting for the cleanup timeout. */
-  retval = makeLdsClientConfig (&clientConfig, &ldsParams);
+  retval = _s_make_lds_client_config (&client_config, &lds_params);
   if (retval == UA_STATUSCODE_GOOD)
     {
-      UA_String deregUrl = UA_STRING_ALLOC (discoveryEndpoint);
-      retval = UA_Server_deregisterDiscovery (server, &clientConfig, deregUrl);
-      UA_String_clear (&deregUrl);
+      UA_String dereg_url = UA_STRING_ALLOC (discovery_endpoint);
+      retval
+          = UA_Server_deregisterDiscovery (server, &client_config, dereg_url);
+      UA_String_clear (&dereg_url);
       if (retval != UA_STATUSCODE_GOOD)
         UA_LOG_ERROR (UA_Log_Stdout, UA_LOGCATEGORY_SERVER,
                       "Could not unregister from discovery server: %s",
@@ -241,9 +242,9 @@ main (int argc, char **argv)
 cleanup:
   if (server)
     UA_Server_delete (server);
-  freeTrustStore (clientSec.trustPaths, clientSec.trustSize);
-  freeTrustStore (serverSec.trustPaths, serverSec.trustSize);
-  configFree (&clientCfg);
-  configFree (&serverCfg);
+  free_trust_store (client_sec.trust_paths, client_sec.trust_size);
+  free_trust_store (server_sec.trust_paths, server_sec.trust_size);
+  config_free (&client_cfg);
+  config_free (&server_cfg);
   return rc;
 }