src/libsystemd-network/sd-dhcp-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 (C) 2013 Intel Corporation. All rights reserved.
   7   Copyright (C) 2014 Tom Gundersen
   8
   9   systemd is free software; you can redistribute it and/or modify it
  10   under the terms of the GNU Lesser General Public License as published by
  11   the Free Software Foundation; either version 2.1 of the License, or
  12   (at your option) any later version.
  13
  14   systemd is distributed in the hope that it will be useful, but
  15   WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17   Lesser General Public License for more details.
  18
  19   You should have received a copy of the GNU Lesser General Public License
  20   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  21 ***/
  22
  23 #include <sys/ioctl.h>
  24
  25 #include "sd-dhcp-server.h"
  26 #include "dhcp-server-internal.h"
  27 #include "dhcp-internal.h"
  28
  29 sd_dhcp_server *sd_dhcp_server_ref(sd_dhcp_server *server) {
  30         if (server)
  31                 assert_se(REFCNT_INC(server->n_ref) >= 2);
  32
  33         return server;
  34 }
  35
  36 sd_dhcp_server *sd_dhcp_server_unref(sd_dhcp_server *server) {
  37         if (server && REFCNT_DEC(server->n_ref) <= 0) {
  38                 log_dhcp_server(server, "UNREF");
  39
  40                 sd_dhcp_server_stop(server);
  41
  42                 sd_event_unref(server->event);
  43                 free(server);
  44         }
  45
  46         return NULL;
  47 }
  48
  49 int sd_dhcp_server_new(sd_dhcp_server **ret, int ifindex) {
  50         _cleanup_dhcp_server_unref_ sd_dhcp_server *server = NULL;
  51
  52         assert_return(ret, -EINVAL);
  53         assert_return(ifindex > 0, -EINVAL);
  54
  55         server = new0(sd_dhcp_server, 1);
  56         if (!server)
  57                 return -ENOMEM;
  58
  59         server->n_ref = REFCNT_INIT;
  60         server->fd = -1;
  61         server->index = ifindex;
  62
  63         *ret = server;
  64         server = NULL;
  65
  66         return 0;
  67 }
  68
  69 int sd_dhcp_server_attach_event(sd_dhcp_server *server, sd_event *event, int priority) {
  70         int r;
  71
  72         assert_return(server, -EINVAL);
  73         assert_return(!server->event, -EBUSY);
  74
  75         if (event)
  76                 server->event = sd_event_ref(event);
  77         else {
  78                 r = sd_event_default(&server->event);
  79                 if (r < 0)
  80                         return r;
  81         }
  82
  83         server->event_priority = priority;
  84
  85         return 0;
  86 }
  87
  88 int sd_dhcp_server_detach_event(sd_dhcp_server *server) {
  89         assert_return(server, -EINVAL);
  90
  91         server->event = sd_event_unref(server->event);
  92
  93         return 0;
  94 }
  95
  96 sd_event *sd_dhcp_server_get_event(sd_dhcp_server *server) {
  97         assert_return(server, NULL);
  98
  99         return server->event;
 100 }
 101
 102 int sd_dhcp_server_stop(sd_dhcp_server *server) {
 103         assert_return(server, -EINVAL);
 104
 105         server->receive_message =
 106                 sd_event_source_unref(server->receive_message);
 107
 108         server->fd = safe_close(server->fd);
 109
 110         log_dhcp_server(server, "STOPPED");
 111
 112         return 0;
 113 }
 114
 115 static int server_receive_message(sd_event_source *s, int fd,
 116                                   uint32_t revents, void *userdata) {
 117         _cleanup_free_ uint8_t *message = NULL;
 118         uint8_t cmsgbuf[CMSG_LEN(sizeof(struct in_pktinfo))];
 119         sd_dhcp_server *server = userdata;
 120         struct iovec iov = {};
 121         struct msghdr msg = {
 122                 .msg_iov = &iov,
 123                 .msg_iovlen = 1,
 124                 .msg_control = cmsgbuf,
 125                 .msg_controllen = sizeof(cmsgbuf),
 126         };
 127         struct cmsghdr *cmsg;
 128         int buflen = 0, len, r;
 129
 130         assert(server);
 131
 132         r = ioctl(fd, FIONREAD, &buflen);
 133         if (r < 0)
 134                 return r;
 135         if (buflen < 0)
 136                 return -EIO;
 137
 138         message = malloc0(buflen);
 139         if (!message)
 140                 return -ENOMEM;
 141
 142         iov.iov_base = message;
 143         iov.iov_len = buflen;
 144
 145         len = recvmsg(fd, &msg, 0);
 146         if (len < buflen)
 147                 return 0;
 148
 149         for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
 150                 if (cmsg->cmsg_level == IPPROTO_IP &&
 151                     cmsg->cmsg_type == IP_PKTINFO &&
 152                     cmsg->cmsg_len == CMSG_LEN(sizeof(struct in_pktinfo))) {
 153                         struct in_pktinfo *info = (struct in_pktinfo*)CMSG_DATA(cmsg);
 154
 155                         /* TODO figure out if this can be done as a filter on the socket, like for IPv6 */
 156                         if (server->index != info->ipi_ifindex)
 157                                 return 0;
 158
 159                         break;
 160                 }
 161         }
 162
 163         log_dhcp_server(server, "received message");
 164
 165         return 1;
 166 }
 167
 168 int sd_dhcp_server_start(sd_dhcp_server *server) {
 169         int r;
 170
 171         assert_return(server, -EINVAL);
 172         assert_return(server->event, -EINVAL);
 173         assert_return(!server->receive_message, -EBUSY);
 174         assert_return(server->fd == -1, -EBUSY);
 175
 176         r = dhcp_network_bind_udp_socket(INADDR_ANY, DHCP_PORT_SERVER);
 177         if (r < 0) {
 178                 sd_dhcp_server_stop(server);
 179                 return r;
 180         }
 181         server->fd = r;
 182
 183         r = sd_event_add_io(server->event, &server->receive_message,
 184                             server->fd, EPOLLIN,
 185                             server_receive_message, server);
 186         if (r < 0) {
 187                 sd_dhcp_server_stop(server);
 188                 return r;
 189         }
 190
 191         r = sd_event_source_set_priority(server->receive_message,
 192                                          server->event_priority);
 193         if (r < 0) {
 194                 sd_dhcp_server_stop(server);
 195                 return r;
 196         }
 197
 198         log_dhcp_server(server, "STARTED");
 199
 200         return 0;
 201 }