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
  32 #include "connman.h"
  33
  34 static GSList *driver_list = NULL;
  35 static GHashTable *server_hash = NULL;
  36
  37 static char **system_timeservers = NULL;
  38 static char **timeservers = NULL;
  39
  40 static GResolv *resolv = NULL;
  41 static int resolv_id = 0;
  42 static volatile int count;
  43
  44 static void resolv_debug(const char *str, void *data)
  45 {
  46         connman_info("%s: %s\n", (const char *) data, str);
  47 }
  48 static void save_timeservers(char **servers)
  49 {
  50         GKeyFile *keyfile;
  51         int cnt;
  52
  53         keyfile = __connman_storage_load_global();
  54         if (keyfile == NULL)
  55                 keyfile = g_key_file_new();
  56
  57         for (cnt = 0; servers != NULL && servers[cnt] != NULL; cnt++);
  58
  59         g_key_file_set_string_list(keyfile, "global", "Timeservers",
  60                            (const gchar **)servers, cnt);
  61
  62         __connman_storage_save_global(keyfile);
  63
  64         g_key_file_free(keyfile);
  65
  66         return;
  67 }
  68
  69 static char **load_timeservers()
  70 {
  71         GKeyFile *keyfile;
  72         GError *error = NULL;
  73         char **servers = NULL;
  74
  75         keyfile = __connman_storage_load_global();
  76         if (keyfile == NULL)
  77                 return NULL;
  78
  79         servers = g_key_file_get_string_list(keyfile, "global",
  80                                                 "Timeservers", NULL, &error);
  81         if (error) {
  82                 DBG("Error loading timeservers: %s", error->message);
  83                 g_error_free(error);
  84         }
  85
  86         g_key_file_free(keyfile);
  87
  88         return servers;
  89 }
  90
  91 static gint compare_priority(gconstpointer a, gconstpointer b)
  92 {
  93         const struct connman_timeserver_driver *driver1 = a;
  94         const struct connman_timeserver_driver *driver2 = b;
  95
  96         return driver2->priority - driver1->priority;
  97 }
  98
  99 /**
 100  * connman_timeserver_driver_register:
 101  * @driver: timeserver driver definition
 102  *
 103  * Register a new timeserver driver
 104  *
 105  * Returns: %0 on success
 106  */
 107 int connman_timeserver_driver_register(struct connman_timeserver_driver *driver)
 108 {
 109         DBG("driver %p name %s", driver, driver->name);
 110
 111         driver_list = g_slist_insert_sorted(driver_list, driver,
 112                                                         compare_priority);
 113
 114         return 0;
 115 }
 116
 117 /**
 118  * connman_timeserver_driver_unregister:
 119  * @driver: timeserver driver definition
 120  *
 121  * Remove a previously registered timeserver driver
 122  */
 123 void connman_timeserver_driver_unregister(struct connman_timeserver_driver *driver)
 124 {
 125         DBG("driver %p name %s", driver, driver->name);
 126
 127         driver_list = g_slist_remove(driver_list, driver);
 128 }
 129
 130 /* Restart NTP procedure */
 131 static void connman_timeserver_restart()
 132 {
 133         /* If service timeservers are in use, dont restart ntp */
 134         if (timeservers != NULL)
 135                 return;
 136
 137         if (resolv == NULL) {
 138                 DBG("No online service.");
 139                 return;
 140         }
 141
 142         /* Cancel current lookup */
 143         if(resolv_id > 0)
 144                 g_resolv_cancel_lookup(resolv, resolv_id);
 145
 146         /* Reload system timeserver list */
 147         if (system_timeservers != NULL) {
 148                 g_strfreev(system_timeservers);
 149                 system_timeservers = NULL;
 150         }
 151
 152         system_timeservers = load_timeservers();
 153
 154         if (system_timeservers == NULL)
 155                 return;
 156
 157         __connman_ntp_stop();
 158
 159         count = 0;
 160
 161         __connman_timeserver_sync_next();
 162 }
 163
 164 static void resolv_result(GResolvResultStatus status, char **results, gpointer user_data)
 165 {
 166         int i;
 167
 168         DBG("status %d", status);
 169
 170         __sync_fetch_and_add(&count, 1);
 171
 172         if (status == G_RESOLV_RESULT_STATUS_SUCCESS) {
 173                 if (results != NULL) {
 174                         for (i = 0; results[i]; i++)
 175                                 DBG("result: %s", results[i]);
 176
 177                         __connman_ntp_start(results[0]);
 178
 179                         return;
 180                 }
 181         }
 182
 183         __connman_timeserver_sync_next();
 184 }
 185
 186 void __connman_timeserver_sync_next()
 187 {
 188         if (system_timeservers == NULL ||
 189         system_timeservers[count] == NULL)
 190                 return;
 191
 192         DBG("Trying timeserver %s", system_timeservers[count]);
 193
 194         if (resolv)
 195                 resolv_id = g_resolv_lookup_hostname(resolv,
 196                         system_timeservers[count], resolv_result,
 197                                                 NULL);
 198 }
 199
 200 int __connman_timeserver_sync(struct connman_service *service)
 201 {
 202         char **nameservers = NULL;
 203         int i;
 204
 205         DBG("service %p", service);
 206
 207         i = __connman_service_get_index(service);
 208         if (i < 0)
 209                 return -EINVAL;
 210
 211         nameservers = connman_service_get_nameservers(service);
 212         if (nameservers == NULL)
 213                 return -EINVAL;
 214
 215         resolv = g_resolv_new(i);
 216         if (resolv == NULL)
 217                 return -ENOMEM;
 218
 219         if (getenv("CONNMAN_RESOLV_DEBUG"))
 220                 g_resolv_set_debug(resolv, resolv_debug, "RESOLV");
 221
 222         for (i = 0; nameservers[i] != NULL; i++)
 223                 g_resolv_add_nameserver(resolv, nameservers[i], 53, 0);
 224
 225         count = 0;
 226
 227         system_timeservers = load_timeservers();
 228
 229         timeservers = connman_service_get_timeservers(service);
 230
 231         if (timeservers != NULL && timeservers[0] != NULL) {
 232                 DBG("Using service tiemservers");
 233                 __connman_ntp_start(timeservers[0]);
 234                 return 0;
 235         }
 236
 237         if (system_timeservers == NULL || system_timeservers[count] == NULL) {
 238                 DBG("No timeservers set.");
 239                 return 0;
 240         }
 241
 242         DBG("Trying server %s", system_timeservers[count]);
 243
 244         resolv_id = g_resolv_lookup_hostname(resolv, system_timeservers[count],
 245                                                 resolv_result, NULL);
 246         return 0;
 247 }
 248
 249 void __connman_timeserver_stop()
 250 {
 251         DBG(" ");
 252
 253         if (resolv != NULL) {
 254                 g_resolv_unref(resolv);
 255                 resolv = NULL;
 256         }
 257
 258         if (system_timeservers != NULL) {
 259                 g_strfreev(system_timeservers);
 260                 system_timeservers = NULL;
 261         }
 262
 263         timeservers = NULL;
 264
 265         count = 0;
 266
 267         __connman_ntp_stop();
 268 }
 269
 270 int __connman_timeserver_system_append(const char *server)
 271 {
 272         int len;
 273         char **servers = NULL;
 274
 275         if (server == NULL) {
 276                 save_timeservers(servers);
 277                 goto restart;
 278         }
 279
 280         DBG("server %s", server);
 281
 282         servers = load_timeservers();
 283
 284         if (servers != NULL) {
 285                 int i;
 286
 287                 for (i = 0; servers[i] != NULL; i++)
 288                         if (g_strcmp0(servers[i], server) == 0) {
 289                                 g_strfreev(servers);
 290                                 return -EEXIST;
 291                         }
 292
 293                 len = g_strv_length(servers);
 294                 servers = g_try_renew(char *, servers, len + 2);
 295         } else {
 296                 len = 0;
 297                 servers = g_try_new0(char *, len + 2);
 298         }
 299
 300         if (servers == NULL)
 301                 return -ENOMEM;
 302
 303         servers[len] = g_strdup(server);
 304         servers[len + 1] = NULL;
 305
 306         save_timeservers(servers);
 307
 308         g_strfreev(servers);
 309 restart:
 310         connman_timeserver_restart();
 311
 312         return 0;
 313 }
 314
 315 int __connman_timeserver_system_remove(const char *server)
 316 {
 317         char **servers;
 318         char **temp;
 319         int len, i, j;
 320
 321         if (server == NULL)
 322                 return -EINVAL;
 323
 324         DBG("server %s", server);
 325
 326         servers = load_timeservers();
 327
 328         if (servers == NULL)
 329                 return 0;
 330
 331         len = g_strv_length(servers);
 332         if (len == 1) {
 333                 if (g_strcmp0(servers[0], server) != 0) {
 334                         g_strfreev(servers);
 335                         return 0;
 336                 }
 337
 338                 g_strfreev(servers);
 339                 servers = NULL;
 340                 save_timeservers(servers);
 341                 return 0;
 342         }
 343
 344         temp = g_try_new0(char *, len - 1);
 345         if (temp == NULL) {
 346                         g_strfreev(servers);
 347                         return -ENOMEM;
 348         }
 349
 350         for (i = 0, j = 0; i < len; i++) {
 351                 if (g_strcmp0(servers[i], server) != 0) {
 352                         temp[j] = g_strdup(servers[i]);
 353                         j++;
 354                 }
 355         }
 356         temp[len - 1] = NULL;
 357
 358         g_strfreev(servers);
 359         servers = g_strdupv(temp);
 360         g_strfreev(temp);
 361
 362         save_timeservers(servers);
 363         g_strfreev(servers);
 364
 365         connman_timeserver_restart();
 366
 367         return 0;
 368 }
 369
 370 char **__connman_timeserver_system_get()
 371 {
 372         char **servers;
 373
 374         servers = load_timeservers();
 375         return servers;
 376 }
 377
 378 int __connman_timeserver_init(void)
 379 {
 380         DBG("");
 381
 382         server_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
 383                                                 g_free, NULL);
 384
 385         return 0;
 386 }
 387
 388 void __connman_timeserver_cleanup(void)
 389 {
 390         DBG("");
 391
 392         g_hash_table_destroy(server_hash);
 393 }