src/timesync/timesyncd-server.c

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