ethsock.c 30 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465
  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. #include <sys/types.h>
  20. #include <stdbool.h>
  21. #include <stdarg.h>
  22. #include <string.h>
  23. #include <stdlib.h>
  24. #include <stdio.h>
  25. #include <fcntl.h>
  26. #include "nmrpd.h"
  27. #if defined(NMRPFLASH_WINDOWS)
  28. # include <iphlpapi.h>
  29. # define NMRPFLASH_PRETTY_FMT "%ls"
  30. # ifndef ERROR_NDIS_MEDIA_DISCONNECTED
  31. # define ERROR_NDIS_MEDIA_DISCONNECTED 0x8034001f
  32. # endif
  33. # define WPCAP
  34. # include <pcap.h>
  35. #else
  36. # include <sys/ioctl.h>
  37. # include <ifaddrs.h>
  38. # include <unistd.h>
  39. # include <net/if.h>
  40. # include <pcap.h>
  41. # if defined(NMRPFLASH_LINUX)
  42. # define NMRPFLASH_AF_PACKET AF_PACKET
  43. # include <linux/if_packet.h>
  44. # include <netlink/route/addr.h>
  45. # include <netlink/route/neighbour.h>
  46. # else
  47. # define NMRPFLASH_AF_PACKET AF_LINK
  48. # include <net/if_types.h>
  49. # include <net/if_media.h>
  50. # endif
  51. #endif
  52. #ifdef NMRPFLASH_OSX
  53. #include <CoreFoundation/CoreFoundation.h>
  54. #define NMRPFLASH_PRETTY_FMT "%s"
  55. #endif
  56. struct ethsock
  57. {
  58. const char *intf;
  59. pcap_t *pcap;
  60. #ifndef NMRPFLASH_WINDOWS
  61. int fd;
  62. #ifdef NMRPFLASH_LINUX
  63. bool stp;
  64. // managed by NetworkManager
  65. bool nm_managed;
  66. #endif
  67. #else
  68. HANDLE handle;
  69. DWORD index;
  70. #endif
  71. unsigned timeout;
  72. uint8_t hwaddr[6];
  73. };
  74. struct ethsock_arp_undo
  75. {
  76. uint32_t ipaddr;
  77. uint8_t hwaddr[6];
  78. };
  79. struct ethsock_ip_undo
  80. {
  81. uint32_t ip[2];
  82. };
  83. static int x_pcap_findalldevs(pcap_if_t **devs)
  84. {
  85. char errbuf[PCAP_ERRBUF_SIZE];
  86. if (pcap_findalldevs(devs, errbuf) != 0) {
  87. fprintf(stderr, "%s.\n", errbuf);
  88. return -1;
  89. }
  90. return 0;
  91. }
  92. static bool intf_get_pcap_flags(const char *intf, bpf_u_int32 *flags)
  93. {
  94. pcap_if_t *devs, *dev;
  95. if (x_pcap_findalldevs(&devs) == 0) {
  96. for (dev = devs; dev; dev = dev->next) {
  97. if (!strcmp(intf, dev->name)) {
  98. *flags = dev->flags;
  99. break;
  100. }
  101. }
  102. pcap_freealldevs(devs);
  103. return dev != NULL;
  104. }
  105. return false;
  106. }
  107. #ifndef NMRPFLASH_WINDOWS
  108. static int systemf(const char *fmt, ...)
  109. {
  110. char cmd[1024];
  111. int ret;
  112. va_list va;
  113. va_start(va, fmt);
  114. ret = vsnprintf(cmd, sizeof(cmd) - 1, fmt, va);
  115. if (ret >= sizeof(cmd) - 1) {
  116. return -1;
  117. }
  118. ret = system(cmd);
  119. va_end(va);
  120. return ret;
  121. }
  122. #endif
  123. #ifndef NMRPFLASH_WINDOWS
  124. static inline bool sockaddr_get_hwaddr(struct sockaddr *sa, uint8_t *hwaddr)
  125. {
  126. void *src;
  127. if (!sa || sa->sa_family != NMRPFLASH_AF_PACKET) {
  128. return false;
  129. }
  130. #ifndef NMRPFLASH_LINUX
  131. if (((struct sockaddr_dl*)sa)->sdl_type != IFT_ETHER) {
  132. return false;
  133. }
  134. src = LLADDR((struct sockaddr_dl*)sa);
  135. #else
  136. src = ((struct sockaddr_ll*)sa)->sll_addr;
  137. #endif
  138. memcpy(hwaddr, src, 6);
  139. return true;
  140. }
  141. #ifdef NMRPFLASH_LINUX
  142. static int intf_sys_open(const char* intf, const char* file)
  143. {
  144. char name[256];
  145. snprintf(name, sizeof(name), "/sys/class/net/%s/%s", intf, file);
  146. return open(name, O_RDWR, 0644);
  147. }
  148. static bool intf_sys_read(const char* intf, const char* file, bool def)
  149. {
  150. char c;
  151. int fd;
  152. fd = intf_sys_open(intf, file);
  153. if (fd == -1) {
  154. return def;
  155. }
  156. c = 0;
  157. read(fd, &c, 1);
  158. close(fd);
  159. return c ? (c == '1') : def;
  160. }
  161. static bool intf_stp_enable(const char *intf, bool enabled)
  162. {
  163. int fd;
  164. ssize_t n;
  165. fd = intf_sys_open(intf, "bridge/stp_state");
  166. if (fd == -1) {
  167. return false;
  168. }
  169. n = write(fd, enabled ? "1\n" : "0\n", 2);
  170. close(fd);
  171. return n == 2;
  172. }
  173. static struct nl_addr *build_ip(uint32_t ip)
  174. {
  175. struct nl_addr *na = nl_addr_build(AF_INET, &ip, 4);
  176. if (!na) {
  177. xperror("nl_addr_build");
  178. }
  179. return na;
  180. }
  181. static struct nl_sock *xnl_socket_route()
  182. {
  183. int err;
  184. struct nl_sock *sk = nl_socket_alloc();
  185. if (sk) {
  186. if (!(err = nl_connect(sk, NETLINK_ROUTE))) {
  187. return sk;
  188. }
  189. nl_socket_free(sk);
  190. nl_perror(err, "nl_connect");
  191. } else {
  192. xperror("nl_socket_alloc");
  193. }
  194. return NULL;
  195. }
  196. static bool intf_add_del_ip(const char *intf, uint32_t ipaddr, uint32_t ipmask, bool add)
  197. {
  198. struct rtnl_addr *ra = NULL;
  199. struct nl_sock *sk = NULL;
  200. struct nl_addr *laddr = NULL;
  201. struct nl_addr *bcast = NULL;
  202. int err = 1;
  203. if (!(sk = xnl_socket_route())) {
  204. return false;
  205. }
  206. if (!(laddr = build_ip(ipaddr))) {
  207. goto out;
  208. }
  209. nl_addr_set_prefixlen(laddr, bitcount(ipmask));
  210. if (!(bcast = build_ip((ipaddr & ipmask) | ~ipmask))) {
  211. goto out;
  212. }
  213. if (!(ra = rtnl_addr_alloc())) {
  214. xperror("rtnl_addr_alloc");
  215. goto out;
  216. }
  217. rtnl_addr_set_ifindex(ra, if_nametoindex(intf));
  218. rtnl_addr_set_local(ra, laddr);
  219. rtnl_addr_set_broadcast(ra, bcast);
  220. if ((err = (add ? rtnl_addr_add(sk, ra, 0) : rtnl_addr_delete(sk, ra, 0))) < 0) {
  221. if (add && err == -NLE_EXIST) {
  222. err = 0;
  223. } else if (add || verbosity > 1) {
  224. nl_perror(err, add ? "rtnl_addr_add" : "rtnl_addr_delete");
  225. }
  226. }
  227. out:
  228. rtnl_addr_put(ra);
  229. nl_addr_put(laddr);
  230. nl_addr_put(bcast);
  231. nl_socket_free(sk);
  232. return !err;
  233. }
  234. static bool intf_add_del_arp(const char *intf, uint32_t ipaddr, uint8_t *hwaddr, bool add)
  235. {
  236. #if 0
  237. struct arpreq arp;
  238. memset(&arp, 0, sizeof(arp));
  239. arp.arp_ha.sa_family = ARPHRD_ETHER;
  240. memcpy(&arp.arp_ha.sa_data, hwaddr, 6);
  241. arp.arp_flags = ATF_PERM | ATF_COM;
  242. struct sockaddr_in *in = (struct sockaddr_in*)&req.arp_pa;
  243. in->sin_addr.s_addr = htonl(ipaddr);
  244. in->sin_family = AF_INET;
  245. int fd = socket(AF_INET, SOCK_DGRAM, 0);
  246. if (fd < 0) {
  247. perror("socket");
  248. return false;
  249. }
  250. bool ret = true;
  251. if (ioctl(fd, add ? SIOCSARP : SIOCDARP, &req) < 0) {
  252. perror(add ? "ioctl(SIOCSARP)" : "ioctl(SIOCDARP");
  253. ret = false;
  254. }
  255. close(fd);
  256. return ret;
  257. #else
  258. struct nl_sock *sk;
  259. struct rtnl_neigh *neigh;
  260. struct nl_addr *mac, *ip;
  261. int err = 1;
  262. sk = NULL;
  263. neigh = NULL;
  264. mac = ip = NULL;
  265. if (!(sk = xnl_socket_route())) {
  266. goto out;
  267. }
  268. if (!(neigh = rtnl_neigh_alloc())) {
  269. xperror("rtnl_neigh_alloc");
  270. goto out;
  271. }
  272. if (!(mac = nl_addr_build(AF_PACKET, hwaddr, 6))) {
  273. xperror("nl_addr_build");
  274. goto out;
  275. }
  276. if (!(ip = nl_addr_build(AF_INET, &ipaddr, 4))) {
  277. xperror("nl_addr_build");
  278. goto out;
  279. }
  280. rtnl_neigh_set_ifindex(neigh, if_nametoindex(intf));
  281. rtnl_neigh_set_dst(neigh, ip);
  282. err = rtnl_neigh_delete(sk, neigh, 0);
  283. if (add) {
  284. rtnl_neigh_set_lladdr(neigh, mac);
  285. rtnl_neigh_set_state(neigh, NUD_PERMANENT);
  286. err = rtnl_neigh_add(sk, neigh, NLM_F_CREATE);
  287. }
  288. if (err && add) {
  289. nl_perror(err, "rtnl_neigh_add");
  290. }
  291. out:
  292. nl_addr_put(ip);
  293. nl_addr_put(mac);
  294. rtnl_neigh_put(neigh);
  295. nl_socket_free(sk);
  296. return !err;
  297. #endif
  298. }
  299. #endif
  300. static bool intf_get_hwaddr_and_bridge(const char *intf, uint8_t *hwaddr, bool *bridge)
  301. {
  302. struct ifaddrs *ifas, *ifa;
  303. bool found;
  304. if (getifaddrs(&ifas) != 0) {
  305. xperror("getifaddrs");
  306. return false;
  307. }
  308. found = false;
  309. if (bridge) {
  310. *bridge = false;
  311. }
  312. for (ifa = ifas; ifa; ifa = ifa->ifa_next) {
  313. if (!strcmp(ifa->ifa_name, intf)) {
  314. if (sockaddr_get_hwaddr(ifa->ifa_addr, hwaddr)) {
  315. #ifdef NMRPFLASH_BSD
  316. if (bridge) {
  317. *bridge = ((struct if_data*) ifa->ifa_data)->ifi_type == IFT_BRIDGE;
  318. }
  319. #endif
  320. found = true;
  321. break;
  322. }
  323. }
  324. }
  325. freeifaddrs(ifas);
  326. return found;
  327. }
  328. #else
  329. void win_perror2(const char *msg, DWORD err)
  330. {
  331. char *buf = NULL;
  332. FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
  333. FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
  334. NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  335. (LPTSTR)&buf, 0, NULL);
  336. if (buf) {
  337. /* FormatMessageA terminates buf with CRLF! */
  338. fprintf(stderr, "%s: %s", msg, buf);
  339. LocalFree(buf);
  340. } else {
  341. fprintf(stderr, "%s: error %d\n", msg, (int)err);
  342. }
  343. }
  344. static bool intf_get_if_row(NET_IFINDEX index, MIB_IF_ROW2* row)
  345. {
  346. DWORD err;
  347. memset(row, 0, sizeof(*row));
  348. row->InterfaceIndex = index;
  349. err = GetIfEntry2(row);
  350. if (err != NO_ERROR) {
  351. if (verbosity > 1) {
  352. win_perror2("GetIfEntry2", err);
  353. }
  354. return false;
  355. }
  356. return true;
  357. }
  358. static bool intf_get_hwaddr_and_index(const char *intf, uint8_t *hwaddr, DWORD *index)
  359. {
  360. PIP_ADAPTER_ADDRESSES adapters, adapter;
  361. ULONG ret, flags, bufLen;
  362. bool found = false;
  363. flags = GAA_FLAG_INCLUDE_ALL_INTERFACES;
  364. bufLen = 0;
  365. ret = GetAdaptersAddresses(AF_UNSPEC, flags, NULL, NULL, &bufLen);
  366. if (ret != ERROR_BUFFER_OVERFLOW) {
  367. win_perror2("GetAdaptersAddresses", ret);
  368. return false;
  369. }
  370. bufLen *= 2;
  371. adapters = malloc(bufLen);
  372. if (!adapters) {
  373. xperror("malloc");
  374. return false;
  375. }
  376. ret = GetAdaptersAddresses(AF_UNSPEC, flags, NULL, adapters, &bufLen);
  377. if (ret == NO_ERROR) {
  378. for (adapter = adapters; adapter; adapter = adapter->Next) {
  379. if (verbosity > 2) {
  380. printf(" %s: Type=%lu, Name=%ls\n", adapter->AdapterName, adapter->IfType, adapter->FriendlyName);
  381. }
  382. if (adapter->IfType != IF_TYPE_ETHERNET_CSMACD && adapter->IfType != IF_TYPE_IEEE80211) {
  383. continue;
  384. }
  385. /* Interface names from WinPcap are "\Device\NPF_{GUID}", while
  386. * AdapterName from GetAdaptersAddresses is just "{GUID}".*/
  387. if (strstr(intf, adapter->AdapterName)) {
  388. if (adapter->PhysicalAddressLength == 6) {
  389. memcpy(hwaddr, adapter->PhysicalAddress, 6);
  390. if (index) {
  391. *index = adapter->IfIndex;
  392. }
  393. found = true;
  394. break;
  395. }
  396. }
  397. }
  398. } else {
  399. win_perror2("GetAdaptersAddresses", ret);
  400. }
  401. free(adapters);
  402. return found;
  403. }
  404. static const char *intf_name_to_wpcap(const char *intf)
  405. {
  406. static char buf[128];
  407. if (intf[0] == '\\') {
  408. return intf;
  409. }
  410. do {
  411. NET_IFINDEX index;
  412. DWORD err;
  413. NET_LUID luid;
  414. GUID guid;
  415. if (sscanf(intf, "net%lu", &index) != 1) {
  416. index = if_nametoindex(intf);
  417. if (!index) {
  418. break;
  419. }
  420. }
  421. err = ConvertInterfaceIndexToLuid(index, &luid);
  422. if (err != NO_ERROR) {
  423. if (verbosity) {
  424. win_perror2("ConvertInterfaceIndexToLuid", err);
  425. }
  426. break;
  427. }
  428. err = ConvertInterfaceLuidToGuid(&luid, &guid);
  429. if (err != NO_ERROR) {
  430. if (verbosity) {
  431. win_perror2("ConvertInterfaceLuidToGuid", err);
  432. }
  433. break;
  434. }
  435. snprintf(buf, sizeof(buf),
  436. "\\Device\\NPF_{%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
  437. guid.Data1, guid.Data2, guid.Data3,
  438. guid.Data4[0], guid.Data4[1], guid.Data4[2],
  439. guid.Data4[3], guid.Data4[4], guid.Data4[5],
  440. guid.Data4[6], guid.Data4[7]);
  441. return buf;
  442. } while (false);
  443. fprintf(stderr, "Invalid interface name.\n");
  444. return NULL;
  445. }
  446. NET_IFINDEX intf_get_index(const char* intf)
  447. {
  448. const char* p;
  449. GUID guid;
  450. NET_LUID luid;
  451. DWORD err;
  452. NET_IFINDEX ret;
  453. int n;
  454. p = strstr(intf, "NPF_{");
  455. if (!p) {
  456. return 0;
  457. }
  458. sscanf(p + 5,
  459. "%08lX-%04hX-%04hX-%02hhX%02hhX-%02hhX%02hhX%02hhX%02hhX%02hhX%02hhX%n",
  460. &guid.Data1, &guid.Data2, &guid.Data3,
  461. &guid.Data4[0], &guid.Data4[1], &guid.Data4[2],
  462. &guid.Data4[3], &guid.Data4[4], &guid.Data4[5],
  463. &guid.Data4[6], &guid.Data4[7], &n);
  464. if (n != 36) {
  465. return 0;
  466. }
  467. err = ConvertInterfaceGuidToLuid(&guid, &luid);
  468. if (err) {
  469. win_perror2("ConvertInterfaceGuidToLuid", err);
  470. return 0;
  471. }
  472. err = ConvertInterfaceLuidToIndex(&luid, &ret);
  473. if (err) {
  474. win_perror2("ConvertInterfaceLuidToIndex", err);
  475. return 0;
  476. }
  477. return ret;
  478. }
  479. #endif
  480. #ifdef NMRPFLASH_OSX
  481. void cf_perror(const char* function)
  482. {
  483. if (verbosity > 1) {
  484. fprintf(stderr, "Warning: %s failed\n", function);
  485. }
  486. }
  487. CFStringRef to_cfstring(const char* str)
  488. {
  489. CFStringRef ret = CFStringCreateWithFileSystemRepresentation(
  490. kCFAllocatorDefault, str);
  491. if (!ret) {
  492. cf_perror("CFStringCreateWithFileSystemRepresentation");
  493. }
  494. return ret;
  495. }
  496. CFPropertyListRef plist_open(const char* filename)
  497. {
  498. CFURLRef url = NULL;
  499. CFReadStreamRef stream = NULL;
  500. CFPropertyListRef plist = NULL;
  501. do {
  502. url = CFURLCreateFromFileSystemRepresentation(
  503. kCFAllocatorDefault, (const UInt8*)filename,
  504. strlen(filename), false);
  505. if (!url) {
  506. cf_perror("CFURLCreateFromFileSystemRepresentation");
  507. break;
  508. }
  509. stream = CFReadStreamCreateWithFile(kCFAllocatorDefault, url);
  510. if (!stream) {
  511. cf_perror("CFReadStreamCreateWithFile");
  512. break;
  513. }
  514. if (!CFReadStreamOpen(stream)) {
  515. cf_perror("CFReadStreamOpen");
  516. break;
  517. }
  518. plist = CFPropertyListCreateWithStream(
  519. kCFAllocatorDefault, stream, 0,
  520. kCFPropertyListImmutable, NULL, NULL);
  521. if (!plist) {
  522. cf_perror("CFPropertyListCreateWithStream");
  523. break;
  524. }
  525. } while (false);
  526. if (url) {
  527. CFRelease(url);
  528. }
  529. if (stream) {
  530. CFReadStreamClose(stream);
  531. CFRelease(stream);
  532. }
  533. return plist;
  534. }
  535. bool dict_get_value(CFDictionaryRef dict, const char* key, const void** value)
  536. {
  537. CFStringRef cfkey = to_cfstring(key);
  538. if (!cfkey) {
  539. return false;
  540. }
  541. Boolean status = CFDictionaryGetValueIfPresent(dict, cfkey, value);
  542. CFRelease(cfkey);
  543. return status;
  544. }
  545. char* dict_get_string(CFDictionaryRef dict, const char* key)
  546. {
  547. CFStringRef str;
  548. if (!dict_get_value(dict, key, (const void**)&str)) {
  549. return NULL;
  550. }
  551. CFIndex len = CFStringGetLength(str) + 1;
  552. char* buf = (char*)malloc(len);
  553. if (!buf) {
  554. perror("malloc");
  555. return NULL;
  556. }
  557. Boolean status = CFStringGetFileSystemRepresentation(
  558. str, buf, len);
  559. if (!status) {
  560. cf_perror("CFStringGetFileSystemRepresentation");
  561. free(buf);
  562. return NULL;
  563. }
  564. return buf;
  565. }
  566. typedef struct {
  567. const char* device;
  568. char* pretty;
  569. } find_pretty_name_ctx;
  570. void find_pretty_name(const void* key, const void* value, void* context)
  571. {
  572. find_pretty_name_ctx* ctx = (find_pretty_name_ctx*)context;
  573. if (ctx->pretty) {
  574. return;
  575. }
  576. CFDictionaryRef dict;
  577. if (!dict_get_value((CFDictionaryRef)value, "Interface", (const void**)&dict)) {
  578. return;
  579. }
  580. char* device = dict_get_string(dict, "DeviceName");
  581. if (!device) {
  582. return;
  583. }
  584. if (!strcmp(ctx->device, device)) {
  585. ctx->pretty = dict_get_string(dict, "UserDefinedName");
  586. }
  587. free(device);
  588. }
  589. char* get_pretty_name(const char* interface)
  590. {
  591. CFPropertyListRef plist = plist_open("/Library/Preferences/SystemConfiguration/preferences.plist");
  592. if (!plist) {
  593. return NULL;
  594. }
  595. // what we're after is a CFDictionary element with the path
  596. // /NetworkServices/<UUID>/Interface. The keys we're interested
  597. // in are DeviceName (the network interface name), and UserDefinedName
  598. // (the pretty name). Since we don't know the interface's UUID,
  599. // we have to loop through all of them.
  600. CFDictionaryRef dict;
  601. find_pretty_name_ctx ctx = { interface, NULL };
  602. if (dict_get_value((CFDictionaryRef)plist, "NetworkServices", (const void**)&dict)) {
  603. CFDictionaryApplyFunction(dict, find_pretty_name, &ctx);
  604. }
  605. CFRelease(plist);
  606. return ctx.pretty;
  607. }
  608. #endif
  609. inline uint8_t *ethsock_get_hwaddr(struct ethsock *sock)
  610. {
  611. return sock->hwaddr;
  612. }
  613. bool ethsock_is_wifi(struct ethsock *sock)
  614. {
  615. #ifdef PCAP_IF_WIRELESS
  616. bpf_u_int32 flags;
  617. if (!intf_get_pcap_flags(sock->intf, &flags)) {
  618. return false;
  619. }
  620. return flags & PCAP_IF_WIRELESS;
  621. #else
  622. #warning "libpcap version is < 1.9.0"
  623. return false;
  624. #endif
  625. }
  626. bool ethsock_is_unplugged(struct ethsock *sock)
  627. {
  628. #ifdef PCAP_IF_CONNECTION_STATUS
  629. bpf_u_int32 flags;
  630. if (!intf_get_pcap_flags(sock->intf, &flags)) {
  631. return false;
  632. }
  633. return (flags & PCAP_IF_CONNECTION_STATUS)
  634. == PCAP_IF_CONNECTION_STATUS_DISCONNECTED;
  635. #else
  636. #warning "libpcap version is < 1.9.0"
  637. return false;
  638. #endif
  639. }
  640. struct ethsock *ethsock_create(const char *intf, uint16_t protocol)
  641. {
  642. char buf[PCAP_ERRBUF_SIZE];
  643. struct bpf_program fp;
  644. struct ethsock *sock;
  645. bool is_bridge = false;
  646. int err;
  647. #ifdef NMRPFLASH_WINDOWS
  648. intf = intf_name_to_wpcap(intf);
  649. if (!intf) {
  650. return NULL;
  651. }
  652. #endif
  653. sock = malloc(sizeof(struct ethsock));
  654. if (!sock) {
  655. xperror("malloc");
  656. return NULL;
  657. }
  658. buf[0] = '\0';
  659. sock->intf = intf;
  660. sock->pcap = pcap_create(sock->intf, buf);
  661. if (!sock->pcap) {
  662. fprintf(stderr, "pcap_create: %s\n", buf);
  663. }
  664. if (*buf) {
  665. fprintf(stderr, "Warning: %s.\n", buf);
  666. }
  667. err = pcap_set_snaplen(sock->pcap, BUFSIZ);
  668. if (err) {
  669. pcap_perror(sock->pcap, "pcap_set_snaplen");
  670. goto cleanup;
  671. }
  672. err = pcap_set_promisc(sock->pcap, 1);
  673. if (err) {
  674. pcap_perror(sock->pcap, "pcap_set_promisc");
  675. goto cleanup;
  676. }
  677. err = pcap_set_timeout(sock->pcap, 200);
  678. if (err) {
  679. pcap_perror(sock->pcap, "pcap_set_timeout");
  680. goto cleanup;
  681. }
  682. err = pcap_set_immediate_mode(sock->pcap, 1);
  683. if (err) {
  684. pcap_perror(sock->pcap, "pcap_set_immediate_mode");
  685. goto cleanup;
  686. }
  687. err = pcap_activate(sock->pcap);
  688. if (err < 0) {
  689. pcap_perror(sock->pcap, "pcap_activate");
  690. goto cleanup;
  691. } else if (err > 0) {
  692. fprintf(stderr, "Warning: %s.\n", pcap_geterr(sock->pcap));
  693. }
  694. if (pcap_datalink(sock->pcap) != DLT_EN10MB) {
  695. fprintf(stderr, "%s is not an ethernet interface.\n",
  696. intf);
  697. goto cleanup;
  698. }
  699. #ifndef NMRPFLASH_WINDOWS
  700. err = !intf_get_hwaddr_and_bridge(intf, sock->hwaddr, &is_bridge);
  701. #else
  702. err = !intf_get_hwaddr_and_index(intf, sock->hwaddr, &sock->index);
  703. #endif
  704. if (err) {
  705. fprintf(stderr, "Failed to get interface info.\n");
  706. goto cleanup;
  707. }
  708. #ifdef NMRPFLASH_WINDOWS
  709. err = pcap_setmintocopy(sock->pcap, 0);
  710. if (err) {
  711. pcap_perror(sock->pcap, "pcap_setmintocopy");
  712. goto cleanup;
  713. }
  714. sock->handle = pcap_getevent(sock->pcap);
  715. if (!sock->handle) {
  716. pcap_perror(sock->pcap, "pcap_getevent");
  717. goto cleanup;
  718. }
  719. #else
  720. sock->fd = pcap_get_selectable_fd(sock->pcap);
  721. if (sock->fd == -1) {
  722. pcap_perror(sock->pcap, "pcap_get_selectable_fd");
  723. goto cleanup;
  724. }
  725. #endif
  726. snprintf(buf, sizeof(buf), "ether proto 0x%04x and not ether src %s",
  727. protocol, mac_to_str(sock->hwaddr));
  728. err = pcap_compile(sock->pcap, &fp, buf, 0, 0);
  729. if (err) {
  730. pcap_perror(sock->pcap, "pcap_compile");
  731. goto cleanup;
  732. }
  733. err = pcap_setfilter(sock->pcap, &fp);
  734. pcap_freecode(&fp);
  735. if (err) {
  736. pcap_perror(sock->pcap, "pcap_setfilter");
  737. goto cleanup;
  738. }
  739. #ifdef NMRPFLASH_LINUX
  740. // nmrpflash does not work on bridge interfaces with STP enabled
  741. if ((sock->stp = intf_sys_read(intf, "bridge/stp_state", false))) {
  742. if (!intf_stp_enable(intf, false)) {
  743. fprintf(stderr, "Warning: failed to disable STP on %s.\n", intf);
  744. }
  745. }
  746. err = system("nmcli -v > /dev/null");
  747. if (!err) {
  748. err = systemf("nmcli -f GENERAL.STATE device show %s | grep -q unmanaged", sock->intf);
  749. if (!err) {
  750. sock->nm_managed = false;
  751. } else {
  752. sock->nm_managed = true;
  753. err = systemf("nmcli device set ifname %s managed no", sock->intf);
  754. if (err) {
  755. printf("Warning: failed to temporarily disable NetworkManager\n");
  756. } else if (verbosity > 1) {
  757. printf("Temporarily disabling NetworkManager on interface.\n");
  758. }
  759. }
  760. } else {
  761. sock->nm_managed = false;
  762. }
  763. #else
  764. if (is_bridge) {
  765. fprintf(stderr, "Warning: bridge interfaces are not fully "
  766. "supported on this platform.\n");
  767. }
  768. #endif
  769. return sock;
  770. cleanup:
  771. ethsock_close(sock);
  772. return NULL;
  773. }
  774. ssize_t ethsock_recv(struct ethsock *sock, void *buf, size_t len)
  775. {
  776. struct pcap_pkthdr* hdr;
  777. const u_char *capbuf;
  778. int status;
  779. #ifdef NMRPFLASH_WINDOWS
  780. DWORD ret;
  781. if (sock->timeout) {
  782. ret = WaitForSingleObject(sock->handle, sock->timeout);
  783. if (ret == WAIT_TIMEOUT) {
  784. return 0;
  785. } else if (ret != WAIT_OBJECT_0) {
  786. win_perror2("WaitForSingleObject", ret);
  787. return -1;
  788. }
  789. }
  790. #else
  791. if (sock->timeout) {
  792. status = select_fd(sock->fd, sock->timeout);
  793. if (status < 0) {
  794. return -1;
  795. } else if (status == 0) {
  796. return 0;
  797. }
  798. }
  799. #endif
  800. status = pcap_next_ex(sock->pcap, &hdr, &capbuf);
  801. switch (status) {
  802. case 1:
  803. memcpy(buf, capbuf, MIN(len, hdr->caplen));
  804. return hdr->caplen;
  805. case 0:
  806. return 0;
  807. case -1:
  808. pcap_perror(sock->pcap, "pcap_next_ex");
  809. return -1;
  810. default:
  811. fprintf(stderr, "pcap_next_ex: returned %d.\n", status);
  812. return -1;
  813. }
  814. }
  815. int ethsock_send(struct ethsock *sock, void *buf, size_t len)
  816. {
  817. if (pcap_inject(sock->pcap, buf, len) != len) {
  818. #ifdef NMRPFLASH_WINDOWS
  819. // Npcap's pcap_inject fails in many cases where neither
  820. // Linux or macOS report an error. For now, we simply
  821. // ignore errors if unplugged (and let all other through
  822. // as well, just printing a debug line).
  823. if (!ethsock_is_unplugged(sock) && verbosity > 1) {
  824. pcap_perror(sock->pcap, "pcap_inject");
  825. }
  826. return 0;
  827. #endif
  828. pcap_perror(sock->pcap, "pcap_inject");
  829. return -1;
  830. }
  831. return 0;
  832. }
  833. int ethsock_close(struct ethsock *sock)
  834. {
  835. if (!sock) {
  836. return 0;
  837. }
  838. #ifdef NMRPFLASH_LINUX
  839. if (sock->stp) {
  840. intf_stp_enable(sock->intf, true);
  841. }
  842. if (sock->nm_managed) {
  843. systemf("nmcli device set ifname %s managed yes", sock->intf);
  844. }
  845. #endif
  846. if (sock->pcap) {
  847. pcap_close(sock->pcap);
  848. }
  849. free(sock);
  850. return 0;
  851. }
  852. inline int ethsock_set_timeout(struct ethsock *sock, unsigned msec)
  853. {
  854. sock->timeout = msec;
  855. return 0;
  856. }
  857. unsigned ethsock_get_timeout(struct ethsock *sock)
  858. {
  859. return sock->timeout;
  860. }
  861. static int ethsock_arp(struct ethsock *sock, uint8_t *hwaddr, uint32_t ipaddr, struct ethsock_arp_undo **undo)
  862. {
  863. #if defined(NMRPFLASH_UNIX) && !defined(NMRPFLASH_LINUX)
  864. struct in_addr addr = { .s_addr = ipaddr };
  865. #elif defined(NMRPFLASH_WINDOWS)
  866. DWORD err;
  867. MIB_IPNETROW arp = {
  868. .dwIndex = sock->index,
  869. .dwPhysAddrLen = 6,
  870. .dwAddr = ipaddr,
  871. .dwType = MIB_IPNET_TYPE_STATIC
  872. };
  873. memcpy(arp.bPhysAddr, hwaddr, 6);
  874. #endif
  875. if (undo) {
  876. #if defined(NMRPFLASH_LINUX)
  877. if (!intf_add_del_arp(sock->intf, ipaddr, hwaddr, true)) {
  878. return -1;
  879. }
  880. #elif defined(NMRPFLASH_WINDOWS)
  881. err = CreateIpNetEntry(&arp);
  882. if (err != NO_ERROR) {
  883. win_perror2("CreateIpNetEntry", err);
  884. return -1;
  885. }
  886. #else
  887. if (systemf("arp -s %s %s", inet_ntoa(addr), mac_to_str(hwaddr)) != 0) {
  888. return -1;
  889. }
  890. #endif
  891. *undo = malloc(sizeof(struct ethsock_arp_undo));
  892. if (!*undo) {
  893. xperror("malloc");
  894. return -1;
  895. }
  896. (*undo)->ipaddr = ipaddr;
  897. memcpy((*undo)->hwaddr, hwaddr, 6);
  898. } else {
  899. #if defined(NMRPFLASH_LINUX)
  900. if (!intf_add_del_arp(sock->intf, ipaddr, hwaddr, false)) {
  901. return -1;
  902. }
  903. #elif defined(NMRPFLASH_WINDOWS)
  904. return DeleteIpNetEntry(&arp) ? 0 : -1;
  905. #else
  906. return systemf("arp -d %s &> /dev/null", inet_ntoa(addr));
  907. #endif
  908. }
  909. return 0;
  910. }
  911. int ethsock_arp_add(struct ethsock *sock, uint8_t *hwaddr, uint32_t ipaddr, struct ethsock_arp_undo **undo)
  912. {
  913. // remove any previous ARP entry
  914. ethsock_arp(sock, hwaddr, ipaddr, NULL);
  915. // add the new ARP entry
  916. return undo ? ethsock_arp(sock, hwaddr, ipaddr, undo) : -1;
  917. }
  918. int ethsock_arp_del(struct ethsock *sock, struct ethsock_arp_undo **undo)
  919. {
  920. if (!*undo) {
  921. return 0;
  922. }
  923. int ret = ethsock_arp(sock, (*undo)->hwaddr, (*undo)->ipaddr, NULL);
  924. free(*undo);
  925. *undo = NULL;
  926. return ret;
  927. }
  928. static bool get_hwaddr_from_pcap(const pcap_if_t *dev, uint8_t *hwaddr)
  929. {
  930. #ifndef NMRPFLASH_WINDOWS
  931. pcap_addr_t *addr;
  932. int i;
  933. for (addr = dev->addresses; addr; addr = addr->next) {
  934. if (verbosity > 1) {
  935. printf("%s: sa_family=%d, sa_data={ ", dev->name,
  936. addr->addr->sa_family);
  937. for (i = 0; i != sizeof(addr->addr->sa_data); ++i) {
  938. printf("%02x ", addr->addr->sa_data[i] & 0xff);
  939. }
  940. printf("}\n");
  941. }
  942. if (sockaddr_get_hwaddr(addr->addr, hwaddr)) {
  943. return true;
  944. }
  945. }
  946. return intf_get_hwaddr_and_bridge(dev->name, hwaddr, NULL);
  947. #else
  948. return intf_get_hwaddr_and_index(dev->name, hwaddr, NULL);
  949. #endif
  950. }
  951. int ethsock_list_all(void)
  952. {
  953. pcap_if_t *devs, *dev;
  954. pcap_addr_t *addr;
  955. uint8_t hwaddr[6];
  956. unsigned dev_num = 0, dev_ok = 0;
  957. #if defined(NMRPFLASH_WINDOWS)
  958. wchar_t *pretty = NULL;
  959. NET_IFINDEX index;
  960. MIB_IF_ROW2 row;
  961. #elif defined(NMRPFLASH_OSX)
  962. char *pretty = NULL;
  963. #endif
  964. if (x_pcap_findalldevs(&devs) != 0) {
  965. return -1;
  966. }
  967. memset(hwaddr, 0, 6);
  968. for (dev = devs; dev; dev = dev->next, ++dev_num) {
  969. if (dev->flags & PCAP_IF_LOOPBACK) {
  970. if (verbosity) {
  971. printf("%-15s (loopback device)\n", dev->name);
  972. }
  973. continue;
  974. }
  975. if (!get_hwaddr_from_pcap(dev, hwaddr)) {
  976. if (verbosity) {
  977. printf("%-15s (not an ethernet device)\n",
  978. dev->name);
  979. }
  980. continue;
  981. }
  982. #ifndef NMRPFLASH_WINDOWS
  983. printf("%-15s", dev->name);
  984. # ifdef NMRPFLASH_OSX
  985. pretty = get_pretty_name(dev->name);
  986. # endif
  987. #else
  988. index = intf_get_index(dev->name);
  989. if (intf_get_if_row(index, &row)) {
  990. if (!row.InterfaceAndOperStatusFlags.HardwareInterface) {
  991. if (verbosity) {
  992. printf("%-15s (virtual interface)\n", dev->name);
  993. }
  994. continue;
  995. }
  996. if (row.Alias[0]) {
  997. pretty = row.Alias;
  998. }
  999. }
  1000. if (!verbosity && index) {
  1001. printf("net%-2lu", index);
  1002. } else {
  1003. printf("%-15s", dev->name);
  1004. }
  1005. #endif
  1006. for (addr = dev->addresses; addr; addr = addr->next) {
  1007. if (addr->addr->sa_family == AF_INET) {
  1008. printf(" %-15s",
  1009. inet_ntoa(((struct sockaddr_in*)addr->addr)->sin_addr));
  1010. break;
  1011. }
  1012. }
  1013. if (!addr) {
  1014. printf(" %-15s", "0.0.0.0");
  1015. }
  1016. printf(" %s", mac_to_str(hwaddr));
  1017. #if defined(NMRPFLASH_WINDOWS) || defined(NMRPFLASH_OSX)
  1018. if (pretty) {
  1019. printf(" (" NMRPFLASH_PRETTY_FMT ")", pretty);
  1020. } else if (dev->description) {
  1021. printf(" (%s)", dev->description);
  1022. }
  1023. #endif
  1024. #ifdef NMRPFLASH_OSX
  1025. free(pretty);
  1026. #endif
  1027. printf("\n");
  1028. ++dev_ok;
  1029. }
  1030. if (!dev_ok) {
  1031. printf("No suitable network interfaces found.\n");
  1032. }
  1033. return 0;
  1034. }
  1035. int ethsock_for_each_ip(struct ethsock *sock, ethsock_ip_callback_t callback,
  1036. void *arg)
  1037. {
  1038. struct ethsock_ip_callback_args args;
  1039. pcap_if_t *devs, *dev;
  1040. pcap_addr_t *addr;
  1041. int status = 0;
  1042. if (x_pcap_findalldevs(&devs) != 0) {
  1043. return -1;
  1044. }
  1045. args.arg = arg;
  1046. for (dev = devs; dev; dev = dev->next) {
  1047. if (strcmp(sock->intf, dev->name)) {
  1048. continue;
  1049. }
  1050. for (addr = dev->addresses; addr; addr = addr->next) {
  1051. if (addr->addr->sa_family == AF_INET) {
  1052. args.ipaddr = &((struct sockaddr_in*)addr->addr)->sin_addr;
  1053. args.ipmask = &((struct sockaddr_in*)addr->netmask)->sin_addr;
  1054. status = callback(&args);
  1055. if (status <= 0) {
  1056. break;
  1057. }
  1058. }
  1059. }
  1060. break;
  1061. }
  1062. pcap_freealldevs(devs);
  1063. return status <= 0 ? status : 0;
  1064. }
  1065. static inline void set_addr(void *p, uint32_t addr)
  1066. {
  1067. struct sockaddr_in* sin = p;
  1068. sin->sin_family = AF_INET;
  1069. sin->sin_addr.s_addr = addr;
  1070. #ifdef NMRPFLASH_BSD
  1071. ((struct sockaddr*)p)->sa_len = sizeof(struct sockaddr_in);
  1072. #endif
  1073. }
  1074. #if !defined(NMRPFLASH_WINDOWS) && !defined(NMRPFLASH_LINUX)
  1075. static bool intf_up(int fd, const char *intf, bool up)
  1076. {
  1077. struct ifreq ifr;
  1078. strncpy(ifr.ifr_name, intf, IFNAMSIZ);
  1079. if (ioctl(fd, SIOCGIFFLAGS, &ifr) != 0) {
  1080. if (up) {
  1081. xperror("ioctl(SIOCGIFFLAGS)");
  1082. }
  1083. return false;
  1084. }
  1085. if (!up) {
  1086. ifr.ifr_flags &= ~(IFF_UP | IFF_RUNNING);
  1087. } else {
  1088. ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
  1089. }
  1090. if (ioctl(fd, SIOCSIFFLAGS, &ifr) != 0) {
  1091. if (up) {
  1092. xperror("ioctl(SIOCSIFFLAGS)");
  1093. }
  1094. return false;
  1095. }
  1096. return true;
  1097. }
  1098. #endif
  1099. static int ethsock_ip_add_del(struct ethsock *sock, uint32_t ipaddr, uint32_t ipmask, struct ethsock_ip_undo **undo, bool add)
  1100. {
  1101. int ret, fd;
  1102. if (add && undo) {
  1103. if (!(*undo = malloc(sizeof(struct ethsock_ip_undo)))) {
  1104. xperror("malloc");
  1105. return -1;
  1106. }
  1107. (*undo)->ip[0] = ipaddr;
  1108. (*undo)->ip[1] = ipmask;
  1109. } else if (!add && (!undo || !*undo)) {
  1110. return 0;
  1111. }
  1112. ret = -1;
  1113. fd = socket(AF_INET, SOCK_DGRAM, 0);
  1114. if (fd < 0) {
  1115. sock_perror("socket");
  1116. goto out;
  1117. }
  1118. #ifndef NMRPFLASH_WINDOWS
  1119. #ifdef NMRPFLASH_LINUX
  1120. if (!intf_add_del_ip(sock->intf, (*undo)->ip[0], (*undo)->ip[1], add)) {
  1121. goto out;
  1122. }
  1123. #else // NMRPFLASH_OSX (or any other BSD)
  1124. struct ifaliasreq ifra;
  1125. memset(&ifra, 0, sizeof(ifra));
  1126. strncpy(ifra.ifra_name, sock->intf, IFNAMSIZ);
  1127. set_addr(&ifra.ifra_addr, ipaddr);
  1128. set_addr(&ifra.ifra_mask, ipmask);
  1129. //set_addr(&ifra.ifra_broadaddr, (ipaddr & ipmask) | ~ipmask);
  1130. if (ioctl(fd, add ? SIOCAIFADDR : SIOCDIFADDR, &ifra) != 0) {
  1131. if (add) {
  1132. xperror("ioctl(SIOCAIFADDR");
  1133. }
  1134. goto out;
  1135. }
  1136. if (add) {
  1137. (*undo)->ip[0] = ipaddr;
  1138. (*undo)->ip[1] = ipmask;
  1139. intf_up(fd, ifra.ifra_name, true);
  1140. }
  1141. #endif
  1142. #else // NMRPFLASH_WINDOWS
  1143. MIB_UNICASTIPADDRESS_ROW row;
  1144. DWORD err;
  1145. int i;
  1146. memset(&row, 0, sizeof(row));
  1147. row.InterfaceIndex = sock->index;
  1148. set_addr(&row.Address.Ipv4, ipaddr);
  1149. row.Address.si_family = AF_INET;
  1150. if (add) {
  1151. row.PrefixOrigin = IpPrefixOriginManual;
  1152. row.SuffixOrigin = IpPrefixOriginManual;
  1153. row.OnLinkPrefixLength = bitcount(ipmask);
  1154. row.SkipAsSource = false;
  1155. row.PreferredLifetime = 0xffffffff;
  1156. row.ValidLifetime = 0xffffffff;
  1157. }
  1158. if (add) {
  1159. err = CreateUnicastIpAddressEntry(&row);
  1160. if (err != NO_ERROR && err != ERROR_OBJECT_ALREADY_EXISTS) {
  1161. win_perror2("CreateUnicastIpAddressEntry", err);
  1162. goto out;
  1163. }
  1164. if (err != ERROR_OBJECT_ALREADY_EXISTS) {
  1165. /* Wait until the new IP has actually been added */
  1166. for (i = 0; i < 20; ++i) {
  1167. err = GetUnicastIpAddressEntry(&row);
  1168. if (err != NO_ERROR) {
  1169. win_perror2("GetUnicastIpAddressEntry", err);
  1170. goto out;
  1171. }
  1172. if (row.DadState == IpDadStateTentative) {
  1173. Sleep(500);
  1174. } else {
  1175. break;
  1176. }
  1177. }
  1178. if (row.DadState == IpDadStateDeprecated) {
  1179. fprintf(stderr, "Warning: IP address marked as deprecated.\n");
  1180. } else if (row.DadState == IpDadStateTentative) {
  1181. fprintf(stderr, "Warning: IP address marked as tentative.\n");
  1182. } else if (row.DadState != IpDadStatePreferred) {
  1183. fprintf(stderr, "Failed to add IP address (state=%d).\n", row.DadState);
  1184. goto out;
  1185. }
  1186. }
  1187. } else {
  1188. err = DeleteUnicastIpAddressEntry(&row);
  1189. if (err != NO_ERROR) {
  1190. win_perror2("DeleteUnicastIpAddressEntry", err);
  1191. goto out;
  1192. }
  1193. }
  1194. #endif
  1195. ret = 0;
  1196. out:
  1197. #ifndef NMRPFLASH_WINDOWS
  1198. close(fd);
  1199. #else
  1200. closesocket(fd);
  1201. #endif
  1202. if (ret != 0 && undo) {
  1203. free(*undo);
  1204. *undo = NULL;
  1205. }
  1206. return ret;
  1207. }
  1208. int ethsock_ip_add(struct ethsock *sock, uint32_t ipaddr, uint32_t ipmask, struct ethsock_ip_undo **undo)
  1209. {
  1210. return ethsock_ip_add_del(sock, ipaddr, ipmask, undo, true);
  1211. }
  1212. int ethsock_ip_del(struct ethsock *sock, struct ethsock_ip_undo **undo)
  1213. {
  1214. if (!undo || !*undo) {
  1215. return 0;
  1216. }
  1217. int ret;
  1218. if ((*undo)->ip[0] != INADDR_NONE) {
  1219. ret = ethsock_ip_add_del(sock, (*undo)->ip[0], (*undo)->ip[1], undo, false);
  1220. } else {
  1221. ret = 0;
  1222. }
  1223. free(*undo);
  1224. *undo = NULL;
  1225. return ret;
  1226. }