src/libsystemd/sd-rtnl/rtnl-util.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 Tom Gundersen <teg@jklm.no>
   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 <netinet/ether.h>
  23
  24 #include "sd-rtnl.h"
  25
  26 #include "rtnl-util.h"
  27 #include "rtnl-internal.h"
  28
  29 int rtnl_set_link_name(sd_rtnl **rtnl, int ifindex, const char *name) {
  30         _cleanup_rtnl_message_unref_ sd_rtnl_message *message = NULL;
  31         int r;
  32
  33         assert(rtnl);
  34         assert(ifindex > 0);
  35         assert(name);
  36
  37         if (!*rtnl) {
  38                 r = sd_rtnl_open(rtnl, 0);
  39                 if (r < 0)
  40                         return r;
  41         }
  42
  43         r = sd_rtnl_message_new_link(*rtnl, &message, RTM_SETLINK, ifindex);
  44         if (r < 0)
  45                 return r;
  46
  47         r = sd_rtnl_message_append_string(message, IFLA_IFNAME, name);
  48         if (r < 0)
  49                 return r;
  50
  51         r = sd_rtnl_call(*rtnl, message, 0, NULL);
  52         if (r < 0)
  53                 return r;
  54
  55         return 0;
  56 }
  57
  58 int rtnl_set_link_properties(sd_rtnl **rtnl, int ifindex, const char *alias,
  59                              const struct ether_addr *mac, unsigned mtu) {
  60         _cleanup_rtnl_message_unref_ sd_rtnl_message *message = NULL;
  61         int r;
  62
  63         assert(rtnl);
  64         assert(ifindex > 0);
  65
  66         if (!alias && !mac && mtu == 0)
  67                 return 0;
  68
  69         if (!*rtnl) {
  70                 r = sd_rtnl_open(rtnl, 0);
  71                 if (r < 0)
  72                         return r;
  73         }
  74
  75         r = sd_rtnl_message_new_link(*rtnl, &message, RTM_SETLINK, ifindex);
  76         if (r < 0)
  77                 return r;
  78
  79         if (alias) {
  80                 r = sd_rtnl_message_append_string(message, IFLA_IFALIAS, alias);
  81                 if (r < 0)
  82                         return r;
  83         }
  84
  85         if (mac) {
  86                 r = sd_rtnl_message_append_ether_addr(message, IFLA_ADDRESS, mac);
  87                 if (r < 0)
  88                         return r;
  89         }
  90
  91         if (mtu > 0) {
  92                 r = sd_rtnl_message_append_u32(message, IFLA_MTU, mtu);
  93                 if (r < 0)
  94                         return r;
  95         }
  96
  97         r = sd_rtnl_call(*rtnl, message, 0, NULL);
  98         if (r < 0)
  99                 return r;
 100
 101         return 0;
 102 }
 103
 104 int rtnl_message_new_synthetic_error(int error, uint32_t serial, sd_rtnl_message **ret) {
 105         struct nlmsgerr *err;
 106         int r;
 107
 108         assert(error <= 0);
 109
 110         r = message_new(NULL, ret, NLMSG_ERROR);
 111         if (r < 0)
 112                 return r;
 113
 114         (*ret)->hdr->nlmsg_seq = serial;
 115
 116         err = NLMSG_DATA((*ret)->hdr);
 117
 118         err->error = error;
 119
 120         return 0;
 121 }
 122
 123 bool rtnl_message_type_is_neigh(uint16_t type) {
 124         switch (type) {
 125                 case RTM_NEWNEIGH:
 126                 case RTM_GETNEIGH:
 127                 case RTM_DELNEIGH:
 128                         return true;
 129                 default:
 130                         return false;
 131         }
 132 }
 133
 134 bool rtnl_message_type_is_route(uint16_t type) {
 135         switch (type) {
 136                 case RTM_NEWROUTE:
 137                 case RTM_GETROUTE:
 138                 case RTM_DELROUTE:
 139                         return true;
 140                 default:
 141                         return false;
 142         }
 143 }
 144
 145 bool rtnl_message_type_is_link(uint16_t type) {
 146         switch (type) {
 147                 case RTM_NEWLINK:
 148                 case RTM_SETLINK:
 149                 case RTM_GETLINK:
 150                 case RTM_DELLINK:
 151                         return true;
 152                 default:
 153                         return false;
 154         }
 155 }
 156
 157 bool rtnl_message_type_is_addr(uint16_t type) {
 158         switch (type) {
 159                 case RTM_NEWADDR:
 160                 case RTM_GETADDR:
 161                 case RTM_DELADDR:
 162                         return true;
 163                 default:
 164                         return false;
 165         }
 166 }
 167
 168 int rtnl_log_parse_error(int r) {
 169         return log_error_errno(r, "Failed to parse netlink message: %m");
 170 }
 171
 172 int rtnl_log_create_error(int r) {
 173         return log_error_errno(r, "Failed to create netlink message: %m");
 174 }