src/core/loopback-setup.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 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 <errno.h>
  23 #include <sys/socket.h>
  24 #include <net/if.h>
  25 #include <asm/types.h>
  26 #include <netinet/in.h>
  27 #include <linux/rtnetlink.h>
  28 #include <string.h>
  29 #include <stdlib.h>
  30 #include <unistd.h>
  31
  32 #include "util.h"
  33 #include "macro.h"
  34 #include "loopback-setup.h"
  35 #include "socket-util.h"
  36 #include "sd-rtnl.h"
  37 #include "rtnl-util.h"
  38
  39 static int pipe_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
  40         int *counter = userdata;
  41         int r;
  42
  43         (*counter) --;
  44
  45         r = sd_rtnl_message_get_errno(m);
  46
  47         return r == -EEXIST ? 0 : r;
  48 }
  49
  50 static int add_adresses(sd_rtnl *rtnl, int if_loopback, uint32_t ipv4_address, int *counter) {
  51         _cleanup_sd_rtnl_message_unref_ sd_rtnl_message *ipv4 = NULL, *ipv6 = NULL;
  52         int r;
  53
  54         r = sd_rtnl_message_addr_new(RTM_NEWADDR, if_loopback, AF_INET, 8, IFA_F_PERMANENT, RT_SCOPE_HOST, &ipv4);
  55         if (r < 0)
  56                 return r;
  57
  58         r = sd_rtnl_message_append(ipv4, IFA_LOCAL, &ipv4_address);
  59         if (r < 0)
  60                 return r;
  61
  62         r = sd_rtnl_call_async(rtnl, ipv4, &pipe_handler, counter, 0, NULL);
  63         if (r < 0)
  64                 return r;
  65
  66         (*counter) ++;
  67
  68         if (!socket_ipv6_is_supported())
  69                 return 0;
  70
  71         r = sd_rtnl_message_addr_new(RTM_NEWADDR, if_loopback, AF_INET6, 128, 0, 0, &ipv6);
  72         if (r < 0)
  73                 return r;
  74
  75         r = sd_rtnl_message_append(ipv6, IFA_LOCAL, &in6addr_loopback);
  76         if (r < 0)
  77                 return r;
  78
  79         r = sd_rtnl_call_async(rtnl, ipv6, &pipe_handler, counter, 0, NULL);
  80         if (r < 0)
  81                 return r;
  82
  83         (*counter) ++;
  84
  85         return 0;
  86 }
  87
  88 static int start_interface(sd_rtnl *rtnl, int if_loopback, uint32_t ipv4_address, int *counter) {
  89         _cleanup_sd_rtnl_message_unref_ sd_rtnl_message *req = NULL;
  90         int r;
  91
  92         r = sd_rtnl_message_link_new(RTM_NEWLINK, if_loopback, &req);
  93         if (r < 0)
  94                 return r;
  95
  96         r = sd_rtnl_message_link_set_flags(req, IFF_UP);
  97         if (r < 0)
  98                 return r;
  99
 100         r = sd_rtnl_message_append(req, IFA_LOCAL, &ipv4_address);
 101         if (r < 0)
 102                 return r;
 103
 104         r = sd_rtnl_call_async(rtnl, req, &pipe_handler, counter, 0, NULL);
 105         if (r < 0)
 106                 return r;
 107
 108         (*counter) ++;
 109
 110         return 0;
 111 }
 112
 113 static int check_loopback(void) {
 114         int r;
 115         _cleanup_close_ int fd = -1;
 116         union {
 117                 struct sockaddr sa;
 118                 struct sockaddr_in in;
 119         } sa = {
 120                 .in.sin_family = AF_INET,
 121                 .in.sin_addr.s_addr = INADDR_LOOPBACK,
 122         };
 123
 124         /* If we failed to set up the loop back device, check whether
 125          * it might already be set up */
 126
 127         fd = socket(AF_INET, SOCK_DGRAM|SOCK_NONBLOCK|SOCK_CLOEXEC, 0);
 128         if (fd < 0)
 129                 return -errno;
 130
 131         if (bind(fd, &sa.sa, sizeof(sa.in)) >= 0)
 132                 r = 1;
 133         else
 134                 r = errno == EADDRNOTAVAIL ? 0 : -errno;
 135
 136         return r;
 137 }
 138
 139 int loopback_setup(void) {
 140         _cleanup_sd_rtnl_unref_ sd_rtnl *rtnl = NULL;
 141         int r, if_loopback, counter = 0;
 142         bool eperm = false;
 143         uint32_t ipv4_address = htonl(INADDR_LOOPBACK);
 144
 145         errno = 0;
 146         if_loopback = (int) if_nametoindex("lo");
 147         if (if_loopback <= 0)
 148                 return errno ? -errno : -ENODEV;
 149
 150         r = sd_rtnl_open(0, &rtnl);
 151         if (r < 0)
 152                 return r;
 153
 154         r = add_adresses(rtnl, if_loopback, ipv4_address, &counter);
 155         if (r < 0)
 156                 return r;
 157
 158         r = start_interface(rtnl, if_loopback, ipv4_address, &counter);
 159         if (r < 0)
 160                 return r;
 161
 162         while (counter > 0) {
 163                 r = sd_rtnl_wait(rtnl, 0);
 164                 if (r < 0)
 165                         return r;
 166
 167                 r = sd_rtnl_process(rtnl, 0);
 168                 if (r < 0) {
 169                         if (r == -EPERM)
 170                                 eperm = true;
 171                         else {
 172                                 log_warning("Failed to configure loopback device: %s", strerror(-r));
 173                                 return r;
 174                         }
 175                 }
 176         }
 177
 178         if (eperm && check_loopback() < 0) {
 179                 log_warning("Failed to configure loopback device: %s", strerror(EPERM));
 180                 return -EPERM;
 181         }
 182
 183         return 0;
 184 }