gdhcp/common.c

   1 /*
   2  *  DHCP library with GLib integration
   3  *
   4  *  Copyright (C) 2007-2012  Intel Corporation. All rights reserved.
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License version 2 as
   8  *  published by the Free Software Foundation.
   9  *
  10  *  This program 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 this program; if not, write to the Free Software
  17  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18  *
  19  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <errno.h>
  28 #include <unistd.h>
  29 #include <sys/ioctl.h>
  30 #include <stdint.h>
  31 #include <string.h>
  32 #include <endian.h>
  33 #include <net/if_arp.h>
  34 #include <linux/if.h>
  35 #include <netpacket/packet.h>
  36 #include <net/ethernet.h>
  37 #include <arpa/inet.h>
  38
  39 #include "gdhcp.h"
  40 #include "common.h"
  41
  42 static const DHCPOption client_options[] = {
  43         { OPTION_IP,                    0x01 }, /* subnet-mask */
  44         { OPTION_IP | OPTION_LIST,      0x03 }, /* routers */
  45         { OPTION_IP | OPTION_LIST,      0x06 }, /* domain-name-servers */
  46         { OPTION_STRING,                0x0c }, /* hostname */
  47         { OPTION_STRING,                0x0f }, /* domain-name */
  48         { OPTION_IP | OPTION_LIST,      0x2a }, /* ntp-servers */
  49         { OPTION_U32,                   0x33 }, /* dhcp-lease-time */
  50         /* Options below will not be exposed to user */
  51         { OPTION_IP,                    0x32 }, /* requested-ip */
  52         { OPTION_U8,                    0x35 }, /* message-type */
  53         { OPTION_U32,                   0x36 }, /* server-id */
  54         { OPTION_U16,                   0x39 }, /* max-size */
  55         { OPTION_STRING,                0x3c }, /* vendor */
  56         { OPTION_STRING,                0x3d }, /* client-id */
  57         { OPTION_STRING,                0xfc }, /* UNOFFICIAL proxy-pac */
  58         { OPTION_UNKNOWN,               0x00 },
  59 };
  60
  61 GDHCPOptionType dhcp_get_code_type(uint8_t code)
  62 {
  63         int i;
  64
  65         for (i = 0; client_options[i].code; i++) {
  66                 if (client_options[i].code == code)
  67                         return client_options[i].type;
  68         }
  69
  70         return OPTION_UNKNOWN;
  71 }
  72
  73 uint8_t *dhcp_get_option(struct dhcp_packet *packet, int code)
  74 {
  75         int len, rem;
  76         uint8_t *optionptr;
  77         uint8_t overload = 0;
  78
  79         /* option bytes: [code][len][data1][data2]..[dataLEN] */
  80         optionptr = packet->options;
  81         rem = sizeof(packet->options);
  82
  83         while (1) {
  84                 if (rem <= 0)
  85                         /* Bad packet, malformed option field */
  86                         return NULL;
  87
  88                 if (optionptr[OPT_CODE] == DHCP_PADDING) {
  89                         rem--;
  90                         optionptr++;
  91
  92                         continue;
  93                 }
  94
  95                 if (optionptr[OPT_CODE] == DHCP_END) {
  96                         if (overload & FILE_FIELD) {
  97                                 overload &= ~FILE_FIELD;
  98
  99                                 optionptr = packet->file;
 100                                 rem = sizeof(packet->file);
 101
 102                                 continue;
 103                         } else if (overload & SNAME_FIELD) {
 104                                 overload &= ~SNAME_FIELD;
 105
 106                                 optionptr = packet->sname;
 107                                 rem = sizeof(packet->sname);
 108
 109                                 continue;
 110                         }
 111
 112                         break;
 113                 }
 114
 115                 len = 2 + optionptr[OPT_LEN];
 116
 117                 rem -= len;
 118                 if (rem < 0)
 119                         continue; /* complain and return NULL */
 120
 121                 if (optionptr[OPT_CODE] == code)
 122                         return optionptr + OPT_DATA;
 123
 124                 if (optionptr[OPT_CODE] == DHCP_OPTION_OVERLOAD)
 125                         overload |= optionptr[OPT_DATA];
 126
 127                 optionptr += len;
 128         }
 129
 130         return NULL;
 131 }
 132
 133 int dhcp_end_option(uint8_t *optionptr)
 134 {
 135         int i = 0;
 136
 137         while (optionptr[i] != DHCP_END) {
 138                 if (optionptr[i] != DHCP_PADDING)
 139                         i += optionptr[i + OPT_LEN] + OPT_DATA - 1;
 140
 141                 i++;
 142         }
 143
 144         return i;
 145 }
 146
 147 uint8_t *dhcpv6_get_option(struct dhcpv6_packet *packet, uint16_t pkt_len,
 148                         int code, uint16_t *option_len, int *option_count)
 149 {
 150         int rem, count = 0;
 151         uint8_t *optionptr, *found = NULL;
 152         uint16_t opt_code, opt_len, len;
 153
 154         optionptr = packet->options;
 155         rem = pkt_len - 1 - 3;
 156
 157         if (rem <= 0)
 158                 goto bad_packet;
 159
 160         while (1) {
 161                 opt_code = optionptr[0] << 8 | optionptr[1];
 162                 opt_len = len = optionptr[2] << 8 | optionptr[3];
 163                 len += 2 + 2; /* skip code and len */
 164
 165                 if (len < 4)
 166                         goto bad_packet;
 167
 168                 rem -= len;
 169                 if (rem < 0)
 170                         break;
 171
 172                 if (opt_code == code) {
 173                         if (option_len != NULL)
 174                                 *option_len = opt_len;
 175                         if (rem == 0)
 176                                 found = NULL;
 177                         else
 178                                 found = optionptr + 2 + 2;
 179                         count++;
 180                 }
 181
 182                 if (rem == 0)
 183                         break;
 184
 185                 optionptr += len;
 186         }
 187
 188         if (option_count != NULL)
 189                 *option_count = count;
 190
 191         return found;
 192
 193 bad_packet:
 194         if (option_len != NULL)
 195                 *option_len = 0;
 196         if (option_count != NULL)
 197                 *option_count = 0;
 198         return NULL;
 199 }
 200
 201 uint8_t *dhcpv6_get_sub_option(unsigned char *option, uint16_t max_len,
 202                         uint16_t *option_code, uint16_t *option_len)
 203 {
 204         int rem;
 205         uint16_t code, len;
 206
 207         rem = max_len - 2 - 2;
 208
 209         if (rem <= 0)
 210                 /* Bad option */
 211                 return NULL;
 212
 213         code = option[0] << 8 | option[1];
 214         len = option[2] << 8 | option[3];
 215
 216         rem -= len;
 217         if (rem < 0)
 218                 return NULL;
 219
 220         *option_code = code;
 221         *option_len = len;
 222
 223         return &option[4];
 224 }
 225
 226 /*
 227  * Add an option (supplied in binary form) to the options.
 228  * Option format: [code][len][data1][data2]..[dataLEN]
 229  */
 230 void dhcp_add_binary_option(struct dhcp_packet *packet, uint8_t *addopt)
 231 {
 232         unsigned len;
 233         uint8_t *optionptr = packet->options;
 234         unsigned end = dhcp_end_option(optionptr);
 235
 236         len = OPT_DATA + addopt[OPT_LEN];
 237
 238         /* end position + (option code/length + addopt length) + end option */
 239         if (end + len + 1 >= DHCP_OPTIONS_BUFSIZE)
 240                 /* option did not fit into the packet */
 241                 return;
 242
 243         memcpy(optionptr + end, addopt, len);
 244
 245         optionptr[end + len] = DHCP_END;
 246 }
 247
 248 /*
 249  * Add an option (supplied in binary form) to the options.
 250  * Option format: [code][len][data1][data2]..[dataLEN]
 251  */
 252 void dhcpv6_add_binary_option(struct dhcpv6_packet *packet, uint16_t max_len,
 253                                 uint16_t *pkt_len, uint8_t *addopt)
 254 {
 255         unsigned len;
 256         uint8_t *optionptr = packet->options;
 257
 258         len = 2 + 2 + (addopt[2] << 8 | addopt[3]);
 259
 260         /* end position + (option code/length + addopt length) */
 261         if (*pkt_len + len >= max_len)
 262                 /* option did not fit into the packet */
 263                 return;
 264
 265         memcpy(optionptr + *pkt_len, addopt, len);
 266         *pkt_len += len;
 267 }
 268
 269 void dhcp_add_simple_option(struct dhcp_packet *packet, uint8_t code,
 270                                                         uint32_t data)
 271 {
 272         uint8_t option[6], len;
 273         GDHCPOptionType type = dhcp_get_code_type(code);
 274
 275         if (type == OPTION_UNKNOWN)
 276                 return;
 277
 278         option[OPT_CODE] = code;
 279
 280         len = dhcp_option_lengths[type & OPTION_TYPE_MASK];
 281         option[OPT_LEN] = len;
 282
 283         switch (len) {
 284         case 1:
 285                 option[OPT_DATA] = data;
 286                 break;
 287         case 2:
 288                 put_be16(data, option + OPT_DATA);
 289                 break;
 290         case 4:
 291                 put_be32(data, option + OPT_DATA);
 292                 break;
 293         default:
 294                 printf("Invalid option len %d for code 0x%x\n", len, code);
 295                 return;
 296         }
 297
 298         dhcp_add_binary_option(packet, option);
 299
 300         return;
 301 }
 302
 303 void dhcp_init_header(struct dhcp_packet *packet, char type)
 304 {
 305         memset(packet, 0, sizeof(*packet));
 306
 307         packet->op = BOOTREQUEST;
 308
 309         switch (type) {
 310         case DHCPOFFER:
 311         case DHCPACK:
 312         case DHCPNAK:
 313                 packet->op = BOOTREPLY;
 314         }
 315
 316         packet->htype = 1;
 317         packet->hlen = 6;
 318         packet->cookie = htonl(DHCP_MAGIC);
 319         packet->options[0] = DHCP_END;
 320
 321         dhcp_add_simple_option(packet, DHCP_MESSAGE_TYPE, type);
 322 }
 323
 324 void dhcpv6_init_header(struct dhcpv6_packet *packet, uint8_t type)
 325 {
 326         int id;
 327
 328         memset(packet, 0, sizeof(*packet));
 329
 330         packet->message = type;
 331
 332         id = random();
 333
 334         packet->transaction_id[0] = (id >> 16) & 0xff;
 335         packet->transaction_id[1] = (id >> 8) & 0xff;
 336         packet->transaction_id[2] = id & 0xff;
 337 }
 338
 339 static gboolean check_vendor(uint8_t  *option_vendor, const char *vendor)
 340 {
 341         uint8_t vendor_length = sizeof(vendor) - 1;
 342
 343         if (option_vendor[OPT_LEN - OPT_DATA] != vendor_length)
 344                 return FALSE;
 345
 346         if (memcmp(option_vendor, vendor, vendor_length) != 0)
 347                 return FALSE;
 348
 349         return TRUE;
 350 }
 351
 352 static void check_broken_vendor(struct dhcp_packet *packet)
 353 {
 354         uint8_t *vendor;
 355
 356         if (packet->op != BOOTREQUEST)
 357                 return;
 358
 359         vendor = dhcp_get_option(packet, DHCP_VENDOR);
 360         if (vendor == NULL)
 361                 return;
 362
 363         if (check_vendor(vendor, "MSFT 98") == TRUE)
 364                 packet->flags |= htons(BROADCAST_FLAG);
 365 }
 366
 367 int dhcp_recv_l3_packet(struct dhcp_packet *packet, int fd)
 368 {
 369         int n;
 370
 371         memset(packet, 0, sizeof(*packet));
 372
 373         n = read(fd, packet, sizeof(*packet));
 374         if (n < 0)
 375                 return -errno;
 376
 377         if (packet->cookie != htonl(DHCP_MAGIC))
 378                 return -EPROTO;
 379
 380         check_broken_vendor(packet);
 381
 382         return n;
 383 }
 384
 385 int dhcpv6_recv_l3_packet(struct dhcpv6_packet **packet, unsigned char *buf,
 386                         int buf_len, int fd)
 387 {
 388         int n;
 389
 390         n = read(fd, buf, buf_len);
 391         if (n < 0)
 392                 return -errno;
 393
 394         *packet = (struct dhcpv6_packet *)buf;
 395
 396         return n;
 397 }
 398
 399 /* TODO: Use glib checksum */
 400 uint16_t dhcp_checksum(void *addr, int count)
 401 {
 402         /*
 403          * Compute Internet Checksum for "count" bytes
 404          * beginning at location "addr".
 405          */
 406         int32_t sum = 0;
 407         uint16_t *source = (uint16_t *) addr;
 408
 409         while (count > 1)  {
 410                 /*  This is the inner loop */
 411                 sum += *source++;
 412                 count -= 2;
 413         }
 414
 415         /*  Add left-over byte, if any */
 416         if (count > 0) {
 417                 /* Make sure that the left-over byte is added correctly both
 418                  * with little and big endian hosts */
 419                 uint16_t tmp = 0;
 420                 *(uint8_t *) &tmp = *(uint8_t *) source;
 421                 sum += tmp;
 422         }
 423         /*  Fold 32-bit sum to 16 bits */
 424         while (sum >> 16)
 425                 sum = (sum & 0xffff) + (sum >> 16);
 426
 427         return ~sum;
 428 }
 429
 430 #define IN6ADDR_ALL_DHCP_RELAY_AGENTS_AND_SERVERS_MC_INIT \
 431         { { { 0xff,0x02,0,0,0,0,0,0,0,0,0,0,0,0x1,0,0x2 } } } /* ff02::1:2 */
 432 static const struct in6_addr in6addr_all_dhcp_relay_agents_and_servers_mc =
 433         IN6ADDR_ALL_DHCP_RELAY_AGENTS_AND_SERVERS_MC_INIT;
 434
 435 /* from netinet/in.h */
 436 struct in6_pktinfo {
 437         struct in6_addr ipi6_addr;  /* src/dst IPv6 address */
 438         unsigned int ipi6_ifindex;  /* send/recv interface index */
 439 };
 440
 441 int dhcpv6_send_packet(int index, struct dhcpv6_packet *dhcp_pkt, int len)
 442 {
 443         struct msghdr m;
 444         struct iovec v;
 445         struct in6_pktinfo *pktinfo;
 446         struct cmsghdr *cmsg;
 447         int fd, ret;
 448         struct sockaddr_in6 dst;
 449         void *control_buf;
 450         size_t control_buf_len;
 451
 452         fd = socket(PF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, IPPROTO_UDP);
 453         if (fd < 0)
 454                 return -errno;
 455
 456         memset(&dst, 0, sizeof(dst));
 457         dst.sin6_family = AF_INET6;
 458         dst.sin6_port = htons(DHCPV6_SERVER_PORT);
 459
 460         dst.sin6_addr = in6addr_all_dhcp_relay_agents_and_servers_mc;
 461
 462         control_buf_len = CMSG_SPACE(sizeof(struct in6_pktinfo));
 463         control_buf = g_try_malloc0(control_buf_len);
 464         if (control_buf == NULL) {
 465                 close(fd);
 466                 return -ENOMEM;
 467         }
 468
 469         memset(&m, 0, sizeof(m));
 470         memset(&v, 0, sizeof(v));
 471
 472         m.msg_name = &dst;
 473         m.msg_namelen = sizeof(dst);
 474
 475         v.iov_base = (char *)dhcp_pkt;
 476         v.iov_len = len;
 477         m.msg_iov = &v;
 478         m.msg_iovlen = 1;
 479
 480         m.msg_control = control_buf;
 481         m.msg_controllen = control_buf_len;
 482         cmsg = CMSG_FIRSTHDR(&m);
 483         cmsg->cmsg_level = IPPROTO_IPV6;
 484         cmsg->cmsg_type = IPV6_PKTINFO;
 485         cmsg->cmsg_len = CMSG_LEN(sizeof(*pktinfo));
 486
 487         pktinfo = (struct in6_pktinfo *)CMSG_DATA(cmsg);
 488         memset(pktinfo, 0, sizeof(*pktinfo));
 489         pktinfo->ipi6_ifindex = index;
 490         m.msg_controllen = cmsg->cmsg_len;
 491
 492         ret = sendmsg(fd, &m, 0);
 493         if (ret < 0)
 494                 perror("DHCPv6 msg send failed");
 495
 496         g_free(control_buf);
 497         close(fd);
 498
 499         return ret;
 500 }
 501
 502 int dhcp_send_raw_packet(struct dhcp_packet *dhcp_pkt,
 503                 uint32_t source_ip, int source_port, uint32_t dest_ip,
 504                         int dest_port, const uint8_t *dest_arp, int ifindex)
 505 {
 506         struct sockaddr_ll dest;
 507         struct ip_udp_dhcp_packet packet;
 508         int fd, n;
 509
 510         enum {
 511                 IP_UPD_DHCP_SIZE = sizeof(struct ip_udp_dhcp_packet) -
 512                                                 EXTEND_FOR_BUGGY_SERVERS,
 513                 UPD_DHCP_SIZE = IP_UPD_DHCP_SIZE -
 514                                 offsetof(struct ip_udp_dhcp_packet, udp),
 515         };
 516
 517         fd = socket(PF_PACKET, SOCK_DGRAM | SOCK_CLOEXEC, htons(ETH_P_IP));
 518         if (fd < 0)
 519                 return -errno;
 520
 521         memset(&dest, 0, sizeof(dest));
 522         memset(&packet, 0, sizeof(packet));
 523         packet.data = *dhcp_pkt;
 524
 525         dest.sll_family = AF_PACKET;
 526         dest.sll_protocol = htons(ETH_P_IP);
 527         dest.sll_ifindex = ifindex;
 528         dest.sll_halen = 6;
 529         memcpy(dest.sll_addr, dest_arp, 6);
 530         if (bind(fd, (struct sockaddr *)&dest, sizeof(dest)) < 0) {
 531                 close(fd);
 532                 return -errno;
 533         }
 534
 535         packet.ip.protocol = IPPROTO_UDP;
 536         packet.ip.saddr = source_ip;
 537         packet.ip.daddr = dest_ip;
 538         packet.udp.source = htons(source_port);
 539         packet.udp.dest = htons(dest_port);
 540         /* size, excluding IP header: */
 541         packet.udp.len = htons(UPD_DHCP_SIZE);
 542         /* for UDP checksumming, ip.len is set to UDP packet len */
 543         packet.ip.tot_len = packet.udp.len;
 544         packet.udp.check = dhcp_checksum(&packet, IP_UPD_DHCP_SIZE);
 545         /* but for sending, it is set to IP packet len */
 546         packet.ip.tot_len = htons(IP_UPD_DHCP_SIZE);
 547         packet.ip.ihl = sizeof(packet.ip) >> 2;
 548         packet.ip.version = IPVERSION;
 549         packet.ip.ttl = IPDEFTTL;
 550         packet.ip.check = dhcp_checksum(&packet.ip, sizeof(packet.ip));
 551
 552         /*
 553          * Currently we send full-sized DHCP packets (zero padded).
 554          * If you need to change this: last byte of the packet is
 555          * packet.data.options[dhcp_end_option(packet.data.options)]
 556          */
 557         n = sendto(fd, &packet, IP_UPD_DHCP_SIZE, 0,
 558                         (struct sockaddr *) &dest, sizeof(dest));
 559         close(fd);
 560
 561         if (n < 0)
 562                 return -errno;
 563
 564         return n;
 565 }
 566
 567 int dhcp_send_kernel_packet(struct dhcp_packet *dhcp_pkt,
 568                                 uint32_t source_ip, int source_port,
 569                                 uint32_t dest_ip, int dest_port)
 570 {
 571         struct sockaddr_in client;
 572         int fd, n, opt = 1;
 573
 574         enum {
 575                 DHCP_SIZE = sizeof(struct dhcp_packet) -
 576                                         EXTEND_FOR_BUGGY_SERVERS,
 577         };
 578
 579         fd = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, IPPROTO_UDP);
 580         if (fd < 0)
 581                 return -errno;
 582
 583         setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
 584
 585         memset(&client, 0, sizeof(client));
 586         client.sin_family = AF_INET;
 587         client.sin_port = htons(source_port);
 588         client.sin_addr.s_addr = htonl(source_ip);
 589         if (bind(fd, (struct sockaddr *) &client, sizeof(client)) < 0) {
 590                 close(fd);
 591                 return -errno;
 592         }
 593
 594         memset(&client, 0, sizeof(client));
 595         client.sin_family = AF_INET;
 596         client.sin_port = htons(dest_port);
 597         client.sin_addr.s_addr = dest_ip;
 598         if (connect(fd, (struct sockaddr *) &client, sizeof(client)) < 0) {
 599                 close(fd);
 600                 return -errno;
 601         }
 602
 603         n = write(fd, dhcp_pkt, DHCP_SIZE);
 604
 605         close(fd);
 606
 607         if (n < 0)
 608                 return -errno;
 609
 610         return n;
 611 }
 612
 613 int dhcp_l3_socket(int port, const char *interface, int family)
 614 {
 615         int fd, opt = 1, len;
 616         struct sockaddr_in addr4;
 617         struct sockaddr_in6 addr6;
 618         struct sockaddr *addr;
 619
 620         fd = socket(family, SOCK_DGRAM | SOCK_CLOEXEC, IPPROTO_UDP);
 621         if (fd < 0)
 622                 return -errno;
 623
 624         setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
 625
 626         if (setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE,
 627                                 interface, strlen(interface) + 1) < 0) {
 628                 close(fd);
 629                 return -1;
 630         }
 631
 632         if (family == AF_INET) {
 633                 memset(&addr4, 0, sizeof(addr4));
 634                 addr4.sin_family = family;
 635                 addr4.sin_port = htons(port);
 636                 addr = (struct sockaddr *)&addr4;
 637                 len = sizeof(addr4);
 638         } else if (family == AF_INET6) {
 639                 memset(&addr6, 0, sizeof(addr6));
 640                 addr6.sin6_family = family;
 641                 addr6.sin6_port = htons(port);
 642                 addr = (struct sockaddr *)&addr6;
 643                 len = sizeof(addr6);
 644         } else {
 645                 close(fd);
 646                 return -EINVAL;
 647         }
 648
 649         if (bind(fd, addr, len) != 0) {
 650                 close(fd);
 651                 return -1;
 652         }
 653
 654         return fd;
 655 }
 656
 657 char *get_interface_name(int index)
 658 {
 659         struct ifreq ifr;
 660         int sk, err;
 661
 662         if (index < 0)
 663                 return NULL;
 664
 665         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 666         if (sk < 0) {
 667                 perror("Open socket error");
 668                 return NULL;
 669         }
 670
 671         memset(&ifr, 0, sizeof(ifr));
 672         ifr.ifr_ifindex = index;
 673
 674         err = ioctl(sk, SIOCGIFNAME, &ifr);
 675         if (err < 0) {
 676                 perror("Get interface name error");
 677                 close(sk);
 678                 return NULL;
 679         }
 680
 681         close(sk);
 682
 683         return g_strdup(ifr.ifr_name);
 684 }
 685
 686 gboolean interface_is_up(int index)
 687 {
 688         int sk, err;
 689         struct ifreq ifr;
 690         gboolean ret = FALSE;
 691
 692         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 693         if (sk < 0) {
 694                 perror("Open socket error");
 695                 return FALSE;
 696         }
 697
 698         memset(&ifr, 0, sizeof(ifr));
 699         ifr.ifr_ifindex = index;
 700
 701         err = ioctl(sk, SIOCGIFNAME, &ifr);
 702         if (err < 0) {
 703                 perror("Get interface name error");
 704                 goto done;
 705         }
 706
 707         err = ioctl(sk, SIOCGIFFLAGS, &ifr);
 708         if (err < 0) {
 709                 perror("Get interface flags error");
 710                 goto done;
 711         }
 712
 713         if (ifr.ifr_flags & IFF_UP)
 714                 ret = TRUE;
 715
 716 done:
 717         close(sk);
 718
 719         return ret;
 720 }