Aksal/nuttx-apps
1
0
Fork 1
mirror of https://github.com/apache/nuttx-apps.git synced 2026-08-01 20:29:00 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

netutils: prefer DHCP-provided NTP servers for ntpc

Browse source 
Use the DHCP-learned NTP server list as the default ntpc server source when DHCP option 42 is available.

Fall back to CONFIG_NETUTILS_NTPCLIENT_SERVER only when DHCP does not provide any NTP servers, and restart ntpc when the DHCP-provided server list changes.

Signed-off-by: Jerry Ma <masc2008@gmail.com>
This commit is contained in:
shichunma 2026-04-11 18:41:05 +08:00 • committed by Alan C. Assis
parent 4b705721ca
commit c82957109f
6 changed files with 535 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

1
netutils/netlib/CMakeLists.txt
View file

@ -57,6 +57,7 @@ if(CONFIG_NETUTILS_NETLIB)
endif()
if(CONFIG_NETUTILS_DHCPC)
list(APPEND SRCS netlib_obtainipv4addr.c)
list(APPEND SRCS netlib_dhcp_ntp.c)
endif()
endif()

1
netutils/netlib/Makefile
View file

@ -57,6 +57,7 @@ CSRCS += netlib_iptables.c
endif
ifeq ($(CONFIG_NETUTILS_DHCPC),y)
CSRCS += netlib_obtainipv4addr.c
CSRCS += netlib_dhcp_ntp.c
endif
endif

182
netutils/netlib/netlib_dhcp_ntp.c Normal file
View file

@ -0,0 +1,182 @@
/****************************************************************************
* apps/netutils/netlib/netlib_dhcp_ntp.c
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you 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
*
* http://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.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#ifdef CONFIG_NETUTILS_DHCPC
#include <errno.h>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include "netutils/netlib.h"
/****************************************************************************
* Private Data
****************************************************************************/
static pthread_mutex_t g_dhcp_ntp_lock = PTHREAD_MUTEX_INITIALIZER;
static FAR char *g_dhcp_ntp_servers;
static netlib_dhcp_ntp_callback_t g_dhcp_ntp_callback;
static FAR void *g_dhcp_ntp_callback_arg;
/****************************************************************************
* Private Functions
****************************************************************************/
static FAR char *netlib_dhcp_ntp_dup(FAR const char *ntp_server_list)
{
if (ntp_server_list == NULL || ntp_server_list[0] == '\0')
{
return NULL;
}
return strdup(ntp_server_list);
}
/****************************************************************************
* Public Functions
****************************************************************************/
int netlib_set_ntp_servers_from_dhcp(FAR const char *ntp_server_list)
{
FAR char *new_servers;
FAR char *notify_servers = NULL;
FAR char *old_servers;
netlib_dhcp_ntp_callback_t callback;
FAR void *arg;
int ret = OK;
new_servers = netlib_dhcp_ntp_dup(ntp_server_list);
if (ntp_server_list != NULL && ntp_server_list[0] != '\0' &&
new_servers == NULL)
{
return -ENOMEM;
}
pthread_mutex_lock(&g_dhcp_ntp_lock);
if ((g_dhcp_ntp_servers == NULL && new_servers == NULL) ||
(g_dhcp_ntp_servers != NULL && new_servers != NULL &&
strcmp(g_dhcp_ntp_servers, new_servers) == 0))
{
pthread_mutex_unlock(&g_dhcp_ntp_lock);
free(new_servers);
return OK;
}
callback = g_dhcp_ntp_callback;
arg = g_dhcp_ntp_callback_arg;
if (callback != NULL && new_servers != NULL)
{
notify_servers = strdup(new_servers);
if (notify_servers == NULL)
{
ret = -ENOMEM;
goto errout_with_lock;
}
}
old_servers = g_dhcp_ntp_servers;
g_dhcp_ntp_servers = new_servers;
pthread_mutex_unlock(&g_dhcp_ntp_lock);
free(old_servers);
if (callback != NULL)
{
callback(notify_servers, arg);
}
free(notify_servers);
return OK;
errout_with_lock:
pthread_mutex_unlock(&g_dhcp_ntp_lock);
free(new_servers);
return ret;
}
int netlib_register_dhcp_ntp_callback(netlib_dhcp_ntp_callback_t callback,
FAR void *arg)
{
FAR char *notify_servers = NULL;
if (callback == NULL)
{
return -EINVAL;
}
pthread_mutex_lock(&g_dhcp_ntp_lock);
if (g_dhcp_ntp_callback != NULL &&
(g_dhcp_ntp_callback != callback || g_dhcp_ntp_callback_arg != arg))
{
pthread_mutex_unlock(&g_dhcp_ntp_lock);
return -EBUSY;
}
if (g_dhcp_ntp_servers != NULL)
{
notify_servers = strdup(g_dhcp_ntp_servers);
if (notify_servers == NULL)
{
pthread_mutex_unlock(&g_dhcp_ntp_lock);
return -ENOMEM;
}
}
g_dhcp_ntp_callback = callback;
g_dhcp_ntp_callback_arg = arg;
pthread_mutex_unlock(&g_dhcp_ntp_lock);
callback(notify_servers, arg);
free(notify_servers);
return OK;
}
int netlib_unregister_dhcp_ntp_callback(netlib_dhcp_ntp_callback_t callback,
FAR void *arg)
{
int ret = -ENOENT;
pthread_mutex_lock(&g_dhcp_ntp_lock);
if (g_dhcp_ntp_callback == callback && g_dhcp_ntp_callback_arg == arg)
{
g_dhcp_ntp_callback = NULL;
g_dhcp_ntp_callback_arg = NULL;
ret = OK;
}
pthread_mutex_unlock(&g_dhcp_ntp_lock);
return ret;
}
#endif /* CONFIG_NETUTILS_DHCPC */

