LinuxEthernetTap.cpp 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570
  1. /*
  2. * Copyright (c)2019 ZeroTier, Inc.
  3. *
  4. * Use of this software is governed by the Business Source License included
  5. * in the LICENSE.TXT file in the project's root directory.
  6. *
  7. * Change Date: 2025-01-01
  8. *
  9. * On the date above, in accordance with the Business Source License, use
  10. * of this software will be governed by version 2.0 of the Apache License.
  11. */
  12. /****/
  13. #ifdef __GNUC__
  14. #pragma GCC diagnostic ignored "-Wrestrict"
  15. #endif
  16. #include "../node/Constants.hpp"
  17. #ifdef __LINUX__
  18. #include "../node/Utils.hpp"
  19. #include "../node/Mutex.hpp"
  20. #include "../node/Dictionary.hpp"
  21. #include "OSUtils.hpp"
  22. #include "LinuxEthernetTap.hpp"
  23. #include "LinuxNetLink.hpp"
  24. #include <stdint.h>
  25. #include <stdio.h>
  26. #include <stdlib.h>
  27. #include <string.h>
  28. #include <unistd.h>
  29. #include <signal.h>
  30. #include <fcntl.h>
  31. #include <errno.h>
  32. #include <sys/types.h>
  33. #include <sys/stat.h>
  34. #include <sys/ioctl.h>
  35. #include <sys/wait.h>
  36. #include <sys/select.h>
  37. #include <netinet/in.h>
  38. #include <net/if_arp.h>
  39. #include <arpa/inet.h>
  40. #include <linux/if.h>
  41. #include <linux/if_tun.h>
  42. #include <linux/if_addr.h>
  43. #include <linux/if_ether.h>
  44. #include <ifaddrs.h>
  45. #include <algorithm>
  46. #include <utility>
  47. #include <string>
  48. #ifndef IFNAMSIZ
  49. #define IFNAMSIZ 16
  50. #endif
  51. #define ZT_TAP_BUF_SIZE 16384
  52. // ff:ff:ff:ff:ff:ff with no ADI
  53. static const ZeroTier::MulticastGroup _blindWildcardMulticastGroup(ZeroTier::MAC(0xff),0);
  54. namespace ZeroTier {
  55. static const char _base32_chars[32] = { 'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','2','3','4','5','6','7' };
  56. static void _base32_5_to_8(const uint8_t *in,char *out)
  57. {
  58. out[0] = _base32_chars[(in[0]) >> 3];
  59. out[1] = _base32_chars[(in[0] & 0x07) << 2 | (in[1] & 0xc0) >> 6];
  60. out[2] = _base32_chars[(in[1] & 0x3e) >> 1];
  61. out[3] = _base32_chars[(in[1] & 0x01) << 4 | (in[2] & 0xf0) >> 4];
  62. out[4] = _base32_chars[(in[2] & 0x0f) << 1 | (in[3] & 0x80) >> 7];
  63. out[5] = _base32_chars[(in[3] & 0x7c) >> 2];
  64. out[6] = _base32_chars[(in[3] & 0x03) << 3 | (in[4] & 0xe0) >> 5];
  65. out[7] = _base32_chars[(in[4] & 0x1f)];
  66. }
  67. LinuxEthernetTap::LinuxEthernetTap(
  68. const char *homePath,
  69. const MAC &mac,
  70. unsigned int mtu,
  71. unsigned int metric,
  72. uint64_t nwid,
  73. const char *friendlyName,
  74. void (*handler)(void *,void *,uint64_t,const MAC &,const MAC &,unsigned int,unsigned int,const void *,unsigned int),
  75. void *arg) :
  76. _handler(handler),
  77. _arg(arg),
  78. _nwid(nwid),
  79. _mac(mac),
  80. _homePath(homePath),
  81. _mtu(mtu),
  82. _fd(0),
  83. _enabled(true),
  84. _run(true)
  85. {
  86. static std::mutex s_tapCreateLock;
  87. char procpath[128],nwids[32];
  88. struct stat sbuf;
  89. // Create only one tap at a time globally.
  90. std::lock_guard<std::mutex> tapCreateLock(s_tapCreateLock);
  91. // Make sure Linux netlink is initialized.
  92. (void)LinuxNetLink::getInstance();
  93. OSUtils::ztsnprintf(nwids,sizeof(nwids),"%.16llx",nwid);
  94. _fd = ::open("/dev/net/tun",O_RDWR);
  95. if (_fd <= 0) {
  96. _fd = ::open("/dev/tun",O_RDWR);
  97. if (_fd <= 0)
  98. throw std::runtime_error(std::string("could not open TUN/TAP device: ") + strerror(errno));
  99. }
  100. struct ifreq ifr;
  101. memset(&ifr,0,sizeof(ifr));
  102. // Restore device names from legacy devicemap, but for new devices we use a base32-based
  103. // canonical device name.
  104. std::map<std::string,std::string> globalDeviceMap;
  105. FILE *devmapf = fopen((_homePath + ZT_PATH_SEPARATOR_S + "devicemap").c_str(),"r");
  106. if (devmapf) {
  107. char buf[256];
  108. while (fgets(buf,sizeof(buf),devmapf)) {
  109. char *x = (char *)0;
  110. char *y = (char *)0;
  111. char *saveptr = (char *)0;
  112. for(char *f=Utils::stok(buf,"\r\n=",&saveptr);(f);f=Utils::stok((char *)0,"\r\n=",&saveptr)) {
  113. if (!x) x = f;
  114. else if (!y) y = f;
  115. else break;
  116. }
  117. if ((x)&&(y)&&(x[0])&&(y[0]))
  118. globalDeviceMap[x] = y;
  119. }
  120. fclose(devmapf);
  121. }
  122. bool recalledDevice = false;
  123. std::map<std::string,std::string>::const_iterator gdmEntry = globalDeviceMap.find(nwids);
  124. if (gdmEntry != globalDeviceMap.end()) {
  125. Utils::scopy(ifr.ifr_name,sizeof(ifr.ifr_name),gdmEntry->second.c_str());
  126. OSUtils::ztsnprintf(procpath,sizeof(procpath),"/proc/sys/net/ipv4/conf/%s",ifr.ifr_name);
  127. recalledDevice = (stat(procpath,&sbuf) != 0);
  128. }
  129. if (!recalledDevice) {
  130. #ifdef __SYNOLOGY__
  131. int devno = 50;
  132. do {
  133. OSUtils::ztsnprintf(ifr.ifr_name,sizeof(ifr.ifr_name),"eth%d",devno++);
  134. OSUtils::ztsnprintf(procpath,sizeof(procpath),"/proc/sys/net/ipv4/conf/%s",ifr.ifr_name);
  135. } while (stat(procpath,&sbuf) == 0); // try zt#++ until we find one that does not exist
  136. #else
  137. uint64_t trial = 0; // incremented in the very unlikely event of a name collision with another network
  138. do {
  139. const uint64_t nwid40 = (nwid ^ (nwid >> 24)) + trial++;
  140. uint8_t tmp2[5];
  141. char tmp3[11];
  142. tmp2[0] = (uint8_t)((nwid40 >> 32) & 0xff);
  143. tmp2[1] = (uint8_t)((nwid40 >> 24) & 0xff);
  144. tmp2[2] = (uint8_t)((nwid40 >> 16) & 0xff);
  145. tmp2[3] = (uint8_t)((nwid40 >> 8) & 0xff);
  146. tmp2[4] = (uint8_t)(nwid40 & 0xff);
  147. tmp3[0] = 'z';
  148. tmp3[1] = 't';
  149. _base32_5_to_8(tmp2,tmp3 + 2);
  150. tmp3[10] = (char)0;
  151. memcpy(ifr.ifr_name,tmp3,11);
  152. OSUtils::ztsnprintf(procpath,sizeof(procpath),"/proc/sys/net/ipv4/conf/%s",ifr.ifr_name);
  153. } while (stat(procpath,&sbuf) == 0);
  154. #endif
  155. }
  156. ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
  157. if (ioctl(_fd,TUNSETIFF,(void *)&ifr) < 0) {
  158. ::close(_fd);
  159. throw std::runtime_error("unable to configure TUN/TAP device for TAP operation");
  160. }
  161. ::ioctl(_fd,TUNSETPERSIST,0); // valgrind may generate a false alarm here
  162. _dev = ifr.ifr_name;
  163. ::fcntl(_fd,F_SETFD,fcntl(_fd,F_GETFD) | FD_CLOEXEC);
  164. (void)::pipe(_shutdownSignalPipe);
  165. _thread_init_l.lock();
  166. for(unsigned int t=0;t<2;++t) {
  167. _tapReaderThread[t] = std::thread([this, t]{
  168. fd_set readfds,nullfds;
  169. int n,nfds,r;
  170. void *buf = nullptr;
  171. std::vector<void *> buffers;
  172. if (t == 0) {
  173. struct ifreq ifr;
  174. memset(&ifr,0,sizeof(ifr));
  175. strcpy(ifr.ifr_name,_dev.c_str());
  176. const int sock = socket(AF_INET,SOCK_DGRAM,0);
  177. if (sock <= 0)
  178. return;
  179. if (ioctl(sock,SIOCGIFFLAGS,(void *)&ifr) < 0) {
  180. ::close(sock);
  181. printf("WARNING: ioctl() failed setting up Linux tap device (bring interface up)\n");
  182. return;
  183. }
  184. ifr.ifr_flags |= IFF_UP;
  185. if (ioctl(sock,SIOCSIFFLAGS,(void *)&ifr) < 0) {
  186. ::close(sock);
  187. printf("WARNING: ioctl() failed setting up Linux tap device (bring interface up)\n");
  188. return;
  189. }
  190. // Some kernel versions seem to require you to yield while the device comes up
  191. // before they will accept MTU and MAC. For others it doesn't matter, but is
  192. // harmless. This was moved to the worker thread though so as not to block the
  193. // main ZeroTier loop.
  194. usleep(500000);
  195. ifr.ifr_ifru.ifru_hwaddr.sa_family = ARPHRD_ETHER;
  196. _mac.copyTo(ifr.ifr_ifru.ifru_hwaddr.sa_data,6);
  197. if (ioctl(sock,SIOCSIFHWADDR,(void *)&ifr) < 0) {
  198. ::close(sock);
  199. printf("WARNING: ioctl() failed setting up Linux tap device (set MAC)\n");
  200. return;
  201. }
  202. ifr.ifr_ifru.ifru_mtu = (int)_mtu;
  203. if (ioctl(sock,SIOCSIFMTU,(void *)&ifr) < 0) {
  204. ::close(sock);
  205. printf("WARNING: ioctl() failed setting up Linux tap device (set MTU)\n");
  206. return;
  207. }
  208. fcntl(_fd,F_SETFL,O_NONBLOCK);
  209. ::close(sock);
  210. _thread_init_l.unlock();
  211. } else {
  212. _thread_init_l.lock();
  213. _thread_init_l.unlock();
  214. }
  215. if (!_run)
  216. return;
  217. FD_ZERO(&readfds);
  218. FD_ZERO(&nullfds);
  219. nfds = (int)std::max(_shutdownSignalPipe[0],_fd) + 1;
  220. r = 0;
  221. for(;;) {
  222. FD_SET(_shutdownSignalPipe[0],&readfds);
  223. FD_SET(_fd,&readfds);
  224. select(nfds,&readfds,&nullfds,&nullfds,(struct timeval *)0);
  225. if (FD_ISSET(_shutdownSignalPipe[0],&readfds)) // writes to shutdown pipe terminate thread
  226. break;
  227. if (FD_ISSET(_fd,&readfds)) {
  228. for(;;) { // read until there are no more packets, then return to outer select() loop
  229. if (!buf) {
  230. // To reduce use of the mutex, we keep a local buffer vector and
  231. // swap (which is a pointer swap) with the global one when it's
  232. // empty. This retrieves a batch of buffers to use.
  233. if (buffers.empty()) {
  234. std::lock_guard<std::mutex> l(_buffers_l);
  235. buffers.swap(_buffers);
  236. }
  237. if (buffers.empty()) {
  238. buf = malloc(ZT_TAP_BUF_SIZE);
  239. if (!buf)
  240. break;
  241. } else {
  242. buf = buffers.back();
  243. buffers.pop_back();
  244. }
  245. }
  246. n = (int)::read(_fd,reinterpret_cast<uint8_t *>(buf) + r,ZT_TAP_BUF_SIZE - r);
  247. if (n > 0) {
  248. // Some tap drivers like to send the ethernet frame and the
  249. // payload in two chunks, so handle that by accumulating
  250. // data until we have at least a frame.
  251. r += n;
  252. if (r > 14) {
  253. if (r > ((int)_mtu + 14)) // sanity check for weird TAP behavior on some platforms
  254. r = _mtu + 14;
  255. if (_enabled) {
  256. _tapq.post(std::pair<void *,int>(buf,r));
  257. buf = nullptr;
  258. }
  259. r = 0;
  260. }
  261. } else {
  262. r = 0;
  263. break;
  264. }
  265. }
  266. }
  267. }
  268. });
  269. }
  270. _tapProcessorThread = std::thread([this] {
  271. MAC to,from;
  272. std::pair<void *,int> qi;
  273. while (_tapq.get(qi)) {
  274. uint8_t *const b = reinterpret_cast<uint8_t *>(qi.first);
  275. if (b) {
  276. to.setTo(b, 6);
  277. from.setTo(b + 6, 6);
  278. unsigned int etherType = Utils::ntoh(((const uint16_t *)b)[6]);
  279. _handler(_arg, nullptr, _nwid, from, to, etherType, 0, (const void *)(b + 14),(unsigned int)(qi.second - 14));
  280. {
  281. std::lock_guard<std::mutex> l(_buffers_l);
  282. if (_buffers.size() < 128)
  283. _buffers.push_back(qi.first);
  284. else free(qi.first);
  285. }
  286. } else break;
  287. }
  288. });
  289. }
  290. LinuxEthernetTap::~LinuxEthernetTap()
  291. {
  292. _run = false;
  293. (void)::write(_shutdownSignalPipe[1],"\0",1); // causes reader thread(s) to exit
  294. _tapq.post(std::pair<void *,int>(nullptr,0)); // causes processor thread to exit
  295. _tapReaderThread[0].join();
  296. _tapReaderThread[1].join();
  297. _tapProcessorThread.join();
  298. ::close(_fd);
  299. ::close(_shutdownSignalPipe[0]);
  300. ::close(_shutdownSignalPipe[1]);
  301. for(std::vector<void *>::iterator i(_buffers.begin());i!=_buffers.end();++i)
  302. free(*i);
  303. std::vector< std::pair<void *,int> > dv(_tapq.drain());
  304. for(std::vector< std::pair<void *,int> >::iterator i(dv.begin());i!=dv.end();++i) {
  305. if (i->first)
  306. free(i->first);
  307. }
  308. }
  309. void LinuxEthernetTap::setEnabled(bool en)
  310. {
  311. _enabled = en;
  312. }
  313. bool LinuxEthernetTap::enabled() const
  314. {
  315. return _enabled;
  316. }
  317. static bool ___removeIp(const std::string &_dev,const InetAddress &ip)
  318. {
  319. LinuxNetLink::getInstance().removeAddress(ip, _dev.c_str());
  320. return true;
  321. }
  322. bool LinuxEthernetTap::addIps(std::vector<InetAddress> ips)
  323. {
  324. #ifdef __SYNOLOGY__
  325. std::string filepath = "/etc/sysconfig/network-scripts/ifcfg-"+_dev;
  326. std::string cfg_contents = "DEVICE="+_dev+"\nBOOTPROTO=static";
  327. int ip4=0,ip6=0,ip4_tot=0,ip6_tot=0;
  328. for(int i=0; i<(int)ips.size(); i++) {
  329. if (ips[i].isV4())
  330. ip4_tot++;
  331. else
  332. ip6_tot++;
  333. }
  334. // Assemble and write contents of ifcfg-dev file
  335. for(int i=0; i<(int)ips.size(); i++) {
  336. if (ips[i].isV4()) {
  337. char iptmp[64],iptmp2[64];
  338. std::string numstr4 = ip4_tot > 1 ? std::to_string(ip4) : "";
  339. cfg_contents += "\nIPADDR"+numstr4+"="+ips[i].toIpString(iptmp)
  340. + "\nNETMASK"+numstr4+"="+ips[i].netmask().toIpString(iptmp2)+"\n";
  341. ip4++;
  342. } else {
  343. char iptmp[64],iptmp2[64];
  344. std::string numstr6 = ip6_tot > 1 ? std::to_string(ip6) : "";
  345. cfg_contents += "\nIPV6ADDR"+numstr6+"="+ips[i].toIpString(iptmp)
  346. + "\nNETMASK"+numstr6+"="+ips[i].netmask().toIpString(iptmp2)+"\n";
  347. ip6++;
  348. }
  349. }
  350. OSUtils::writeFile(filepath.c_str(), cfg_contents.c_str(), cfg_contents.length());
  351. // Finally, add IPs
  352. for(int i=0; i<(int)ips.size(); i++){
  353. LinuxNetLink::getInstance().addAddress(ips[i], _dev.c_str());
  354. }
  355. return true;
  356. #endif // __SYNOLOGY__
  357. return false;
  358. }
  359. bool LinuxEthernetTap::addIp(const InetAddress &ip)
  360. {
  361. if (!ip)
  362. return false;
  363. std::vector<InetAddress> allIps(ips());
  364. if (std::binary_search(allIps.begin(),allIps.end(),ip))
  365. return true;
  366. // Remove and reconfigure if address is the same but netmask is different
  367. for(std::vector<InetAddress>::iterator i(allIps.begin());i!=allIps.end();++i) {
  368. if (i->ipsEqual(ip))
  369. ___removeIp(_dev,*i);
  370. }
  371. LinuxNetLink::getInstance().addAddress(ip, _dev.c_str());
  372. return true;
  373. }
  374. bool LinuxEthernetTap::removeIp(const InetAddress &ip)
  375. {
  376. if (!ip)
  377. return true;
  378. std::vector<InetAddress> allIps(ips());
  379. if (std::find(allIps.begin(),allIps.end(),ip) != allIps.end()) {
  380. if (___removeIp(_dev,ip))
  381. return true;
  382. }
  383. return false;
  384. }
  385. std::vector<InetAddress> LinuxEthernetTap::ips() const
  386. {
  387. struct ifaddrs *ifa = (struct ifaddrs *)0;
  388. if (getifaddrs(&ifa))
  389. return std::vector<InetAddress>();
  390. std::vector<InetAddress> r;
  391. struct ifaddrs *p = ifa;
  392. while (p) {
  393. if ((!strcmp(p->ifa_name,_dev.c_str()))&&(p->ifa_addr)&&(p->ifa_netmask)&&(p->ifa_addr->sa_family == p->ifa_netmask->sa_family)) {
  394. switch(p->ifa_addr->sa_family) {
  395. case AF_INET: {
  396. struct sockaddr_in *sin = (struct sockaddr_in *)p->ifa_addr;
  397. struct sockaddr_in *nm = (struct sockaddr_in *)p->ifa_netmask;
  398. r.push_back(InetAddress(&(sin->sin_addr.s_addr),4,Utils::countBits((uint32_t)nm->sin_addr.s_addr)));
  399. } break;
  400. case AF_INET6: {
  401. struct sockaddr_in6 *sin = (struct sockaddr_in6 *)p->ifa_addr;
  402. struct sockaddr_in6 *nm = (struct sockaddr_in6 *)p->ifa_netmask;
  403. uint32_t b[4];
  404. memcpy(b,nm->sin6_addr.s6_addr,sizeof(b));
  405. r.push_back(InetAddress(sin->sin6_addr.s6_addr,16,Utils::countBits(b[0]) + Utils::countBits(b[1]) + Utils::countBits(b[2]) + Utils::countBits(b[3])));
  406. } break;
  407. }
  408. }
  409. p = p->ifa_next;
  410. }
  411. if (ifa)
  412. freeifaddrs(ifa);
  413. std::sort(r.begin(),r.end());
  414. r.erase(std::unique(r.begin(),r.end()),r.end());
  415. return r;
  416. }
  417. void LinuxEthernetTap::put(const MAC &from,const MAC &to,unsigned int etherType,const void *data,unsigned int len)
  418. {
  419. char putBuf[ZT_MAX_MTU + 64];
  420. if ((_fd > 0)&&(len <= _mtu)&&(_enabled)) {
  421. to.copyTo(putBuf,6);
  422. from.copyTo(putBuf + 6,6);
  423. *((uint16_t *)(putBuf + 12)) = htons((uint16_t)etherType);
  424. memcpy(putBuf + 14,data,len);
  425. len += 14;
  426. (void)::write(_fd,putBuf,len);
  427. }
  428. }
  429. std::string LinuxEthernetTap::deviceName() const
  430. {
  431. return _dev;
  432. }
  433. void LinuxEthernetTap::setFriendlyName(const char *friendlyName)
  434. {
  435. }
  436. void LinuxEthernetTap::scanMulticastGroups(std::vector<MulticastGroup> &added,std::vector<MulticastGroup> &removed)
  437. {
  438. char *ptr,*ptr2;
  439. unsigned char mac[6];
  440. std::vector<MulticastGroup> newGroups;
  441. int fd = ::open("/proc/net/dev_mcast",O_RDONLY);
  442. if (fd > 0) {
  443. char buf[131072];
  444. int n = (int)::read(fd,buf,sizeof(buf));
  445. if ((n > 0)&&(n < (int)sizeof(buf))) {
  446. buf[n] = (char)0;
  447. for(char *l=strtok_r(buf,"\r\n",&ptr);(l);l=strtok_r((char *)0,"\r\n",&ptr)) {
  448. int fno = 0;
  449. char *devname = (char *)0;
  450. char *mcastmac = (char *)0;
  451. for(char *f=strtok_r(l," \t",&ptr2);(f);f=strtok_r((char *)0," \t",&ptr2)) {
  452. if (fno == 1)
  453. devname = f;
  454. else if (fno == 4)
  455. mcastmac = f;
  456. ++fno;
  457. }
  458. if ((devname)&&(!strcmp(devname,_dev.c_str()))&&(mcastmac)&&(Utils::unhex(mcastmac,mac,6) == 6))
  459. newGroups.push_back(MulticastGroup(MAC(mac,6),0));
  460. }
  461. }
  462. ::close(fd);
  463. }
  464. std::vector<InetAddress> allIps(ips());
  465. for(std::vector<InetAddress>::iterator ip(allIps.begin());ip!=allIps.end();++ip)
  466. newGroups.push_back(MulticastGroup::deriveMulticastGroupForAddressResolution(*ip));
  467. std::sort(newGroups.begin(),newGroups.end());
  468. newGroups.erase(std::unique(newGroups.begin(),newGroups.end()),newGroups.end());
  469. for(std::vector<MulticastGroup>::iterator m(newGroups.begin());m!=newGroups.end();++m) {
  470. if (!std::binary_search(_multicastGroups.begin(),_multicastGroups.end(),*m))
  471. added.push_back(*m);
  472. }
  473. for(std::vector<MulticastGroup>::iterator m(_multicastGroups.begin());m!=_multicastGroups.end();++m) {
  474. if (!std::binary_search(newGroups.begin(),newGroups.end(),*m))
  475. removed.push_back(*m);
  476. }
  477. _multicastGroups.swap(newGroups);
  478. }
  479. void LinuxEthernetTap::setMtu(unsigned int mtu)
  480. {
  481. if (_mtu != mtu) {
  482. _mtu = mtu;
  483. int sock = socket(AF_INET,SOCK_DGRAM,0);
  484. if (sock > 0) {
  485. struct ifreq ifr;
  486. memset(&ifr,0,sizeof(ifr));
  487. ifr.ifr_ifru.ifru_mtu = (int)mtu;
  488. ioctl(sock,SIOCSIFMTU,(void *)&ifr);
  489. close(sock);
  490. }
  491. }
  492. }
  493. } // namespace ZeroTier
  494. #endif // __LINUX__