ethsock.c

   1 /**
   2  * nmrpflash - Netgear Unbrick Utility
   3  * Copyright (C) 2016 Joseph Lehner <joseph.c.lehner@gmail.com>
   4  *
   5  * nmrpflash is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * nmrpflash is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with nmrpflash.  If not, see <http://www.gnu.org/licenses/>.
  17  *
  18  */
  19
  20 #include <sys/types.h>
  21 #include <stdbool.h>
  22 #include <string.h>
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <fcntl.h>
  26 #include "nmrpd.h"
  27
  28 #if defined(NMRPFLASH_WINDOWS)
  29 #define NMRPFLASH_NETALIAS_PREFIX "net"
  30 #define WPCAP
  31 #include <pcap.h>
  32 #else
  33 #include <sys/ioctl.h>
  34 #include <ifaddrs.h>
  35 #include <unistd.h>
  36 #include <net/if.h>
  37 #include <pcap.h>
  38 #if defined(NMRPFLASH_LINUX)
  39 #define NMRPFLASH_AF_PACKET AF_PACKET
  40 #include <linux/if_packet.h>
  41 #else
  42 #define NMRPFLASH_AF_PACKET AF_LINK
  43 #include <net/if_types.h>
  44 #include <net/if_media.h>
  45 #endif
  46 #endif
  47
  48 struct ethsock
  49 {
  50         const char *intf;
  51         pcap_t *pcap;
  52 #ifndef NMRPFLASH_WINDOWS
  53         int fd;
  54 #ifdef NMRPFLASH_LINUX
  55         bool stp;
  56 #endif
  57 #else
  58         HANDLE handle;
  59         DWORD index;
  60 #endif
  61         unsigned timeout;
  62         uint8_t hwaddr[6];
  63 };
  64
  65 struct ethsock_arp_undo
  66 {
  67         uint32_t ipaddr;
  68         uint8_t hwaddr[6];
  69 };
  70
  71 struct ethsock_ip_undo
  72 {
  73 #ifndef NMRPFLASH_WINDOWS
  74         uint32_t ip[2];
  75 #else
  76         ULONG context;
  77 #endif
  78 };
  79
  80 const char *mac_to_str(uint8_t *mac)
  81 {
  82         static char buf[18];
  83         snprintf(buf, sizeof(buf), "%02x:%02x:%02x:%02x:%02x:%02x",
  84                         mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
  85         return buf;
  86 }
  87
  88 static int x_pcap_findalldevs(pcap_if_t **devs)
  89 {
  90         char errbuf[PCAP_ERRBUF_SIZE];
  91         if (pcap_findalldevs(devs, errbuf) != 0) {
  92                 fprintf(stderr, "%s.\n", errbuf);
  93                 return -1;
  94         }
  95
  96         return 0;
  97 }
  98
  99 #ifndef NMRPFLASH_WINDOWS
 100 static inline bool sockaddr_get_hwaddr(struct sockaddr *sa, uint8_t *hwaddr)
 101 {
 102         void *src;
 103
 104         if (sa->sa_family != NMRPFLASH_AF_PACKET) {
 105                 return false;
 106         }
 107
 108 #ifndef NMRPFLASH_LINUX
 109         if (((struct sockaddr_dl*)sa)->sdl_type != IFT_ETHER) {
 110                 return false;
 111         }
 112         src = LLADDR((struct sockaddr_dl*)sa);
 113 #else
 114         src = ((struct sockaddr_ll*)sa)->sll_addr;
 115 #endif
 116
 117         memcpy(hwaddr, src, 6);
 118         return true;
 119 }
 120
 121 #ifdef NMRPFLASH_LINUX
 122 static int open_stp_state(const char *intf)
 123 {
 124         char name[256];
 125         snprintf(name, sizeof(name), "/sys/class/net/%s/bridge/stp_state", intf);
 126         return open(name, O_RDWR, 0644);
 127 }
 128
 129 static bool is_stp_enabled(const char *intf)
 130 {
 131         char c;
 132         int fd = open_stp_state(intf);
 133         if (fd == -1) {
 134                 return false;
 135         }
 136
 137         if (read(fd, &c, 1) != 1) {
 138                 c = '0';
 139         }
 140
 141         close(fd);
 142         return c == '1';
 143 }
 144
 145 static bool set_stp_enabled(const char *intf, bool enabled)
 146 {
 147         bool ret;
 148         const char *s = enabled ? "1\n" : "0\n";
 149         int fd = open_stp_state(intf);
 150         if (fd == -1) {
 151                 return false;
 152         }
 153
 154         ret = (write(fd, s, 2) == 2);
 155         close(fd);
 156
 157         return ret;
 158 }
 159 #endif
 160
 161 static bool get_intf_info(const char *intf, uint8_t *hwaddr, bool *bridge)
 162 {
 163         struct ifaddrs *ifas, *ifa;
 164         bool found;
 165
 166         if (getifaddrs(&ifas) != 0) {
 167                 xperror("getifaddrs");
 168                 return false;
 169         }
 170
 171         found = false;
 172
 173         if (bridge) {
 174                 *bridge = false;
 175         }
 176
 177         for (ifa = ifas; ifa; ifa = ifa->ifa_next) {
 178                 if (!strcmp(ifa->ifa_name, intf)) {
 179                         if (sockaddr_get_hwaddr(ifa->ifa_addr, hwaddr)) {
 180 #ifdef NMRPFLASH_BSD
 181                                 if (bridge) {
 182                                         *bridge = ((struct if_data*) ifa->ifa_data)->ifi_type == IFT_BRIDGE;
 183                                 }
 184 #endif
 185                                 found = true;
 186                                 break;
 187                         }
 188                 }
 189         }
 190
 191         freeifaddrs(ifas);
 192         return found;
 193 }
 194
 195 #else
 196
 197 void win_perror2(const char *msg, DWORD err)
 198 {
 199         char *buf = NULL;
 200         FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
 201                         FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
 202                         NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 203                         (LPTSTR)&buf, 0, NULL);
 204
 205         if (buf) {
 206                 /* FormatMessageA terminates buf with CRLF! */
 207                 fprintf(stderr, "%s: %s", msg, buf);
 208                 LocalFree(buf);
 209         } else {
 210                 fprintf(stderr, "%s: error %d\n", msg, (int)err);
 211         }
 212 }
 213
 214 static bool get_intf_info(const char *intf, uint8_t *hwaddr, DWORD *index)
 215 {
 216         PIP_ADAPTER_INFO adapters, adapter;
 217         DWORD ret;
 218         ULONG i, bufLen = 0;
 219         bool found = false;
 220
 221         if ((ret = GetAdaptersInfo(NULL, &bufLen)) != ERROR_BUFFER_OVERFLOW) {
 222                 win_perror2("GetAdaptersInfo", ret);
 223                 return false;
 224         }
 225
 226         adapters = malloc(bufLen);
 227         if (!adapters) {
 228                 xperror("malloc");
 229                 return false;
 230         }
 231
 232         if ((ret = GetAdaptersInfo(adapters, &bufLen) == NO_ERROR)) {
 233                 for (adapter = adapters; adapter; adapter = adapter->Next) {
 234                         if (adapter->Type != MIB_IF_TYPE_ETHERNET && adapter->Type != IF_TYPE_IEEE80211) {
 235                                 continue;
 236                         }
 237
 238                         /* Interface names from WinPcap are "\Device\NPF_{GUID}", while
 239                          * AdapterName from GetAdaptersInfo is just "{GUID}".*/
 240                         if (strstr(intf, adapter->AdapterName)) {
 241                                 if (adapter->AddressLength == 6) {
 242                                         memcpy(hwaddr, adapter->Address, 6);
 243                                         if (index) {
 244                                                 *index = adapter->Index;
 245                                         }
 246                                         found = true;
 247                                         break;
 248                                 }
 249                         }
 250                 }
 251         } else {
 252                 win_perror2("GetAdaptersInfo", ret);
 253         }
 254
 255         free(adapters);
 256         return found;
 257 }
 258
 259 static const char *intf_alias_to_wpcap(const char *intf)
 260 {
 261         static char buf[128];
 262         pcap_if_t *devs, *dev;
 263         unsigned i = 0, dev_num = 0;
 264
 265         if (intf[0] == '\\') {
 266                 return intf;
 267         } else if (sscanf(intf, NMRPFLASH_NETALIAS_PREFIX "%u", &dev_num) != 1) {
 268                 fprintf(stderr, "Invalid interface alias.\n");
 269                 return NULL;
 270         }
 271
 272         if (x_pcap_findalldevs(&devs) != 0) {
 273                 return NULL;
 274         }
 275
 276         for (dev = devs; dev; dev = dev->next, ++i) {
 277                 if (i == dev_num) {
 278                         if (verbosity) {
 279                                 printf("%s%u: %s\n", NMRPFLASH_NETALIAS_PREFIX, i, dev->name);
 280                         }
 281                         strncpy(buf, dev->name, sizeof(buf) - 1);
 282                         buf[sizeof(buf) - 1] = '\0';
 283                         break;
 284                 }
 285         }
 286
 287         pcap_freealldevs(devs);
 288
 289         if (!dev) {
 290                 fprintf(stderr, "Interface alias not found.\n");
 291                 return NULL;
 292         }
 293
 294         return buf;
 295 }
 296
 297 static const char *intf_get_pretty_name(const char *intf)
 298 {
 299         static char buf[512];
 300         char *guid;
 301         HKEY hkey;
 302         LONG err;
 303         DWORD len;
 304
 305         guid = strstr(intf, "NPF_{");
 306         if (!guid) {
 307                 return NULL;
 308         }
 309
 310         guid += 4;
 311
 312         snprintf(buf, sizeof(buf),
 313                         "System\\CurrentControlSet\\Control\\Network\\"
 314                         "{4D36E972-E325-11CE-BFC1-08002BE10318}\\"
 315                         "%s\\Connection", guid);
 316         err = RegOpenKeyExA(HKEY_LOCAL_MACHINE, buf, 0, KEY_READ, &hkey);
 317         if (err != ERROR_SUCCESS) {
 318                 if (verbosity > 1) {
 319                         win_perror2("RegOpenKeyExA", err);
 320                 }
 321                 return NULL;
 322         }
 323
 324         len = sizeof(buf);
 325         err = RegQueryValueExA(hkey, "Name", NULL, NULL, (LPBYTE)buf, &len);
 326         if (err == ERROR_SUCCESS) {
 327                 intf = buf;
 328         } else {
 329                 if (verbosity > 1) {
 330                         win_perror2("RegQueryValueExA", err);
 331                 }
 332                 intf = NULL;
 333         }
 334
 335         RegCloseKey(hkey);
 336         return intf;
 337 }
 338 #endif
 339
 340 inline uint8_t *ethsock_get_hwaddr(struct ethsock *sock)
 341 {
 342         return sock->hwaddr;
 343 }
 344
 345 struct ethsock *ethsock_create(const char *intf, uint16_t protocol)
 346 {
 347         char buf[PCAP_ERRBUF_SIZE];
 348         struct bpf_program fp;
 349         struct ethsock *sock;
 350         bool is_bridge;
 351         int err;
 352
 353 #ifdef NMRPFLASH_WINDOWS
 354         intf = intf_alias_to_wpcap(intf);
 355         if (!intf) {
 356                 return NULL;
 357         }
 358 #endif
 359
 360         sock = malloc(sizeof(struct ethsock));
 361         if (!sock) {
 362                 xperror("malloc");
 363                 return NULL;
 364         }
 365
 366         buf[0] = '\0';
 367
 368         sock->intf = intf;
 369         sock->pcap = pcap_open_live(sock->intf, BUFSIZ, 1, 1, buf);
 370         if (!sock->pcap) {
 371                 fprintf(stderr, "%s.\n", buf);
 372                 goto cleanup;
 373         }
 374
 375         if (*buf) {
 376                 fprintf(stderr, "Warning: %s.\n", buf);
 377         }
 378
 379         if (pcap_datalink(sock->pcap) != DLT_EN10MB) {
 380                 fprintf(stderr, "%s is not an ethernet interface.\n",
 381                                 intf);
 382                 goto cleanup;
 383         }
 384
 385 #ifndef NMRPFLASH_WINDOWS
 386         err = !get_intf_info(intf, sock->hwaddr, &is_bridge);
 387 #else
 388         err = !get_intf_info(intf, sock->hwaddr, &sock->index);
 389 #endif
 390         if (err) {
 391                 fprintf(stderr, "Failed to get interface info.\n");
 392                 goto cleanup;
 393         }
 394
 395 #ifndef NMRPFLASH_WINDOWS
 396         sock->fd = pcap_get_selectable_fd(sock->pcap);
 397         if (sock->fd == -1) {
 398                 pcap_perror(sock->pcap, "pcap_get_selectable_fd");
 399                 goto cleanup;
 400         }
 401 #else
 402         sock->handle = pcap_getevent(sock->pcap);
 403         if (!sock->handle) {
 404                 pcap_perror(sock->pcap, "pcap_getevent");
 405                 goto cleanup;
 406         }
 407
 408         err = pcap_setmintocopy(sock->pcap, 1);
 409         if (err) {
 410                 pcap_perror(sock->pcap, "pcap_setmintocopy");
 411                 goto cleanup;
 412         }
 413 #endif
 414
 415         snprintf(buf, sizeof(buf), "ether proto 0x%04x and not ether src %s",
 416                         protocol, mac_to_str(sock->hwaddr));
 417
 418         err = pcap_compile(sock->pcap, &fp, buf, 0, 0);
 419         if (err) {
 420                 pcap_perror(sock->pcap, "pcap_compile");
 421                 goto cleanup;
 422         }
 423
 424         err = pcap_setfilter(sock->pcap, &fp);
 425         pcap_freecode(&fp);
 426
 427         if (err) {
 428                 pcap_perror(sock->pcap, "pcap_setfilter");
 429                 goto cleanup;
 430         }
 431
 432 #ifdef NMRPFLASH_LINUX
 433         // nmrpflash does not work on bridge interfaces with STP enabled
 434         if ((sock->stp = is_stp_enabled(intf))) {
 435                 if (!set_stp_enabled(intf, false)) {
 436                         fprintf(stderr, "Warning: failed to disable STP on %s.\n", intf);
 437                 }
 438         }
 439 #else
 440         if (is_bridge) {
 441                 fprintf(stderr, "Warning: bridge interfaces are not fully "
 442                                 "supported on this platform.\n");
 443         }
 444 #endif
 445
 446         return sock;
 447
 448 cleanup:
 449         ethsock_close(sock);
 450         return NULL;
 451 }
 452
 453 int select_fd(int fd, unsigned timeout)
 454 {
 455         struct timeval tv;
 456         int status;
 457         fd_set fds;
 458
 459         FD_ZERO(&fds);
 460         FD_SET(fd, &fds);
 461
 462         tv.tv_sec = timeout / 1000;
 463         tv.tv_usec = 1000 * (timeout % 1000);
 464
 465         status = select(fd + 1, &fds, NULL, NULL, &tv);
 466         if (status < 0) {
 467                 sock_perror("select");
 468         }
 469
 470         return status;
 471 }
 472
 473 ssize_t ethsock_recv(struct ethsock *sock, void *buf, size_t len)
 474 {
 475         struct pcap_pkthdr* hdr;
 476         const u_char *capbuf;
 477         int status;
 478 #ifdef NMRPFLASH_WINDOWS
 479         DWORD ret;
 480
 481         if (sock->timeout) {
 482                 ret = WaitForSingleObject(sock->handle, sock->timeout);
 483                 if (ret == WAIT_TIMEOUT) {
 484                         return 0;
 485                 } else if (ret != WAIT_OBJECT_0) {
 486                         win_perror2("WaitForSingleObject", ret);
 487                         return -1;
 488                 }
 489         }
 490 #else
 491         if (sock->timeout) {
 492                 status = select_fd(sock->fd, sock->timeout);
 493                 if (status < 0) {
 494                         return -1;
 495                 } else if (status == 0) {
 496                         return 0;
 497                 }
 498         }
 499 #endif
 500
 501         status = pcap_next_ex(sock->pcap, &hdr, &capbuf);
 502         switch (status) {
 503                 case 1:
 504                         memcpy(buf, capbuf, MIN(len, hdr->caplen));
 505                         return hdr->caplen;
 506                 case 0:
 507                         return 0;
 508                 case -1:
 509                         pcap_perror(sock->pcap, "pcap_next_ex");
 510                         return -1;
 511                 default:
 512                         fprintf(stderr, "pcap_next_ex: returned %d.\n", status);
 513                         return -1;
 514         }
 515 }
 516
 517 int ethsock_send(struct ethsock *sock, void *buf, size_t len)
 518 {
 519 #ifdef NMRPFLASH_WINDOWS
 520         if (pcap_sendpacket(sock->pcap, buf, len) == 0) {
 521                 return 0;
 522         } else {
 523                 pcap_perror(sock->pcap, "pcap_sendpacket");
 524                 return -1;
 525         }
 526 #else
 527         if (pcap_inject(sock->pcap, buf, len) == len) {
 528                 return 0;
 529         } else {
 530                 pcap_perror(sock->pcap, "pcap_inject");
 531                 return -1;
 532         }
 533 #endif
 534 }
 535
 536 int ethsock_close(struct ethsock *sock)
 537 {
 538         if (!sock) {
 539                 return 0;
 540         }
 541
 542 #ifdef NMRPFLASH_LINUX
 543         if (sock->stp) {
 544                 set_stp_enabled(sock->intf, true);
 545         }
 546 #endif
 547         if (sock->pcap) {
 548                 pcap_close(sock->pcap);
 549         }
 550
 551         free(sock);
 552         return 0;
 553 }
 554
 555 inline int ethsock_set_timeout(struct ethsock *sock, unsigned msec)
 556 {
 557         sock->timeout = msec;
 558         return 0;
 559 }
 560
 561 #ifndef NMRPFLASH_WINDOWS
 562 int ethsock_arp_add(struct ethsock *sock, uint8_t *hwaddr, uint32_t ipaddr, struct ethsock_arp_undo **undo)
 563 {
 564         return 0;
 565 }
 566
 567 int ethsock_arp_del(struct ethsock *sock, struct ethsock_arp_undo **undo)
 568 {
 569         return 0;
 570 }
 571 #else
 572 static int ethsock_arp(struct ethsock *sock, uint8_t *hwaddr, uint32_t ipaddr, struct ethsock_arp_undo **undo)
 573 {
 574         DWORD ret;
 575         MIB_IPNETROW arp = {
 576                 .dwIndex = sock->index,
 577                 .dwPhysAddrLen = 6,
 578                 .dwAddr = ipaddr,
 579                 .dwType = MIB_IPNET_TYPE_STATIC
 580         };
 581
 582         memcpy(arp.bPhysAddr, hwaddr, 6);
 583
 584         if (undo) {
 585                 ret = CreateIpNetEntry(&arp);
 586                 if (ret != NO_ERROR) {
 587                         win_perror2("CreateIpNetEntry", ret);
 588                         return -1;
 589                 }
 590
 591                 *undo = malloc(sizeof(struct ethsock_arp_undo));
 592                 if (!*undo) {
 593                         xperror("malloc");
 594                         return -1;
 595                 }
 596
 597                 (*undo)->ipaddr = ipaddr;
 598                 memcpy((*undo)->hwaddr, hwaddr, 6);
 599         } else {
 600                 DeleteIpNetEntry(&arp);
 601         }
 602
 603         return 0;
 604 }
 605
 606 int ethsock_arp_add(struct ethsock *sock, uint8_t *hwaddr, uint32_t ipaddr, struct ethsock_arp_undo **undo)
 607 {
 608         ethsock_arp(sock, hwaddr, ipaddr, NULL);
 609         return undo ? ethsock_arp(sock, hwaddr, ipaddr, undo) : -1;
 610 }
 611
 612 int ethsock_arp_del(struct ethsock *sock, struct ethsock_arp_undo **undo)
 613 {
 614         if (!*undo) {
 615                 return 0;
 616         }
 617
 618         int ret = ethsock_arp(sock, (*undo)->hwaddr, (*undo)->ipaddr, NULL);
 619         free(*undo);
 620         *undo = NULL;
 621         return ret;
 622 }
 623 #endif
 624
 625 static bool get_hwaddr_from_pcap(const pcap_if_t *dev, uint8_t *hwaddr)
 626 {
 627 #ifndef NMRPFLASH_WINDOWS
 628         pcap_addr_t *addr;
 629         int i;
 630
 631         for (addr = dev->addresses; addr; addr = addr->next) {
 632                 if (verbosity > 1) {
 633                         printf("%s: sa_family=%d, sa_data={ ", dev->name,
 634                                         addr->addr->sa_family);
 635                         for (i = 0; i != sizeof(addr->addr->sa_data); ++i) {
 636                                 printf("%02x ", addr->addr->sa_data[i] & 0xff);
 637                         }
 638                         printf("}\n");
 639                 }
 640
 641                 if (sockaddr_get_hwaddr(addr->addr, hwaddr)) {
 642                         return true;
 643                 }
 644         }
 645 #endif
 646
 647         return get_intf_info(dev->name, hwaddr, NULL);
 648 }
 649
 650 int ethsock_list_all(void)
 651 {
 652         pcap_if_t *devs, *dev;
 653         pcap_addr_t *addr;
 654         uint8_t hwaddr[6];
 655         unsigned dev_num = 0, dev_ok = 0;
 656 #ifdef NMRPFLASH_WINDOWS
 657         const char *pretty;
 658 #endif
 659
 660         if (x_pcap_findalldevs(&devs) != 0) {
 661                 return -1;
 662         }
 663
 664         memset(hwaddr, 0, 6);
 665
 666         for (dev = devs; dev; dev = dev->next, ++dev_num) {
 667                 if (dev->flags & PCAP_IF_LOOPBACK) {
 668                         if (verbosity) {
 669                                 printf("%-15s  (loopback device)\n", dev->name);
 670                         }
 671                         continue;
 672                 }
 673
 674                 if (!get_hwaddr_from_pcap(dev, hwaddr)) {
 675                         if (verbosity) {
 676                                 printf("%-15s  (not an ethernet device)\n",
 677                                                 dev->name);
 678                         }
 679                         continue;
 680                 }
 681
 682 #ifndef NMRPFLASH_WINDOWS
 683                 printf("%-15s", dev->name);
 684 #else
 685                 /* Call this here so *_perror() calls don't happen within a line */
 686                 pretty = intf_get_pretty_name(dev->name);
 687
 688                 if (!verbosity) {
 689                         printf("%s%u", NMRPFLASH_NETALIAS_PREFIX, dev_num);
 690                 } else {
 691                         printf("%s", dev->name);
 692                 }
 693 #endif
 694
 695                 for (addr = dev->addresses; addr; addr = addr->next) {
 696                         if (addr->addr->sa_family == AF_INET) {
 697                                 printf("  %-15s",
 698                                                 inet_ntoa(((struct sockaddr_in*)addr->addr)->sin_addr));
 699                                 break;
 700                         }
 701                 }
 702
 703                 if (!addr) {
 704                         printf("  %-15s", "0.0.0.0");
 705                 }
 706
 707                 printf("  %s", mac_to_str(hwaddr));
 708
 709 #ifdef NMRPFLASH_WINDOWS
 710                 if (pretty) {
 711                         printf("  (%s)", pretty);
 712                 } else if (dev->description) {
 713                         printf("  (%s)", dev->description);
 714                 }
 715
 716 #endif
 717                 printf("\n");
 718                 ++dev_ok;
 719         }
 720
 721         if (!dev_ok) {
 722                 printf("No suitable network interfaces found.\n");
 723         }
 724
 725         return 0;
 726 }
 727
 728 int ethsock_for_each_ip(struct ethsock *sock, ethsock_ip_callback_t callback,
 729                 void *arg)
 730 {
 731         struct ethsock_ip_callback_args args;
 732         pcap_if_t *devs, *dev;
 733         pcap_addr_t *addr;
 734         int status = 0;
 735
 736         if (x_pcap_findalldevs(&devs) != 0) {
 737                 return -1;
 738         }
 739
 740         args.arg = arg;
 741
 742         for (dev = devs; dev; dev = dev->next) {
 743                 if (strcmp(sock->intf, dev->name)) {
 744                         continue;
 745                 }
 746
 747                 for (addr = dev->addresses; addr; addr = addr->next) {
 748                         if (addr->addr->sa_family == AF_INET) {
 749                                 args.ipaddr = &((struct sockaddr_in*)addr->addr)->sin_addr;
 750                                 args.ipmask = &((struct sockaddr_in*)addr->netmask)->sin_addr;
 751
 752                                 status = callback(&args);
 753                                 if (status <= 0) {
 754                                         break;
 755                                 }
 756                         }
 757                 }
 758
 759                 break;
 760         }
 761
 762         pcap_freealldevs(devs);
 763
 764         return status <= 0 ? status : 0;
 765 }
 766
 767 static inline void set_addr(void *p, uint32_t addr)
 768 {
 769         struct sockaddr_in* sin = p;
 770         sin->sin_family = AF_INET;
 771         sin->sin_addr.s_addr = addr;
 772 #ifdef NMRPFLASH_BSD
 773         ((struct sockaddr*)p)->sa_len = sizeof(struct sockaddr_in);
 774 #endif
 775 }
 776
 777 #ifndef NMRPFLASH_WINDOWS
 778 static bool set_interface_up(int fd, const char *intf, bool up)
 779 {
 780         struct ifreq ifr;
 781         strncpy(ifr.ifr_name, intf, IFNAMSIZ);
 782
 783         if (ioctl(fd, SIOCGIFFLAGS, &ifr) != 0) {
 784                 if (up) {
 785                         xperror("ioctl(SIOCGIFFLAGS)");
 786                 }
 787                 return false;
 788         }
 789
 790         if (!up) {
 791                 ifr.ifr_flags &= ~(IFF_UP | IFF_RUNNING);
 792         } else {
 793                 ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
 794         }
 795
 796         if (ioctl(fd, SIOCSIFFLAGS, &ifr) != 0) {
 797                 if (up) {
 798                         xperror("ioctl(SIOCSIFFLAGS)");
 799                 }
 800                 return false;
 801         }
 802
 803         return true;
 804 }
 805
 806 #endif
 807
 808 int ethsock_ip_add(struct ethsock *sock, uint32_t ipaddr, uint32_t ipmask, struct ethsock_ip_undo **undo)
 809 {
 810         if (undo && !(*undo = malloc(sizeof(struct ethsock_ip_undo)))) {
 811                 xperror("malloc");
 812                 return -1;
 813         }
 814
 815         int ret = -1;
 816         int fd = socket(AF_INET, SOCK_DGRAM, 0);
 817         if (!fd) {
 818                 sock_perror("socket");
 819                 goto out;
 820         }
 821
 822 #ifndef NMRPFLASH_WINDOWS
 823         // XXX: undo is non-zero only if we're adding an IP
 824         bool add = undo;
 825 #ifdef NMRPFLASH_LINUX
 826         struct ifreq ifr;
 827         strncpy(ifr.ifr_name, sock->intf, IFNAMSIZ);
 828         // FIXME: automatically determine the next free alias
 829         strcat(ifr.ifr_name, ":42");
 830
 831         if (add) {
 832                 set_addr(&ifr.ifr_addr, ipaddr);
 833                 if (ioctl(fd, SIOCSIFADDR, &ifr) != 0) {
 834                         xperror("ioctl(SIOSIFADDR)");
 835                         goto out;
 836                 }
 837
 838                 set_addr(&ifr.ifr_netmask, ipmask);
 839                 if (ioctl(fd, SIOCSIFNETMASK, &ifr) != 0) {
 840                         xperror("ioctl(SIOCSIFNETMASK)");
 841                         goto out;
 842                 }
 843
 844                 (*undo)->ip[0] = ipaddr;
 845                 (*undo)->ip[1] = ipmask;
 846         }
 847
 848         if (!set_interface_up(fd, ifr.ifr_name, add)) {
 849                 goto out;
 850         }
 851 #else // NMRPFLASH_OSX (or any other BSD)
 852         struct ifaliasreq ifra;
 853         memset(&ifra, 0, sizeof(ifra));
 854         strncpy(ifra.ifra_name, sock->intf, IFNAMSIZ);
 855
 856         set_addr(&ifra.ifra_addr, ipaddr);
 857         set_addr(&ifra.ifra_mask, ipmask);
 858         //set_addr(&ifra.ifra_broadaddr, (ipaddr & ipmask) | ~ipmask);
 859
 860         if (ioctl(fd, add ? SIOCAIFADDR : SIOCDIFADDR, &ifra) != 0) {
 861                 if (add) {
 862                         xperror("ioctl(SIOCAIFADDR");
 863                 }
 864                 goto out;
 865         }
 866
 867         if (add) {
 868                 (*undo)->ip[0] = ipaddr;
 869                 (*undo)->ip[1] = ipmask;
 870                 set_interface_up(fd, ifra.ifra_name, true);
 871         }
 872
 873 #endif
 874 #else // NMRPFLASH_WINDOWS
 875         struct sockaddr_in sin;
 876         ULONG instance;
 877
 878         (*undo)->context = 0;
 879
 880         DWORD err = AddIPAddress(ipaddr, ipmask, sock->index, &(*undo)->context, &instance);
 881         if (err != NO_ERROR && err != ERROR_DUP_DOMAINNAME && err != ERROR_OBJECT_ALREADY_EXISTS) {
 882                 win_perror2("AddIPAddress", err);
 883                 goto out;
 884         }
 885
 886         set_addr(&sin, ipaddr);
 887         time_t beg = time_monotonic();
 888
 889         /* Wait until the new IP has actually been added */
 890
 891         while (bind(fd, (struct sockaddr*)&sin, sizeof(sin)) != 0) {
 892                 if ((time_monotonic() - beg) >= 5) {
 893                         fprintf(stderr, "Failed to bind after 5 seconds: ");
 894                         sock_perror("bind");
 895                         DeleteIPAddress((*undo)->context);
 896                         goto out;
 897                 }
 898         }
 899 #endif
 900         ret = 0;
 901
 902 out:
 903 #ifndef NMRPFLASH_WINDOWS
 904         close(fd);
 905 #else
 906         closesocket(fd);
 907 #endif
 908         if (ret != 0 && undo) {
 909                 free(*undo);
 910                 *undo = NULL;
 911         }
 912
 913         return ret;
 914 }
 915
 916 int ethsock_ip_del(struct ethsock *sock, struct ethsock_ip_undo **undo)
 917 {
 918         if (!*undo) {
 919                 return 0;
 920         }
 921
 922         int ret;
 923
 924 #ifndef NMRPFLASH_WINDOWS
 925         if ((*undo)->ip[0] != INADDR_NONE) {
 926                 ret = ethsock_ip_add(sock, (*undo)->ip[0], (*undo)->ip[1], NULL);
 927         } else {
 928                 ret = 0;
 929         }
 930 #else
 931         DeleteIPAddress((*undo)->context);
 932         ret = 0;
 933 #endif
 934
 935         free(*undo);
 936         *undo = NULL;
 937         return ret;
 938 }