ip/ipmaddr.c

   1 /*
   2  * ipmaddr.c            "ip maddress".
   3  *
   4  *              This program is free software; you can redistribute it and/or
   5  *              modify it under the terms of the GNU General Public License
   6  *              as published by the Free Software Foundation; either version
   7  *              2 of the License, or (at your option) any later version.
   8  *
   9  * Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  10  *
  11  */
  12
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <unistd.h>
  16 #include <fcntl.h>
  17 #include <sys/ioctl.h>
  18 #include <sys/socket.h>
  19 #include <netinet/in.h>
  20 #include <arpa/inet.h>
  21 #include <string.h>
  22
  23 #include <linux/netdevice.h>
  24 #include <linux/if.h>
  25 #include <linux/if_arp.h>
  26 #include <linux/sockios.h>
  27
  28 #include "rt_names.h"
  29 #include "utils.h"
  30 #include "ip_common.h"
  31 #include "json_print.h"
  32
  33 static struct {
  34         char *dev;
  35         int  family;
  36 } filter;
  37
  38 static void usage(void) __attribute__((noreturn));
  39
  40 static void usage(void)
  41 {
  42         fprintf(stderr,
  43                 "Usage: ip maddr [ add | del ] MULTIADDR dev STRING\n"
  44                 "       ip maddr show [ dev STRING ]\n");
  45         exit(-1);
  46 }
  47
  48 static int parse_hex(char *str, unsigned char *addr, size_t size)
  49 {
  50         int len = 0;
  51
  52         while (*str && (len < 2 * size)) {
  53                 int tmp;
  54
  55                 if (str[1] == 0)
  56                         return -1;
  57                 if (sscanf(str, "%02x", &tmp) != 1)
  58                         return -1;
  59                 addr[len] = tmp;
  60                 len++;
  61                 str += 2;
  62         }
  63         return len;
  64 }
  65
  66 struct ma_info {
  67         struct ma_info *next;
  68         int             index;
  69         int             users;
  70         char            *features;
  71         char            name[IFNAMSIZ];
  72         inet_prefix     addr;
  73 };
  74
  75 static void maddr_ins(struct ma_info **lst, struct ma_info *m)
  76 {
  77         struct ma_info *mp;
  78
  79         for (; (mp = *lst) != NULL; lst = &mp->next) {
  80                 if (mp->index > m->index)
  81                         break;
  82         }
  83         m->next = *lst;
  84         *lst = m;
  85 }
  86
  87 static void read_dev_mcast(struct ma_info **result_p)
  88 {
  89         char buf[256];
  90         FILE *fp = fopen("/proc/net/dev_mcast", "r");
  91
  92         if (!fp)
  93                 return;
  94
  95         while (fgets(buf, sizeof(buf), fp)) {
  96                 char hexa[256];
  97                 struct ma_info m = { .addr.family = AF_PACKET };
  98                 int len;
  99                 int st;
 100
 101                 sscanf(buf, "%d%s%d%d%s", &m.index, m.name, &m.users, &st,
 102                        hexa);
 103                 if (filter.dev && strcmp(filter.dev, m.name))
 104                         continue;
 105
 106                 len = parse_hex(hexa, (unsigned char *)&m.addr.data, sizeof(m.addr.data));
 107                 if (len >= 0) {
 108                         struct ma_info *ma = malloc(sizeof(m));
 109
 110                         memcpy(ma, &m, sizeof(m));
 111                         ma->addr.bytelen = len;
 112                         ma->addr.bitlen = len<<3;
 113                         if (st)
 114                                 ma->features = "static";
 115                         maddr_ins(result_p, ma);
 116                 }
 117         }
 118         fclose(fp);
 119 }
 120
 121 static void read_igmp(struct ma_info **result_p)
 122 {
 123         struct ma_info m = {
 124                 .addr.family = AF_INET,
 125                 .addr.bitlen = 32,
 126                 .addr.bytelen = 4,
 127         };
 128         char buf[256];
 129         FILE *fp = fopen("/proc/net/igmp", "r");
 130
 131         if (!fp)
 132                 return;
 133         if (!fgets(buf, sizeof(buf), fp)) {
 134                 fclose(fp);
 135                 return;
 136         }
 137
 138         while (fgets(buf, sizeof(buf), fp)) {
 139                 struct ma_info *ma;
 140
 141                 if (buf[0] != '\t') {
 142                         size_t len;
 143
 144                         sscanf(buf, "%d%s", &m.index, m.name);
 145                         len = strlen(m.name);
 146                         if (m.name[len - 1] == ':')
 147                                 m.name[len - 1] = '\0';
 148                         continue;
 149                 }
 150
 151                 if (filter.dev && strcmp(filter.dev, m.name))
 152                         continue;
 153
 154                 sscanf(buf, "%08x%d", (__u32 *)&m.addr.data, &m.users);
 155
 156                 ma = malloc(sizeof(m));
 157                 memcpy(ma, &m, sizeof(m));
 158                 maddr_ins(result_p, ma);
 159         }
 160         fclose(fp);
 161 }
 162
 163
 164 static void read_igmp6(struct ma_info **result_p)
 165 {
 166         char buf[256];
 167         FILE *fp = fopen("/proc/net/igmp6", "r");
 168
 169         if (!fp)
 170                 return;
 171
 172         while (fgets(buf, sizeof(buf), fp)) {
 173                 char hexa[256];
 174                 struct ma_info m = { .addr.family = AF_INET6 };
 175                 int len;
 176
 177                 sscanf(buf, "%d%s%s%d", &m.index, m.name, hexa, &m.users);
 178
 179                 if (filter.dev && strcmp(filter.dev, m.name))
 180                         continue;
 181
 182                 len = parse_hex(hexa, (unsigned char *)&m.addr.data, sizeof(m.addr.data));
 183                 if (len >= 0) {
 184                         struct ma_info *ma = malloc(sizeof(m));
 185
 186                         memcpy(ma, &m, sizeof(m));
 187
 188                         ma->addr.bytelen = len;
 189                         ma->addr.bitlen = len<<3;
 190                         maddr_ins(result_p, ma);
 191                 }
 192         }
 193         fclose(fp);
 194 }
 195
 196 static void print_maddr(FILE *fp, struct ma_info *list)
 197 {
 198         print_string(PRINT_FP, NULL, "\t", NULL);
 199
 200         open_json_object(NULL);
 201         if (list->addr.family == AF_PACKET) {
 202                 SPRINT_BUF(b1);
 203
 204                 print_string(PRINT_FP, NULL, "link  ", NULL);
 205                 print_color_string(PRINT_ANY, COLOR_MAC, "link", "%s",
 206                                    ll_addr_n2a((void *)list->addr.data, list->addr.bytelen,
 207                                                0, b1, sizeof(b1)));
 208         } else {
 209                 print_string(PRINT_ANY, "family", "%-5s ",
 210                              family_name(list->addr.family));
 211                 print_color_string(PRINT_ANY, ifa_family_color(list->addr.family),
 212                                    "address", "%s",
 213                                    format_host(list->addr.family,
 214                                                -1, list->addr.data));
 215         }
 216
 217         if (list->users != 1)
 218                 print_uint(PRINT_ANY, "users", " users %u", list->users);
 219
 220         if (list->features)
 221                 print_string(PRINT_ANY, "features", " %s", list->features);
 222
 223         print_string(PRINT_FP, NULL, "\n", NULL);
 224         close_json_object();
 225 }
 226
 227 static void print_mlist(FILE *fp, struct ma_info *list)
 228 {
 229         int cur_index = 0;
 230
 231         new_json_obj(json);
 232         for (; list; list = list->next) {
 233
 234                 if (list->index != cur_index || oneline) {
 235                         if (cur_index) {
 236                                 close_json_array(PRINT_JSON, NULL);
 237                                 close_json_object();
 238                         }
 239                         open_json_object(NULL);
 240
 241                         print_uint(PRINT_ANY, "ifindex", "%d:", list->index);
 242                         print_color_string(PRINT_ANY, COLOR_IFNAME,
 243                                            "ifname", "\t%s", list->name);
 244                         print_nl();
 245                         cur_index = list->index;
 246
 247                         open_json_array(PRINT_JSON, "maddr");
 248                 }
 249
 250                 print_maddr(fp, list);
 251         }
 252         if (cur_index) {
 253                 close_json_array(PRINT_JSON, NULL);
 254                 close_json_object();
 255         }
 256
 257         delete_json_obj();
 258 }
 259
 260 static int multiaddr_list(int argc, char **argv)
 261 {
 262         struct ma_info *list = NULL;
 263
 264         if (!filter.family)
 265                 filter.family = preferred_family;
 266
 267         while (argc > 0) {
 268                 if (1) {
 269                         if (strcmp(*argv, "dev") == 0) {
 270                                 NEXT_ARG();
 271                         } else if (matches(*argv, "help") == 0)
 272                                 usage();
 273                         if (filter.dev)
 274                                 duparg2("dev", *argv);
 275                         filter.dev = *argv;
 276                 }
 277                 argv++; argc--;
 278         }
 279
 280         if (!filter.family || filter.family == AF_PACKET)
 281                 read_dev_mcast(&list);
 282         if (!filter.family || filter.family == AF_INET)
 283                 read_igmp(&list);
 284         if (!filter.family || filter.family == AF_INET6)
 285                 read_igmp6(&list);
 286         print_mlist(stdout, list);
 287         return 0;
 288 }
 289
 290 static int multiaddr_modify(int cmd, int argc, char **argv)
 291 {
 292         struct ifreq ifr = {};
 293         int family;
 294         int fd, len;
 295
 296         if (cmd == RTM_NEWADDR)
 297                 cmd = SIOCADDMULTI;
 298         else
 299                 cmd = SIOCDELMULTI;
 300
 301         while (argc > 0) {
 302                 if (strcmp(*argv, "dev") == 0) {
 303                         NEXT_ARG();
 304                         if (ifr.ifr_name[0])
 305                                 duparg("dev", *argv);
 306                         if (get_ifname(ifr.ifr_name, *argv))
 307                                 invarg("\"dev\" not a valid ifname", *argv);
 308                 } else {
 309                         if (matches(*argv, "address") == 0) {
 310                                 NEXT_ARG();
 311                         }
 312                         if (matches(*argv, "help") == 0)
 313                                 usage();
 314                         if (ifr.ifr_hwaddr.sa_data[0])
 315                                 duparg("address", *argv);
 316                         len = ll_addr_a2n(ifr.ifr_hwaddr.sa_data,
 317                                           sizeof(ifr.ifr_hwaddr.sa_data),
 318                                           *argv);
 319                         if (len < 0)
 320                                 exit(1);
 321
 322                         if (len != ETH_ALEN) {
 323                                 fprintf(stderr, "Error: Invalid address length %d - must be %d bytes\n", len, ETH_ALEN);
 324                                 exit(1);
 325                         }
 326                 }
 327                 argc--; argv++;
 328         }
 329         if (ifr.ifr_name[0] == 0) {
 330                 fprintf(stderr, "Not enough information: \"dev\" is required.\n");
 331                 exit(-1);
 332         }
 333
 334         switch (preferred_family) {
 335         case AF_INET6:
 336         case AF_PACKET:
 337         case AF_INET:
 338                 family = preferred_family;
 339                 break;
 340         default:
 341                 family = AF_INET;
 342         }
 343
 344         fd = socket(family, SOCK_DGRAM, 0);
 345         if (fd < 0) {
 346                 perror("Cannot create socket");
 347                 exit(1);
 348         }
 349         if (ioctl(fd, cmd, (char *)&ifr) != 0) {
 350                 perror("ioctl");
 351                 exit(1);
 352         }
 353         close(fd);
 354
 355         exit(0);
 356 }
 357
 358
 359 int do_multiaddr(int argc, char **argv)
 360 {
 361         if (argc < 1)
 362                 return multiaddr_list(0, NULL);
 363         if (matches(*argv, "add") == 0)
 364                 return multiaddr_modify(RTM_NEWADDR, argc-1, argv+1);
 365         if (matches(*argv, "delete") == 0)
 366                 return multiaddr_modify(RTM_DELADDR, argc-1, argv+1);
 367         if (matches(*argv, "list") == 0 || matches(*argv, "show") == 0
 368             || matches(*argv, "lst") == 0)
 369                 return multiaddr_list(argc-1, argv+1);
 370         if (matches(*argv, "help") == 0)
 371                 usage();
 372         fprintf(stderr, "Command \"%s\" is unknown, try \"ip maddr help\".\n", *argv);
 373         exit(-1);
 374 }