78
netutils/netlib/netlib_obtainipv4addr.c
View file

@ -25,6 +25,10 @@
****************************************************************************/
#include <nuttx/debug.h>
#include <arpa/inet.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include "netutils/dhcpc.h"
@ -105,6 +109,68 @@ static int dhcp_setup_result(FAR const char *ifname,
return OK;
}
#ifdef CONFIG_NETUTILS_NTPCLIENT
static int dhcp_set_ntp_servers(FAR const struct dhcpc_state *ds)
{
char ntp_server_list[CONFIG_NETUTILS_DHCPC_NTP_SERVERS *
(INET_ADDRSTRLEN + 1)];
size_t offset = 0;
uint8_t i;
/* Clear the DHCP-provided NTP server list,
* consider case: that device has joined another dhcp domain,
* it need refresh related settings.
*/
if (ds->num_ntpaddr == 0)
{
return netlib_set_ntp_servers_from_dhcp(NULL);
}
ntp_server_list[0] = '\0';
for (i = 0; i < ds->num_ntpaddr; i++)
{
char addrbuf[INET_ADDRSTRLEN];
int ret;
/* Skip empty entries */
if (ds->ntpaddr[i].s_addr == 0)
{
continue;
}
if (inet_ntop(AF_INET, &ds->ntpaddr[i], addrbuf, sizeof(addrbuf)) ==
NULL)
{
return -EINVAL;
}
/* Append the server to the list */
ret = snprintf(ntp_server_list + offset,
sizeof(ntp_server_list) - offset,
"%s%s", offset == 0 ? "" : ";", addrbuf);
if (ret < 0 || (size_t)ret >= sizeof(ntp_server_list) - offset)
{
return -E2BIG;
}
offset += (size_t)ret;
}
/* Clear the list if all entries were empty */
if (offset == 0)
{
return netlib_set_ntp_servers_from_dhcp(NULL);
}
return netlib_set_ntp_servers_from_dhcp(ntp_server_list);
}
#endif
/****************************************************************************
* Name: dhcp_obtain_statefuladdr
*
@ -156,6 +222,18 @@ static int dhcp_obtain_statefuladdr(FAR const char *ifname)
if (ret == OK)
{
ret = dhcp_setup_result(ifname, &ds);
#ifdef CONFIG_NETUTILS_NTPCLIENT
if (ret == OK)
{
ret = dhcp_set_ntp_servers(&ds);
if (ret < 0)
{
nwarn("WARNING: failed to update DHCP NTP server list: %d\n",
ret);
ret = OK;
}
}
#endif
}
else
{

263
netutils/ntpclient/ntpclient.c
View file

@ -126,6 +126,14 @@ enum ntpc_daemon_e
NTP_STOPPED
};
enum ntpc_server_source_e
{
NTP_SERVER_SOURCE_NONE = 0,
NTP_SERVER_SOURCE_CONFIG,
NTP_SERVER_SOURCE_DHCP,
NTP_SERVER_SOURCE_EXPLICIT
};
/* This type describes the state of the NTP client daemon. Only one
* instance of the NTP daemon is permitted in this implementation.
*/
@ -133,11 +141,17 @@ enum ntpc_daemon_e
struct ntpc_daemon_s
{
uint8_t state; /* See enum ntpc_daemon_e */
uint8_t source; /* See enum ntpc_server_source_e */
bool dhcp_registered;
sem_t lock; /* Used to protect the whole structure */
sem_t sync; /* Used to synchronize start and stop events */
pid_t pid; /* Task ID of the NTP daemon */
sq_queue_t kod_list; /* KoD excluded server addresses */
int family; /* Allowed address family */
/* DHCP-provided server list */
FAR char *dhcp_servers;
};
union ntp_addr_u
@ -194,11 +208,14 @@ struct ntp_kod_exclude_s
static struct ntpc_daemon_s g_ntpc_daemon =
{
NTP_NOT_RUNNING,
NTP_SERVER_SOURCE_NONE,
false,
SEM_INITIALIZER(1),
SEM_INITIALIZER(0),
-1,
{ NULL, NULL },
AF_UNSPEC, /* Default is both IPv4 and IPv6 */
NULL,
};
static struct ntp_sample_s g_last_samples
@ -209,6 +226,115 @@ unsigned int g_last_nsamples = 0;
* Private Functions
****************************************************************************/
static int ntpc_daemon(int argc, FAR char **argv);
static int ntpc_set_servers_from_dhcp(FAR const char *ntp_server_list);
static FAR char *ntpc_dup_server_list(FAR const char *ntp_server_list)
{
if (ntp_server_list == NULL || ntp_server_list[0] == '\0')
{
return NULL;
}
return strdup(ntp_server_list);
}
static FAR const char *ntpc_select_server_list(FAR uint8_t *source)
{
if (g_ntpc_daemon.dhcp_servers != NULL &&
g_ntpc_daemon.dhcp_servers[0] != '\0')
{
*source = NTP_SERVER_SOURCE_DHCP;
return g_ntpc_daemon.dhcp_servers;
}
if (CONFIG_NETUTILS_NTPCLIENT_SERVER[0] != '\0')
{
*source = NTP_SERVER_SOURCE_CONFIG;
return CONFIG_NETUTILS_NTPCLIENT_SERVER;
}
*source = NTP_SERVER_SOURCE_NONE;
return NULL;
}
#ifdef CONFIG_NETUTILS_DHCPC
static void ntpc_dhcp_notify(FAR const char *ntp_server_list, FAR void *arg)
{
int ret;
UNUSED(arg);
ret = ntpc_set_servers_from_dhcp(ntp_server_list);
if (ret < 0)
{
nwarn("WARNING: failed to update DHCP NTP server list: %d\n", ret);
}
}
static int ntpc_register_dhcp(void)
{
int ret;
sem_wait(&g_ntpc_daemon.lock);
if (g_ntpc_daemon.dhcp_registered)
{
sem_post(&g_ntpc_daemon.lock);
return OK;
}
g_ntpc_daemon.dhcp_registered = true;
sem_post(&g_ntpc_daemon.lock);
ret = netlib_register_dhcp_ntp_callback(ntpc_dhcp_notify, NULL);
if (ret < 0)
{
sem_wait(&g_ntpc_daemon.lock);
g_ntpc_daemon.dhcp_registered = false;
sem_post(&g_ntpc_daemon.lock);
return ret;
}
return OK;
}
#endif
static int ntpc_start_selected(FAR const char *ntp_server_list,
uint8_t source)
{
FAR char *task_argv[] =
{
(FAR char *)ntp_server_list,
NULL
};
g_ntpc_daemon.state = NTP_STARTED;
g_ntpc_daemon.source = source;
g_ntpc_daemon.pid =
task_create("NTP daemon", CONFIG_NETUTILS_NTPCLIENT_SERVERPRIO,
CONFIG_NETUTILS_NTPCLIENT_STACKSIZE, ntpc_daemon,
task_argv);
if (g_ntpc_daemon.pid < 0)
{
int errval = errno;
DEBUGASSERT(errval > 0);
g_ntpc_daemon.state = NTP_STOPPED;
g_ntpc_daemon.source = NTP_SERVER_SOURCE_NONE;
nerr("ERROR: Failed to start the NTP daemon: %d\n", errval);
return -errval;
}
do
{
sem_wait(&g_ntpc_daemon.sync);
}
while (g_ntpc_daemon.state == NTP_STARTED);
return g_ntpc_daemon.pid;
}
/****************************************************************************
* Name: sample_cmp
****************************************************************************/
@ -1490,11 +1616,12 @@ void ntpc_dualstack_family(int family)
int ntpc_start_with_list(FAR const char *ntp_server_list)
{
FAR char *task_argv[] =
int ret;
if (ntp_server_list == NULL || ntp_server_list[0] == '\0')
{
(FAR char *)ntp_server_list,
NULL
};
return -EINVAL;
}
/* Is the NTP in a non-running state? */
@ -1502,34 +1629,10 @@ int ntpc_start_with_list(FAR const char *ntp_server_list)
if (g_ntpc_daemon.state == NTP_NOT_RUNNING ||
g_ntpc_daemon.state == NTP_STOPPED)
{
/* Start the NTP daemon */
g_ntpc_daemon.state = NTP_STARTED;
g_ntpc_daemon.pid =
task_create("NTP daemon", CONFIG_NETUTILS_NTPCLIENT_SERVERPRIO,
CONFIG_NETUTILS_NTPCLIENT_STACKSIZE, ntpc_daemon,
task_argv);
/* Handle failures to start the NTP daemon */
if (g_ntpc_daemon.pid < 0)
{
int errval = errno;
DEBUGASSERT(errval > 0);
g_ntpc_daemon.state = NTP_STOPPED;
nerr("ERROR: Failed to start the NTP daemon: %d\n", errval);
sem_post(&g_ntpc_daemon.lock);
return -errval;
}
/* Wait for any daemon state change */
do
{
sem_wait(&g_ntpc_daemon.sync);
}
while (g_ntpc_daemon.state == NTP_STARTED);
ret = ntpc_start_selected(ntp_server_list,
NTP_SERVER_SOURCE_EXPLICIT);
sem_post(&g_ntpc_daemon.lock);
return ret;
}
sem_post(&g_ntpc_daemon.lock);
@ -1550,7 +1653,101 @@ int ntpc_start_with_list(FAR const char *ntp_server_list)
int ntpc_start(void)
{
return ntpc_start_with_list(CONFIG_NETUTILS_NTPCLIENT_SERVER);
FAR const char *ntp_server_list;
uint8_t source;
int ret;
#ifdef CONFIG_NETUTILS_DHCPC
ret = ntpc_register_dhcp();
if (ret < 0)
{
return ret;
}
#endif
sem_wait(&g_ntpc_daemon.lock);
if (g_ntpc_daemon.state != NTP_NOT_RUNNING &&
g_ntpc_daemon.state != NTP_STOPPED)
{
ret = g_ntpc_daemon.pid;
sem_post(&g_ntpc_daemon.lock);
return ret;
}
ntp_server_list = ntpc_select_server_list(&source);
if (ntp_server_list == NULL)
{
g_ntpc_daemon.source = NTP_SERVER_SOURCE_NONE;
sem_post(&g_ntpc_daemon.lock);
return -ENOENT;
}
ret = ntpc_start_selected(ntp_server_list, source);
sem_post(&g_ntpc_daemon.lock);
return ret;
}
static int ntpc_set_servers_from_dhcp(FAR const char *ntp_server_list)
{
FAR char *new_servers;
FAR char *old_servers;
bool start = false;
bool restart = false;
int ret = OK;
new_servers = ntpc_dup_server_list(ntp_server_list);
if (ntp_server_list != NULL && ntp_server_list[0] != '\0' &&
new_servers == NULL)
{
return -ENOMEM;
}
sem_wait(&g_ntpc_daemon.lock);
if ((g_ntpc_daemon.dhcp_servers == NULL && new_servers == NULL) ||
(g_ntpc_daemon.dhcp_servers != NULL && new_servers != NULL &&
strcmp(g_ntpc_daemon.dhcp_servers, new_servers) == 0))
{
sem_post(&g_ntpc_daemon.lock);
free(new_servers);
return OK;
}
old_servers = g_ntpc_daemon.dhcp_servers;
g_ntpc_daemon.dhcp_servers = new_servers;
if ((g_ntpc_daemon.source == NTP_SERVER_SOURCE_DHCP ||
g_ntpc_daemon.source == NTP_SERVER_SOURCE_CONFIG) &&
(g_ntpc_daemon.state == NTP_STARTED ||
g_ntpc_daemon.state == NTP_RUNNING))
{
restart = true;
}
else if (g_ntpc_daemon.source == NTP_SERVER_SOURCE_NONE &&
new_servers != NULL &&
(g_ntpc_daemon.state == NTP_NOT_RUNNING ||
g_ntpc_daemon.state == NTP_STOPPED))
{
start = true;
}
sem_post(&g_ntpc_daemon.lock);
free(old_servers);
if (restart)
{
ret = ntpc_stop();
if (ret >= 0 && new_servers != NULL)
{
ret = ntpc_start();
}
}
else if (start)
{
ret = ntpc_start();
}
return ret;
}
/****************************************************************************