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
  30 #include "connman.h"
  31
  32 static GSList *driver_list = NULL;
  33 static GHashTable *server_hash = NULL;
  34
  35 static void save_timeservers(char **servers)
  36 {
  37         GKeyFile *keyfile;
  38         int cnt;
  39
  40         keyfile = __connman_storage_load_global();
  41         if (keyfile == NULL)
  42                 keyfile = g_key_file_new();
  43
  44         for (cnt = 0; servers != NULL && servers[cnt] != NULL; cnt++);
  45
  46         g_key_file_set_string_list(keyfile, "global", "Timeservers",
  47                            (const gchar **)servers, cnt);
  48
  49         __connman_storage_save_global(keyfile);
  50
  51         g_key_file_free(keyfile);
  52
  53         return;
  54 }
  55
  56 static char **load_timeservers()
  57 {
  58         GKeyFile *keyfile;
  59         GError *error = NULL;
  60         char **servers = NULL;
  61
  62         keyfile = __connman_storage_load_global();
  63         if (keyfile == NULL)
  64                 return NULL;
  65
  66         servers = g_key_file_get_string_list(keyfile, "global",
  67                                                 "Timeservers", NULL, &error);
  68         if (error) {
  69                 DBG("Error loading timeservers: %s", error->message);
  70                 g_error_free(error);
  71         }
  72
  73         g_key_file_free(keyfile);
  74
  75         return servers;
  76 }
  77
  78 static gint compare_priority(gconstpointer a, gconstpointer b)
  79 {
  80         const struct connman_timeserver_driver *driver1 = a;
  81         const struct connman_timeserver_driver *driver2 = b;
  82
  83         return driver2->priority - driver1->priority;
  84 }
  85
  86 /**
  87  * connman_timeserver_driver_register:
  88  * @driver: timeserver driver definition
  89  *
  90  * Register a new timeserver driver
  91  *
  92  * Returns: %0 on success
  93  */
  94 int connman_timeserver_driver_register(struct connman_timeserver_driver *driver)
  95 {
  96         DBG("driver %p name %s", driver, driver->name);
  97
  98         driver_list = g_slist_insert_sorted(driver_list, driver,
  99                                                         compare_priority);
 100
 101         return 0;
 102 }
 103
 104 /**
 105  * connman_timeserver_driver_unregister:
 106  * @driver: timeserver driver definition
 107  *
 108  * Remove a previously registered timeserver driver
 109  */
 110 void connman_timeserver_driver_unregister(struct connman_timeserver_driver *driver)
 111 {
 112         DBG("driver %p name %s", driver, driver->name);
 113
 114         driver_list = g_slist_remove(driver_list, driver);
 115 }
 116
 117 /**
 118  * connman_timeserver_append:
 119  * @server: server address
 120  *
 121  * Append time server server address to current list
 122  */
 123 int connman_timeserver_append(const char *server)
 124 {
 125         GSList *list;
 126
 127         DBG("server %s", server);
 128
 129         if (server == NULL)
 130                 return -EINVAL;
 131
 132         /* This server is already handled by a driver */
 133         if (g_hash_table_lookup(server_hash, server))
 134                 return 0;
 135
 136         for (list = driver_list; list; list = list->next) {
 137                 struct connman_timeserver_driver *driver = list->data;
 138                 char *new_server;
 139
 140                 if (driver->append == NULL)
 141                         continue;
 142
 143                 new_server = g_strdup(server);
 144                 if (new_server == NULL)
 145                         return -ENOMEM;
 146
 147                 if (driver->append(server) == 0) {
 148                         g_hash_table_insert(server_hash, new_server, driver);
 149                         return 0;
 150                 } else {
 151                         g_free(new_server);
 152                 }
 153         }
 154
 155         return -ENOENT;
 156 }
 157
 158 /**
 159  * connman_timeserver_remove:
 160  * @server: server address
 161  *
 162  * Remover time server server address from current list
 163  */
 164 int connman_timeserver_remove(const char *server)
 165 {
 166         struct connman_timeserver_driver *driver;
 167
 168         DBG("server %s", server);
 169
 170         if (server == NULL)
 171                 return -EINVAL;
 172
 173         driver = g_hash_table_lookup(server_hash, server);
 174         if (driver == NULL)
 175                 return -EINVAL;
 176
 177         g_hash_table_remove(server_hash, server);
 178
 179         if (driver->remove == NULL)
 180                 return -ENOENT;
 181
 182         return driver->remove(server);
 183 }
 184
 185 void connman_timeserver_sync(void)
 186 {
 187         GSList *list;
 188
 189         DBG("");
 190
 191         for (list = driver_list; list; list = list->next) {
 192                 struct connman_timeserver_driver *driver = list->data;
 193
 194                 if (driver->sync == NULL)
 195                         continue;
 196
 197                 driver->sync();
 198         }
 199 }
 200
 201 int __connman_timeserver_system_append(const char *server)
 202 {
 203         int len;
 204         char **servers = NULL;
 205
 206         if (server == NULL) {
 207                 save_timeservers(servers);
 208                 return 0;
 209         }
 210
 211         DBG("server %s", server);
 212
 213         servers = load_timeservers();
 214
 215         if (servers != NULL) {
 216                 int i;
 217
 218                 for (i = 0; servers[i] != NULL; i++)
 219                         if (g_strcmp0(servers[i], server) == 0) {
 220                                 g_strfreev(servers);
 221                                 return -EEXIST;
 222                         }
 223
 224                 len = g_strv_length(servers);
 225                 servers = g_try_renew(char *, servers, len + 2);
 226         } else {
 227                 len = 0;
 228                 servers = g_try_new0(char *, len + 2);
 229         }
 230
 231         if (servers == NULL)
 232                 return -ENOMEM;
 233
 234         servers[len] = g_strdup(server);
 235         servers[len + 1] = NULL;
 236
 237         save_timeservers(servers);
 238
 239         g_strfreev(servers);
 240
 241         return 0;
 242 }
 243
 244 int __connman_timeserver_system_remove(const char *server)
 245 {
 246         char **servers;
 247         char **temp;
 248         int len, i, j;
 249
 250         if (server == NULL)
 251                 return -EINVAL;
 252
 253         DBG("server %s", server);
 254
 255         servers = load_timeservers();
 256
 257         if (servers == NULL)
 258                 return 0;
 259
 260         len = g_strv_length(servers);
 261         if (len == 1) {
 262                 if (g_strcmp0(servers[0], server) != 0) {
 263                         g_strfreev(servers);
 264                         return 0;
 265                 }
 266
 267                 g_strfreev(servers);
 268                 servers = NULL;
 269                 save_timeservers(servers);
 270                 return 0;
 271         }
 272
 273         temp = g_try_new0(char *, len - 1);
 274         if (temp == NULL) {
 275                         g_strfreev(servers);
 276                         return -ENOMEM;
 277         }
 278
 279         for (i = 0, j = 0; i < len; i++) {
 280                 if (g_strcmp0(servers[i], server) != 0) {
 281                         temp[j] = g_strdup(servers[i]);
 282                         j++;
 283                 }
 284         }
 285         temp[len - 1] = NULL;
 286
 287         g_strfreev(servers);
 288         servers = g_strdupv(temp);
 289         g_strfreev(temp);
 290
 291         save_timeservers(servers);
 292         g_strfreev(servers);
 293
 294         return 0;
 295 }
 296
 297 char **__connman_timeserver_system_get()
 298 {
 299         char **servers;
 300
 301         servers = load_timeservers();
 302         return servers;
 303 }
 304
 305 int __connman_timeserver_init(void)
 306 {
 307         DBG("");
 308
 309         server_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
 310                                                 g_free, NULL);
 311
 312         return 0;
 313 }
 314
 315 void __connman_timeserver_cleanup(void)
 316 {
 317         DBG("");
 318
 319         g_hash_table_destroy(server_hash);
 320 }