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  * Changes:     Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  12  *              20010404 - use setlocale
  13  *
  14  */
  15
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <unistd.h>
  19 #include <syslog.h>
  20 #include <fcntl.h>
  21 #include <sys/ioctl.h>
  22 #include <sys/socket.h>
  23 #include <netinet/in.h>
  24 #include <arpa/inet.h>
  25 #include <string.h>
  26
  27 #if defined(__GLIBC__) && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1))
  28 #include <net/if.h>
  29 #else
  30 #include <linux/if.h>
  31 #endif
  32
  33 #include "config.h"
  34 #include "intl.h"
  35 #include "util-ank.h"
  36 #include "net-support.h"
  37 #include "version.h"
  38 #include "pathnames.h"
  39
  40 char filter_dev[16];
  41 int  filter_family;
  42
  43 /* These have nothing to do with rtnetlink. :-) */
  44 #define NEWADDR         1
  45 #define DELADDR         2
  46
  47 char *Release = RELEASE,
  48      *Version = "ipmaddr 1.1",
  49      *Signature = "Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>";
  50
  51 static void version(void)
  52 {
  53         printf("%s\n%s\n%s\n", Release, Version, Signature);
  54         exit(E_VERSION);
  55 }
  56
  57 static void usage(void) __attribute__((noreturn));
  58
  59 static void usage(void)
  60 {
  61         fprintf(stderr, _("Usage: ipmaddr [ add | del ] MULTIADDR dev STRING\n"));
  62         fprintf(stderr, _("       ipmaddr show [ dev STRING ] [ ipv4 | ipv6 | link | all ]\n"));
  63         fprintf(stderr, _("       ipmaddr -V | -version\n"));
  64         exit(-1);
  65 }
  66
  67 static void print_lla(FILE *fp, int len, unsigned char *addr)
  68 {
  69         int i;
  70         for (i=0; i<len; i++) {
  71                 if (i==0)
  72                         fprintf(fp, "%02x", addr[i]);
  73                 else
  74                         fprintf(fp, ":%02x", addr[i]);
  75         }
  76 }
  77
  78 static int parse_lla(char *str, unsigned char *addr)
  79 {
  80         int len=0;
  81
  82         while (*str) {
  83                 int tmp;
  84                 if (str[0] == ':' || str[0] == '.') {
  85                         str++;
  86                         continue;
  87                 }
  88                 if (str[1] == 0)
  89                         return -1;
  90                 if (sscanf(str, "%02x", &tmp) != 1)
  91                         return -1;
  92                 addr[len] = tmp;
  93                 len++;
  94                 str += 2;
  95         }
  96         return len;
  97 }
  98
  99 static int parse_hex(char *str, unsigned char *addr)
 100 {
 101         int len=0;
 102
 103         while (*str) {
 104                 int tmp;
 105                 if (str[1] == 0)
 106                         return -1;
 107                 if (sscanf(str, "%02x", &tmp) != 1)
 108                         return -1;
 109                 addr[len] = tmp;
 110                 len++;
 111                 str += 2;
 112         }
 113         return len;
 114 }
 115
 116 struct ma_info
 117 {
 118         struct ma_info *next;
 119         int             index;
 120         int             users;
 121         char            *features;
 122         char            name[IFNAMSIZ];
 123         inet_prefix     addr;
 124 };
 125
 126 void maddr_ins(struct ma_info **lst, struct ma_info *m)
 127 {
 128         struct ma_info *mp;
 129
 130         for (; (mp=*lst) != NULL; lst = &mp->next) {
 131                 if (mp->index > m->index)
 132                         break;
 133         }
 134         m->next = *lst;
 135         *lst = m;
 136 }
 137
 138 void read_dev_mcast(struct ma_info **result_p)
 139 {
 140         char buf[256];
 141         FILE *fp = fopen(_PATH_PROCNET_DEV_MCAST, "r");
 142
 143         if (!fp)
 144                 return;
 145
 146         while (fgets(buf, sizeof(buf), fp)) {
 147                 char hexa[256];
 148                 struct ma_info m;
 149                 int len;
 150                 int st;
 151
 152                 memset(&m, 0, sizeof(m));
 153                 sscanf(buf, "%d%s%d%d%s", &m.index, m.name, &m.users, &st,
 154                        hexa);
 155                 if (filter_dev[0] && strcmp(filter_dev, m.name))
 156                         continue;
 157
 158                 m.addr.family = AF_PACKET;
 159
 160                 len = parse_hex(hexa, (unsigned char*)&m.addr.data);
 161                 if (len >= 0) {
 162                         struct ma_info *ma = malloc(sizeof(m));
 163
 164                         memcpy(ma, &m, sizeof(m));
 165                         ma->addr.bytelen = len;
 166                         ma->addr.bitlen = len<<3;
 167                         if (st)
 168                                 ma->features = "static";
 169                         maddr_ins(result_p, ma);
 170                 }
 171         }
 172         fclose(fp);
 173 }
 174
 175 void read_igmp(struct ma_info **result_p)
 176 {
 177         struct ma_info m;
 178         char buf[256];
 179         FILE *fp = fopen(_PATH_PROCNET_IGMP, "r");
 180
 181         if (!fp)
 182                 return;
 183         memset(&m, 0, sizeof(m));
 184         fgets(buf, sizeof(buf), fp);
 185
 186         m.addr.family = AF_INET;
 187         m.addr.bitlen = 32;
 188         m.addr.bytelen = 4;
 189
 190         while (fgets(buf, sizeof(buf), fp)) {
 191                 struct ma_info *ma = malloc(sizeof(m));
 192
 193                 if (buf[0] != '\t') {
 194                         sscanf(buf, "%d%s", &m.index, m.name);
 195                         continue;
 196                 }
 197
 198                 if (filter_dev[0] && strcmp(filter_dev, m.name))
 199                         continue;
 200
 201                 sscanf(buf, "%08x%d", (__u32*)&m.addr.data, &m.users);
 202
 203                 ma = malloc(sizeof(m));
 204                 memcpy(ma, &m, sizeof(m));
 205                 maddr_ins(result_p, ma);
 206         }
 207         fclose(fp);
 208 }
 209
 210
 211 void read_igmp6(struct ma_info **result_p)
 212 {
 213         char buf[256];
 214         FILE *fp = fopen(_PATH_PROCNET_IGMP6, "r");
 215
 216         if (!fp)
 217                 return;
 218
 219         while (fgets(buf, sizeof(buf), fp)) {
 220                 char hexa[256];
 221                 struct ma_info m;
 222                 int len;
 223
 224                 memset(&m, 0, sizeof(m));
 225                 sscanf(buf, "%d%s%s%d", &m.index, m.name, hexa, &m.users);
 226
 227                 if (filter_dev[0] && strcmp(filter_dev, m.name))
 228                         continue;
 229
 230                 m.addr.family = AF_INET6;
 231
 232                 len = parse_hex(hexa, (unsigned char*)&m.addr.data);
 233                 if (len >= 0) {
 234                         struct ma_info *ma = malloc(sizeof(m));
 235
 236                         memcpy(ma, &m, sizeof(m));
 237
 238                         ma->addr.bytelen = len;
 239                         ma->addr.bitlen = len<<3;
 240                         maddr_ins(result_p, ma);
 241                 }
 242         }
 243         fclose(fp);
 244 }
 245
 246 static void print_maddr(FILE *fp, struct ma_info *list)
 247 {
 248         fprintf(fp, "\t");
 249
 250         if (list->addr.family == AF_PACKET) {
 251                 fprintf(fp, "link  ");
 252                 print_lla(fp, list->addr.bytelen, (unsigned char*)list->addr.data);
 253         } else {
 254                 char abuf[256];
 255                 switch(list->addr.family) {
 256                 case AF_INET:
 257                         fprintf(fp, "inet  ");
 258                         break;
 259                 case AF_INET6:
 260                         fprintf(fp, "inet6 ");
 261                         break;
 262                 default:
 263                         fprintf(fp, _("family %d "), list->addr.family);
 264                         break;
 265                 }
 266                 if (format_host(list->addr.family, list->addr.data, abuf, sizeof(abuf)))
 267                         fprintf(fp, "%s", abuf);
 268                 else
 269                         fprintf(fp, "?");
 270         }
 271         if (list->users != 1)
 272                 fprintf(fp, _(" users %d"), list->users);
 273         if (list->features)
 274                 fprintf(fp, " %s", list->features);
 275         fprintf(fp, "\n");
 276 }
 277
 278 static void print_mlist(FILE *fp, struct ma_info *list)
 279 {
 280         int cur_index = 0;
 281
 282         for (; list; list = list->next) {
 283                 if (cur_index != list->index) {
 284                         cur_index = list->index;
 285                         fprintf(fp, "%d:\t%s\n", cur_index, list->name);
 286                 }
 287                 print_maddr(fp, list);
 288         }
 289 }
 290
 291 static int multiaddr_list(int argc, char **argv)
 292 {
 293         struct ma_info *list = NULL;
 294
 295         while (argc > 0) {
 296                 if (strcmp(*argv, "dev") == 0) {
 297                         NEXT_ARG();
 298                         if (filter_dev[0])
 299                                 usage();
 300                         strcpy(filter_dev, *argv);
 301                 } else if (strcmp(*argv, "all") == 0) {
 302                         filter_family = AF_UNSPEC;
 303                 } else if (strcmp(*argv, "ipv4") == 0) {
 304                         filter_family = AF_INET;
 305                 } else if (strcmp(*argv, "ipv6") == 0) {
 306                         filter_family = AF_INET6;
 307                 } else if (strcmp(*argv, "link") == 0) {
 308                         filter_family = AF_PACKET;
 309                 } else {
 310                         if (filter_dev[0])
 311                                 usage();
 312                         strcpy(filter_dev, *argv);
 313                 }
 314                 argv++; argc--;
 315         }
 316
 317         if (!filter_family || filter_family == AF_PACKET)
 318                 read_dev_mcast(&list);
 319         if (!filter_family || filter_family == AF_INET)
 320                 read_igmp(&list);
 321         if (!filter_family || filter_family == AF_INET6)
 322                 read_igmp6(&list);
 323         print_mlist(stdout, list);
 324         return 0;
 325 }
 326
 327 int multiaddr_modify(int cmd, int argc, char **argv)
 328 {
 329         struct ifreq ifr;
 330         int fd;
 331
 332         memset(&ifr, 0, sizeof(ifr));
 333
 334         if (cmd == NEWADDR)
 335                 cmd = SIOCADDMULTI;
 336         else
 337                 cmd = SIOCDELMULTI;
 338
 339         while (argc > 0) {
 340                 if (strcmp(*argv, "dev") == 0) {
 341                         NEXT_ARG();
 342                         if (ifr.ifr_name[0])
 343                                 usage();
 344                         strncpy(ifr.ifr_name, *argv, IFNAMSIZ);
 345                 } else {
 346                         if (ifr.ifr_hwaddr.sa_data[0])
 347                                 usage();
 348                         if (parse_lla(*argv, ifr.ifr_hwaddr.sa_data) < 0)
 349                                 usage();
 350                 }
 351                 argc--; argv++;
 352         }
 353         if (ifr.ifr_name[0] == 0)
 354                 usage();
 355
 356         fd = socket(AF_INET, SOCK_DGRAM, 0);
 357         if (fd < 0) {
 358                 perror(_("Cannot create socket"));
 359                 exit(1);
 360         }
 361         if (ioctl(fd, cmd, (char*)&ifr) != 0) {
 362                 perror("ioctl");
 363                 exit(1);
 364         }
 365         close(fd);
 366
 367         exit(0);
 368 }
 369
 370
 371 int do_multiaddr(int argc, char **argv)
 372 {
 373         if (argc < 1)
 374                 return multiaddr_list(0, NULL);
 375         if (matches(*argv, "add") == 0)
 376                 return multiaddr_modify(NEWADDR, argc-1, argv+1);
 377         if (matches(*argv, "delete") == 0)
 378                 return multiaddr_modify(DELADDR, argc-1, argv+1);
 379         if (matches(*argv, "list") == 0 || matches(*argv, "show") == 0
 380             || matches(*argv, "lst") == 0)
 381                 return multiaddr_list(argc-1, argv+1);
 382         usage();
 383 }
 384
 385 int preferred_family = AF_UNSPEC;
 386 int show_stats = 0;
 387 int resolve_hosts = 0;
 388
 389 int main(int argc, char **argv)
 390 {
 391         char *basename;
 392
 393 #if I18N
 394         setlocale (LC_ALL, "");
 395         bindtextdomain("net-tools", "/usr/share/locale");
 396         textdomain("net-tools");
 397 #endif
 398
 399         basename = strrchr(argv[0], '/');
 400         if (basename == NULL)
 401                 basename = argv[0];
 402         else
 403                 basename++;
 404
 405         while (argc > 1) {
 406                 if (argv[1][0] != '-')
 407                         break;
 408                 if (matches(argv[1], "-family") == 0) {
 409                         argc--;
 410                         argv++;
 411                         if (argc <= 1)
 412                                 usage();
 413                         if (strcmp(argv[1], "inet") == 0)
 414                                 preferred_family = AF_INET;
 415                         else if (strcmp(argv[1], "inet6") == 0)
 416                                 preferred_family = AF_INET6;
 417                         else
 418                                 usage();
 419                 } else if (matches(argv[1], "-stats") == 0 ||
 420                            matches(argv[1], "-statistics") == 0) {
 421                         ++show_stats;
 422                 } else if (matches(argv[1], "-resolve") == 0) {
 423                         ++resolve_hosts;
 424                 } else if ((matches(argv[1], "-V") == 0) || matches(argv[1], "--version") == 0) {
 425                         version();
 426                 } else
 427                         usage();
 428                 argc--; argv++;
 429         }
 430
 431         return do_multiaddr(argc-1, argv+1);
 432 }