LCOV - code coverage report
Current view: top level - libsystemd/sd-netlink - netlink-util.c (source / functions) Hit Total Coverage
Test: systemd test coverage Lines: 17 77 22.1 %
Date: 2015-07-29 18:47:03 Functions: 4 9 44.4 %

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

Generated by: LCOV version 1.11