timeserver: Add service gateway to timeserver list
[platform/upstream/connman.git] / src / timeserver.c
1 /*
2  *
3  *  Connection Manager
4  *
5  *  Copyright (C) 2007-2010  Intel Corporation. All rights reserved.
6  *
7  *  This program is free software; you can redistribute it and/or modify
8  *  it under the terms of the GNU General Public License version 2 as
9  *  published by the Free Software Foundation.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, write to the Free Software
18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19  *
20  */
21
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 #include <errno.h>
27
28 #include <glib.h>
29 #include <stdlib.h>
30 #include <gweb/gresolv.h>
31 #include <netdb.h>
32
33 #include "connman.h"
34
35 static GSList *ts_list = NULL;
36
37 static GResolv *resolv = NULL;
38 static int resolv_id = 0;
39
40 static void resolv_debug(const char *str, void *data)
41 {
42         connman_info("%s: %s\n", (const char *) data, str);
43 }
44 static void save_timeservers(char **servers)
45 {
46         GKeyFile *keyfile;
47         int cnt;
48
49         keyfile = __connman_storage_load_global();
50         if (keyfile == NULL)
51                 keyfile = g_key_file_new();
52
53         for (cnt = 0; servers != NULL && servers[cnt] != NULL; cnt++);
54
55         g_key_file_set_string_list(keyfile, "global", "Timeservers",
56                            (const gchar **)servers, cnt);
57
58         __connman_storage_save_global(keyfile);
59
60         g_key_file_free(keyfile);
61
62         return;
63 }
64
65 static char **load_timeservers()
66 {
67         GKeyFile *keyfile;
68         GError *error = NULL;
69         char **servers = NULL;
70
71         keyfile = __connman_storage_load_global();
72         if (keyfile == NULL)
73                 return NULL;
74
75         servers = g_key_file_get_string_list(keyfile, "global",
76                                                 "Timeservers", NULL, &error);
77         if (error) {
78                 DBG("Error loading timeservers: %s", error->message);
79                 g_error_free(error);
80         }
81
82         g_key_file_free(keyfile);
83
84         return servers;
85 }
86
87 static void resolv_result(GResolvResultStatus status, char **results, gpointer user_data)
88 {
89         int i;
90
91         DBG("status %d", status);
92
93         if (status == G_RESOLV_RESULT_STATUS_SUCCESS) {
94                 if (results != NULL) {
95                         for (i = 0; results[i]; i++)
96                                 DBG("result: %s", results[i]);
97
98                         __connman_ntp_start(results[0]);
99
100                         return;
101                 }
102         }
103
104         /* If resolving fails, move to the next server */
105         __connman_timeserver_sync_next();
106 }
107
108 /*
109  * Once the timeserver list (ts_list) is created, we start querying the
110  * servers one by one. If resolving fails on one of them, we move to the
111  * next one. The user can enter either an IP address or a URL for the
112  * timeserver. We only resolve the urls. Once we have a IP for the NTP
113  * server, we start querying it for time corrections.
114  */
115 void __connman_timeserver_sync_next()
116 {
117         char *server;
118         int ret;
119         struct addrinfo hints;
120         struct addrinfo *addr;
121
122         __connman_ntp_stop();
123
124         /* Get the 1st server in the list */
125         if (ts_list == NULL)
126                 return;
127
128         server = ts_list->data;
129
130         ts_list = g_slist_delete_link(ts_list, ts_list);
131
132         memset(&hints, 0, sizeof(struct addrinfo));
133         hints.ai_flags = AI_NUMERICHOST;
134         addr = NULL;
135
136         ret = getaddrinfo(server, NULL, &hints, &addr);
137         freeaddrinfo(addr);
138
139         /* if its a IP , directly query it. */
140         if (ret == 0) {
141                 DBG("Using timeservers %s", server);
142
143                 __connman_ntp_start(server);
144
145                 g_free(server);
146                 return;
147         }
148
149         DBG("Resolving server %s", server);
150
151         resolv_id = g_resolv_lookup_hostname(resolv, server,
152                                                 resolv_result, NULL);
153
154         g_free(server);
155
156         return;
157 }
158
159
160 /*
161  * __connman_timeserver_sync function recreates the timeserver
162  * list which will be used to determine NTP server for time corrections.
163  * It must be called everytime the default service changes, the service
164  * timeserver(s) or gatway changes or the global timeserver(s) changes.
165  * The service settings take priority over the global timeservers.
166  */
167 int __connman_timeserver_sync(struct connman_service *default_service)
168 {
169         struct connman_service *service;
170         struct connman_network *network;
171         char **timeservers;
172         char **service_ts;
173         const char *service_gw;
174         int index, i;
175
176         if (default_service != NULL)
177                 service = default_service;
178         else
179                 service = __connman_service_get_default();
180
181         if (service == NULL)
182                 return -EINVAL;
183
184         if (resolv == NULL)
185                 return 0;
186         /*
187          * Before be start creating the new timeserver list we must stop
188          * any ongoing ntp query and server resolution.
189          */
190
191         __connman_ntp_stop();
192
193         if (resolv_id > 0)
194                 g_resolv_cancel_lookup(resolv, resolv_id);
195
196         if (ts_list != NULL) {
197                 g_slist_free_full(ts_list, g_free);
198                 ts_list = NULL;
199         }
200
201         service_ts = connman_service_get_timeservers(service);
202
203         /* First add Service Timeservers via DHCP to the list */
204         for (i=0; service_ts != NULL && service_ts[i] != NULL; i++)
205                 ts_list = g_slist_prepend(ts_list, g_strdup(service_ts[i]));
206
207         network = __connman_service_get_network(service);
208
209         index = connman_network_get_index(network);
210
211         service_gw = __connman_ipconfig_get_gateway_from_index(index);
212
213         /* Then add Service Gateway to the list */
214         if (service_gw != NULL)
215                 ts_list = g_slist_prepend(ts_list, g_strdup(service_gw));
216
217         /* Then add Global Timeservers to the list */
218         timeservers = load_timeservers();
219
220         for (i=0; timeservers != NULL && timeservers[i] != NULL; i++)
221                 ts_list = g_slist_prepend(ts_list, g_strdup(timeservers[i]));
222
223         if (ts_list == NULL) {
224                 DBG("No timeservers set.");
225                 return 0;
226         }
227
228         ts_list = g_slist_reverse(ts_list);
229
230         __connman_timeserver_sync_next();
231
232         return 0;
233 }
234
235 static int timeserver_start(struct connman_service *service)
236 {
237         char **nameservers;
238         int i;
239
240         DBG("service %p", service);
241
242         i = __connman_service_get_index(service);
243         if (i < 0)
244                 return -EINVAL;
245
246         nameservers = connman_service_get_nameservers(service);
247         if (nameservers == NULL)
248                 return -EINVAL;
249
250         /* Stop an already ongoing resolution, if there is one */
251         if (resolv_id > 0)
252                 g_resolv_cancel_lookup(resolv, resolv_id);
253
254         /* get rid of the old resolver */
255         if (resolv != NULL) {
256                 g_resolv_unref(resolv);
257                 resolv = NULL;
258         }
259
260         resolv = g_resolv_new(i);
261         if (resolv == NULL)
262                 return -ENOMEM;
263
264         if (getenv("CONNMAN_RESOLV_DEBUG"))
265                 g_resolv_set_debug(resolv, resolv_debug, "RESOLV");
266
267         for (i = 0; nameservers[i] != NULL; i++)
268                 g_resolv_add_nameserver(resolv, nameservers[i], 53, 0);
269
270         return __connman_timeserver_sync(service);
271 }
272
273 static void timeserver_stop()
274 {
275         DBG(" ");
276
277         if (resolv != NULL) {
278                 g_resolv_unref(resolv);
279                 resolv = NULL;
280         }
281
282         if (ts_list != NULL)
283                 g_slist_free_full(ts_list, g_free);
284
285         ts_list = NULL;
286
287         __connman_ntp_stop();
288 }
289
290 int __connman_timeserver_system_set(char **servers)
291 {
292         save_timeservers(servers);
293
294         __connman_timeserver_sync(NULL);
295
296         return 0;
297 }
298
299 char **__connman_timeserver_system_get()
300 {
301         char **servers;
302
303         servers = load_timeservers();
304         return servers;
305 }
306
307 static void default_changed(struct connman_service *default_service)
308 {
309         if (default_service != NULL)
310                 timeserver_start(default_service);
311         else
312                 timeserver_stop();
313 }
314
315 static struct connman_notifier timeserver_notifier = {
316         .name                   = "timeserver",
317         .default_changed        = default_changed,
318 };
319
320 int __connman_timeserver_init(void)
321 {
322         DBG("");
323
324         connman_notifier_register(&timeserver_notifier);
325
326         return 0;
327 }
328
329 void __connman_timeserver_cleanup(void)
330 {
331         DBG("");
332
333         connman_notifier_unregister(&timeserver_notifier);
334 }