src/timesync/timesyncd-server.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2014 Kay Sievers, Lennart Poettering
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include "alloc-util.h"
  21 #include "timesyncd-server.h"
  22
  23 int server_address_new(
  24                 ServerName *n,
  25                 ServerAddress **ret,
  26                 const union sockaddr_union *sockaddr,
  27                 socklen_t socklen) {
  28
  29         ServerAddress *a, *tail;
  30
  31         assert(n);
  32         assert(sockaddr);
  33         assert(socklen >= offsetof(struct sockaddr, sa_data));
  34         assert(socklen <= sizeof(union sockaddr_union));
  35
  36         a = new0(ServerAddress, 1);
  37         if (!a)
  38                 return -ENOMEM;
  39
  40         memcpy(&a->sockaddr, sockaddr, socklen);
  41         a->socklen = socklen;
  42
  43         LIST_FIND_TAIL(addresses, n->addresses, tail);
  44         LIST_INSERT_AFTER(addresses, n->addresses, tail, a);
  45         a->name = n;
  46
  47         if (ret)
  48                 *ret = a;
  49
  50         return 0;
  51 }
  52
  53 ServerAddress* server_address_free(ServerAddress *a) {
  54         if (!a)
  55                 return NULL;
  56
  57         if (a->name) {
  58                 LIST_REMOVE(addresses, a->name->addresses, a);
  59
  60                 if (a->name->manager && a->name->manager->current_server_address == a)
  61                         manager_set_server_address(a->name->manager, NULL);
  62         }
  63
  64         free(a);
  65         return NULL;
  66 }
  67
  68 int server_name_new(
  69                 Manager *m,
  70                 ServerName **ret,
  71                 ServerType type,
  72                 const char *string) {
  73
  74         ServerName *n, *tail;
  75
  76         assert(m);
  77         assert(string);
  78
  79         n = new0(ServerName, 1);
  80         if (!n)
  81                 return -ENOMEM;
  82
  83         n->type = type;
  84         n->string = strdup(string);
  85         if (!n->string) {
  86                 free(n);
  87                 return -ENOMEM;
  88         }
  89
  90         if (type == SERVER_SYSTEM) {
  91                 LIST_FIND_TAIL(names, m->system_servers, tail);
  92                 LIST_INSERT_AFTER(names, m->system_servers, tail, n);
  93         } else if (type == SERVER_LINK) {
  94                 LIST_FIND_TAIL(names, m->link_servers, tail);
  95                 LIST_INSERT_AFTER(names, m->link_servers, tail, n);
  96         } else if (type == SERVER_FALLBACK) {
  97                 LIST_FIND_TAIL(names, m->fallback_servers, tail);
  98                 LIST_INSERT_AFTER(names, m->fallback_servers, tail, n);
  99         } else
 100                 assert_not_reached("Unknown server type");
 101
 102         n->manager = m;
 103
 104         if (type != SERVER_FALLBACK &&
 105             m->current_server_name &&
 106             m->current_server_name->type == SERVER_FALLBACK)
 107                 manager_set_server_name(m, NULL);
 108
 109         log_debug("Added new server %s.", string);
 110
 111         if (ret)
 112                 *ret = n;
 113
 114         return 0;
 115 }
 116
 117 ServerName *server_name_free(ServerName *n) {
 118         if (!n)
 119                 return NULL;
 120
 121         server_name_flush_addresses(n);
 122
 123         if (n->manager) {
 124                 if (n->type == SERVER_SYSTEM)
 125                         LIST_REMOVE(names, n->manager->system_servers, n);
 126                 else if (n->type == SERVER_LINK)
 127                         LIST_REMOVE(names, n->manager->link_servers, n);
 128                 else if (n->type == SERVER_FALLBACK)
 129                         LIST_REMOVE(names, n->manager->fallback_servers, n);
 130                 else
 131                         assert_not_reached("Unknown server type");
 132
 133                 if (n->manager->current_server_name == n)
 134                         manager_set_server_name(n->manager, NULL);
 135         }
 136
 137         log_debug("Removed server %s.", n->string);
 138
 139         free(n->string);
 140         free(n);
 141
 142         return NULL;
 143 }
 144
 145 void server_name_flush_addresses(ServerName *n) {
 146         assert(n);
 147
 148         while (n->addresses)
 149                 server_address_free(n->addresses);
 150 }