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         bool need_update = false;
  62         int r;
  63
  64         assert(rtnl);
  65         assert(ifindex > 0);
  66
  67         if (!alias && !mac && mtu == 0)
  68                 return 0;
  69
  70         r = sd_rtnl_message_new_link(rtnl, &message, RTM_SETLINK, ifindex);
  71         if (r < 0)
  72                 return r;
  73
  74         if (alias) {
  75                 r = sd_rtnl_message_append_string(message, IFLA_IFALIAS, alias);
  76                 if (r < 0)
  77                         return r;
  78
  79                 need_update = true;
  80
  81         }
  82
  83         if (mac) {
  84                 r = sd_rtnl_message_append_ether_addr(message, IFLA_ADDRESS, mac);
  85                 if (r < 0)
  86                         return r;
  87
  88                 need_update = true;
  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                 need_update = true;
  97         }
  98
  99         if  (need_update) {
 100                 r = sd_rtnl_call(rtnl, message, 0, NULL);
 101                 if (r < 0)
 102                         return r;
 103         }
 104
 105         return 0;
 106 }
 107
 108 int rtnl_message_new_synthetic_error(int error, uint32_t serial, sd_rtnl_message **ret) {
 109         struct nlmsgerr *err;
 110         int r;
 111
 112         assert(error <= 0);
 113
 114         r = message_new(NULL, ret, NLMSG_SPACE(sizeof(struct nlmsgerr)));
 115         if (r < 0)
 116                 return r;
 117
 118         (*ret)->hdr->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
 119         (*ret)->hdr->nlmsg_type = NLMSG_ERROR;
 120         (*ret)->hdr->nlmsg_seq = serial;
 121
 122         err = NLMSG_DATA((*ret)->hdr);
 123
 124         err->error = error;
 125
 126         return 0;
 127 }
 128
 129 bool rtnl_message_type_is_route(uint16_t type) {
 130         switch (type) {
 131                 case RTM_NEWROUTE:
 132                 case RTM_GETROUTE:
 133                 case RTM_DELROUTE:
 134                         return true;
 135                 default:
 136                         return false;
 137         }
 138 }
 139
 140 bool rtnl_message_type_is_link(uint16_t type) {
 141         switch (type) {
 142                 case RTM_NEWLINK:
 143                 case RTM_SETLINK:
 144                 case RTM_GETLINK:
 145                 case RTM_DELLINK:
 146                         return true;
 147                 default:
 148                         return false;
 149         }
 150 }
 151
 152 bool rtnl_message_type_is_addr(uint16_t type) {
 153         switch (type) {
 154                 case RTM_NEWADDR:
 155                 case RTM_GETADDR:
 156                 case RTM_DELADDR:
 157                         return true;
 158                 default:
 159                         return false;
 160         }
 161 }
 162
 163 int rtnl_log_parse_error(int r) {
 164         log_error("Failed to parse netlink message: %s", strerror(-r));
 165         return r;
 166 }
 167
 168 int rtnl_log_create_error(int r) {
 169         log_error("Failed to create netlink message: %s", strerror(-r));
 170         return r;
 171 }