lib/libifconfig/libifconfig_carp.c

   1 /*
   2  * Copyright (c) 1983, 1993
   3  *  The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29 #include <sys/param.h>
  30 #include <sys/ioctl.h>
  31
  32 #include <net/if.h>
  33 #include <netinet/ip_carp.h>
  34 #include <netinet/ip_carp_nl.h>
  35
  36 #include <netlink/netlink.h>
  37 #include <netlink/netlink_generic.h>
  38 #include <netlink/netlink_snl.h>
  39 #include <netlink/netlink_snl_generic.h>
  40 #include <netlink/netlink_snl_route.h>
  41
  42 #include <string.h>
  43 #include <strings.h>
  44
  45 #include "libifconfig.h"
  46 #include "libifconfig_internal.h"
  47
  48 #include <stdio.h>
  49
  50 #define _OUT(_field)    offsetof(struct ifconfig_carp, _field)
  51 static struct snl_attr_parser ap_carp_get[] = {
  52         { .type = CARP_NL_VHID, .off = _OUT(carpr_vhid), .cb = snl_attr_get_uint32 },
  53         { .type = CARP_NL_STATE, .off = _OUT(carpr_state), .cb = snl_attr_get_uint32 },
  54         { .type = CARP_NL_ADVBASE, .off = _OUT(carpr_advbase), .cb = snl_attr_get_int32 },
  55         { .type = CARP_NL_ADVSKEW, .off = _OUT(carpr_advskew), .cb = snl_attr_get_int32 },
  56         { .type = CARP_NL_KEY, .off = _OUT(carpr_key), .cb = snl_attr_copy_string, .arg_u32 = CARP_KEY_LEN },
  57         { .type = CARP_NL_ADDR, .off = _OUT(carpr_addr), .cb = snl_attr_get_in_addr },
  58         { .type = CARP_NL_ADDR6, .off = _OUT(carpr_addr6), .cb = snl_attr_get_in6_addr },
  59 };
  60 #undef _OUT
  61
  62 SNL_DECLARE_GENL_PARSER(carp_get_parser, ap_carp_get);
  63
  64 static int
  65 _ifconfig_carp_get(ifconfig_handle_t *h, const char *name,
  66     struct ifconfig_carp *carp, size_t ncarp, uint32_t vhid)
  67 {
  68         struct snl_state ss = {};
  69         struct snl_errmsg_data e = {};
  70         struct snl_writer nw;
  71         struct nlmsghdr *hdr;
  72         size_t i = 0;
  73         uint32_t seq_id;
  74         int family_id;
  75
  76         ifconfig_error_clear(h);
  77
  78         bzero(carp, sizeof(*carp) * ncarp);
  79
  80         if (! snl_init(&ss, NETLINK_GENERIC)) {
  81                 ifconfig_error(h, NETLINK, ENOTSUP);
  82                 return (-1);
  83         }
  84
  85         snl_init_writer(&ss, &nw);
  86
  87         family_id = snl_get_genl_family(&ss, CARP_NL_FAMILY_NAME);
  88         if (family_id == 0) {
  89                 ifconfig_error(h, NETLINK, EPROTONOSUPPORT);
  90                 goto out;
  91         }
  92
  93         hdr = snl_create_genl_msg_request(&nw, family_id, CARP_NL_CMD_GET);
  94         hdr->nlmsg_flags |= NLM_F_DUMP;
  95
  96         snl_add_msg_attr_string(&nw, CARP_NL_IFNAME, name);
  97
  98         if (vhid != 0)
  99                 snl_add_msg_attr_u32(&nw, CARP_NL_VHID, vhid);
 100
 101         hdr = snl_finalize_msg(&nw);
 102         if (hdr == NULL) {
 103                 ifconfig_error(h, NETLINK, ENOMEM);
 104                 goto out;
 105         }
 106         seq_id = hdr->nlmsg_seq;
 107         if (! snl_send_message(&ss, hdr)) {
 108                 ifconfig_error(h, NETLINK, EIO);
 109                 goto out;
 110         }
 111
 112         while ((hdr = snl_read_reply_multi(&ss, seq_id, &e)) != NULL) {
 113                 if (e.error != 0) {
 114                         ifconfig_error(h, NETLINK, e.error);
 115                         break;
 116                 }
 117
 118                 if (i >= ncarp) {
 119                         ifconfig_error(h, NETLINK, E2BIG);
 120                         break;
 121                 }
 122
 123                 memset(&carp[i], 0, sizeof(carp[0]));
 124                 if (! snl_parse_nlmsg(&ss, hdr, &carp_get_parser, &carp[i]))
 125                         continue;
 126
 127                 i++;
 128                 carp[0].carpr_count = i;
 129
 130                 if (i > ncarp) {
 131                         ifconfig_error(h, NETLINK, E2BIG);
 132                         break;
 133                 }
 134         }
 135
 136 out:
 137         snl_free(&ss);
 138
 139         return (h->error.errcode ? -1 : 0);
 140 }
 141
 142 int
 143 ifconfig_carp_set_info(ifconfig_handle_t *h, const char *name,
 144     const struct ifconfig_carp *carpr)
 145 {
 146         struct snl_state ss = {};
 147         struct snl_writer nw;
 148         struct nlmsghdr *hdr;
 149         int family_id;
 150         uint32_t seq_id;
 151
 152         ifconfig_error_clear(h);
 153
 154         if (! snl_init(&ss, NETLINK_GENERIC)) {
 155                 ifconfig_error(h, NETLINK, ENOTSUP);
 156                 return (-1);
 157         }
 158
 159         snl_init_writer(&ss, &nw);
 160
 161         family_id = snl_get_genl_family(&ss, CARP_NL_FAMILY_NAME);
 162         if (family_id == 0) {
 163                 ifconfig_error(h, NETLINK, EPROTONOSUPPORT);
 164                 return (-1);
 165         }
 166         hdr = snl_create_genl_msg_request(&nw, family_id, CARP_NL_CMD_SET);
 167
 168         snl_add_msg_attr_u32(&nw, CARP_NL_VHID, carpr->carpr_vhid);
 169         snl_add_msg_attr_u32(&nw, CARP_NL_STATE, carpr->carpr_state);
 170         snl_add_msg_attr_s32(&nw, CARP_NL_ADVBASE, carpr->carpr_advbase);
 171         snl_add_msg_attr_s32(&nw, CARP_NL_ADVSKEW, carpr->carpr_advskew);
 172         snl_add_msg_attr_string(&nw, CARP_NL_IFNAME, name);
 173         snl_add_msg_attr(&nw, CARP_NL_ADDR, sizeof(carpr->carpr_addr),
 174             &carpr->carpr_addr);
 175         snl_add_msg_attr(&nw, CARP_NL_ADDR6, sizeof(carpr->carpr_addr6),
 176             &carpr->carpr_addr6);
 177         snl_add_msg_attr_string(&nw, CARP_NL_KEY, carpr->carpr_key);
 178
 179         hdr = snl_finalize_msg(&nw);
 180         if (hdr == NULL) {
 181                 ifconfig_error(h, NETLINK, ENOMEM);
 182                 goto out;
 183         }
 184
 185         seq_id = hdr->nlmsg_seq;
 186         if (! snl_send_message(&ss, hdr)) {
 187                 ifconfig_error(h, NETLINK, EIO);
 188                 goto out;
 189         }
 190
 191         struct snl_errmsg_data e = { };
 192         if (! snl_read_reply_code(&ss, seq_id, &e))
 193                 ifconfig_error(h, NETLINK, e.error);
 194
 195 out:
 196         snl_free(&ss);
 197
 198         return (h->error.errcode ? -1 : 0);
 199 }
 200
 201 int
 202 ifconfig_carp_get_vhid(ifconfig_handle_t *h, const char *name,
 203     struct ifconfig_carp *carp, uint32_t vhid)
 204 {
 205         return (_ifconfig_carp_get(h, name, carp, 1, vhid));
 206 }
 207
 208 int
 209 ifconfig_carp_get_info(ifconfig_handle_t *h, const char *name,
 210     struct ifconfig_carp *carp, size_t ncarp)
 211 {
 212         return (_ifconfig_carp_get(h, name, carp, ncarp, 0));
 213 }