DHCP 服务探测

1840阅读　0评论2020-11-05　khls27
分类：LINUX


在一些网络环境中，需要用到DHCP服务探测技术，动态调整本地dhcp服务的。本文提供一个探测的demo实现。
原理：
发送DHCP discover 报文，如果能够接受到 DHCP offer回应，则可以获取到服务信息。

代码如下：

点击(此处)折叠或打开

  1. #include <errno.h>
  2. #include <unistd.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <stddef.h>
  6. #include <time.h>
  7. #include <string.h>
  8. #include <signal.h>
  9. #include <sys/ioctl.h>
  10. #include <arpa/inet.h>
  11. #include <netpacket/packet.h>
  12. #include <netinet/if_ether.h>
  13. #include <netinet/ip.h>
  14. #include <netinet/udp.h>
  15. #include <linux/if.h>

  17. #define MAX_WAIT_TIME 15
  18. #define MAX_ERROR_LENGTH 1500

  20. /* Endianness check */
  21. #define IS_BIG_ENDIAN (*(uint16_t *)"\0\xff" < 0x100)


  24. /* DHCP protocol. RFC 2131, RFC 2132 */
  25. #define DHCP_MAGIC                 0x63825363
  26. #define DHCP_FIXED_LEN            240 /* with DHCP magic */
  27. #define DHCP_UDP_OVERHEAD        28 /* IP + UDP headers */
  28. #define DHCP_MTU_MAX            1500
  29. #define DHCP_MTU_MIN            576
  30. #define DHCP_OPTIONS_BUF_MIN    (DHCP_MTU_MIN - DHCP_FIXED_LEN - DHCP_UDP_OVERHEAD)
  31. #define DHCP_OPTIONS_BUF_MAX    (DHCP_MTU_MAX - DHCP_FIXED_LEN - DHCP_UDP_OVERHEAD)

  33. #define BOOTREQUEST                1
  34. #define BOOTREPLY                2

  36. /* DHCP Ports and Addresses */
  37. #define CLIENT_PORT        68
  38. #define SERVER_PORT        67

  40. /* DHCP packet */
  41. struct dhcp_packet
  42. {
  43.     uint8_t op;                /* BOOTREQUEST or BOOTREPLY */
  44.     uint8_t htype;            /* hardware address type. 1 = 10Mb ethernet */
  45.     uint8_t hlen;            /* hardware address length */
  46.     uint8_t hops;            /* used by relay agents only */
  47.     uint32_t xid;            /* unuque id */
  48.     uint16_t secs;             /* seconds since client started looking */
  49.     uint16_t flags;            /* only one flag */
  50.     uint32_t ciaddr;        /* clients IP address (if already in use) */
  51.     uint32_t yiaddr;        /* client IP address */
  52.     uint32_t siaddr_nip;    /* next server used in bootstrap */
  53.     uint32_t gateway_nip;    /* relay agent IP address */
  54.     uint8_t chaddr[16];        /* MAC address of client */
  55.     uint8_t sname[64];        /* server host name (ASCIZ) */
  56.     uint8_t file[128];        /* boot file name (ASCIIZ) */
  57.     uint32_t cookie;        /* fixed first four option bytes (99, 130, 83, 99 dec) */
  58.     uint8_t options[DHCP_OPTIONS_BUF_MAX];
  59. };

  61. /* IP packet with DHCP */
  62. struct ip_udp_dhcp_packet
  63. {
  64.     struct iphdr ip;            /* IP header */
  65.     struct udphdr udp;            /* UDP header */
  66.     struct dhcp_packet data;    /* UDP payload */
  67. };

  69. /* UDP packet with DHCP */
  70. struct udp_dhcp_packet
  71. {
  72.     struct udphdr udp;            /* UDP header */
  73.     struct dhcp_packet data;    /* UDP payload */
  74. };

  76. /* Packets size */
  77. enum
  78. {
  79.     IP_UDP_DHCP_SIZE = sizeof(struct ip_udp_dhcp_packet),
  80.     UDP_DHCP_SIZE = sizeof(struct udp_dhcp_packet),
  81.     DHCP_SIZE = sizeof(struct dhcp_packet),
  82. };

  84. /* DHCP options codes */
  85. #define DHCP_PADDING             0x00
  86. #define DHCP_SUBNET             0x01
  87. #define DHCP_ROUTER                0x03
  88. #define DHCP_DNS                0x06
  89. #define DHCP_BROADCAST            0x1c
  90. #define DHCP_STATIC                0x21
  91. #define DHCP_NTP                0x2a
  92. #define DHCP_VENDOR                0x2b
  93. #define DHCP_NETBIOS_NAME_SRV    0x2c
  94. #define DHCP_LEASE_TIME         0x33
  95. #define DHCP_OVERLOAD            0x34
  96. #define DHCP_MESSAGE_TYPE        0x35
  97. #define DHCP_SERVER_ID            0x36 /* DHCP server IP */
  98. #define DHCP_PARAM_REQ            0x37 /* list of options client wants */
  99. #define DHCP_MAX_SIZE            0x39
  100. #define DHCP_RENEWAL_TIME        0x3a
  101. #define DHCP_REBINDING_TIME        0x3b
  102. #define DHCP_VENDOR_CLASS_ID    0x3c
  103. #define DHCP_CLIENT_ID            0x3d /* client's MAC addr*/
  104. #define DHCP_SIP                0x78
  105. #define DHCP_CLASSLESS_STATIC    0x79
  106. #define DHCP_END                0xff

  108. /* DHCP_MESSAGE_TYPE values */
  109. #define DHCPDISCOVER    1 /* client -> server */
  110. #define DHCPOFFER        2 /* client <- server */

  112. /* Offsets in option byte sequence */
  113. #define OPT_CODE 0
  114. #define OPT_LEN 1
  115. #define OPT_DATA 2

  117. /* Bits in "overload" option */
  118. #define OPTION_FIELD            0
  119. #define FILE_FIELD                1
  120. #define SNAME_FIELD                2


  123. static volatile sig_atomic_t got_alarm = 0;

  125. /**
  126.  * Get MAC address of interface.
  127.  *
  128.  * @param ifname Interface name.
  129.  * @param addr Array for MAC address.
  130.  *
  131.  * @return -1 on failure, 0 on success.
  132.  */
  133. int get_if_mac(const char* ifname, uint8_t addr[ETH_ALEN])
  134. {
  135.     /* Copy interface name into ifreq */
  136.     struct ifreq ifr;
  137.     memset(&ifr, 0, sizeof(struct ifreq));

  139.     size_t if_name_len = strlen(ifname);

  141.     if (if_name_len < sizeof(ifr.ifr_name))
  142.     {
  143.         memcpy(ifr.ifr_name, ifname, if_name_len);
  144.         ifr.ifr_name[if_name_len] = 0;
  145.     }
  146.     else
  147.     {
  148.         return -1;
  149.     }

  151.     /* Create socket */
  152.     int fd = socket(AF_UNIX, SOCK_DGRAM, 0);

  154.     if (fd < 0)
  155.     {
  156.         return -1;
  157.     }

  159.     /* Get hw address */
  160.     if (ioctl(fd, SIOCGIFHWADDR, &ifr) < 0)
  161.     {
  162.         close (fd);
  163.         return -1;
  164.     }

  166.     close(fd);
  167.     memcpy (addr, ifr.ifr_hwaddr.sa_data, ETH_ALEN);
  168.     return 0;
  169. }


  172. /**
  173.  * Get Interface index.
  174.  *
  175.  * @param ifname Interface name.
  176.  *
  177.  * @return Interface index on success, zero on failure.
  178.  */
  179. unsigned int get_if_index(const char* ifname)
  180. {
  181.     /* Copy interface name into ifreq */
  182.     struct ifreq ifr;
  183.     memset(&ifr, 0, sizeof(struct ifreq));

  185.     size_t if_name_len = strlen(ifname);

  187.     if (if_name_len < sizeof(ifr.ifr_name))
  188.     {
  189.         memcpy(ifr.ifr_name, ifname, if_name_len);
  190.         ifr.ifr_name[if_name_len] = 0;
  191.     }
  192.     else
  193.     {
  194.         return -1;
  195.     }

  197.     /* Create socket */
  198.     int fd = socket(AF_UNIX, SOCK_DGRAM, 0);

  200.     if (fd < 0)
  201.     {
  202.         return 0;
  203.     }

  205.     /* Get interface index */
  206.     if (ioctl(fd, SIOCGIFINDEX, &ifr) < 0)
  207.     {
  208.         close (fd);
  209.         return 0;
  210.     }

  212.     close(fd);
  213.     return ifr.ifr_ifindex;
  214. }

  216. /**
  217.  * Calculate internet checksum.
  218.  *
  219.  * @param addr Start address.
  220.  * @param nleft Length in bytes.
  221.  *
  222.  * @return Checksum.
  223.  */
  224. uint16_t inet_chksum(uint16_t* addr, int nleft)
  225. {
  226.     /*
  227.      * Algorithm is simple, using a 32 bit accumulator,
  228.      * we add sequential 16 bit words to it, and at the end, fold
  229.      * back all the carry bits from the top 16 bits into the lower
  230.      * 16 bits.
  231.      */
  232.     unsigned sum = 0;
  233.     while (nleft > 1)
  234.     {
  235.         sum += *addr++;
  236.         nleft -= 2;
  237.     }
  238.     /* Mop up an odd byte, if necessary */
  239.     if (nleft == 1)
  240.     {
  241.         if (IS_BIG_ENDIAN)
  242.             sum += *(uint8_t*)addr << 8;
  243.         else
  244.             sum += *(uint8_t*)addr;
  245.     }

  247.     /* Add back carry outs from top 16 bits to low 16 bits */
  248.     sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
  249.     sum += (sum >> 16); /* add carry */

  251.     return (uint16_t)~sum;
  252. }

  254. /**
  255.  * Calculate random id (unsigned 32-bit value).
  256.  *
  257.  * @param Void.
  258.  * @return id
  259.  */
  260. uint32_t random_id(void)
  261. {
  262.     srand(time(NULL));
  263.     return rand();
  264. }


  267. /**
  268.  * Fill DHCP Packet.
  269.  *
  270.  * @param packet DHCP packet.
  271.  * @param hwaddr MAC address of interface.
  272.  * @return Void.
  273.  */
  274. static void dhcp_init_packet(struct dhcp_packet* packet, uint8_t* hwaddr)
  275. {
  276.     unsigned index = 0;

  278.     /* DHCP header */
  279.     memset(packet, 0, sizeof(*packet));
  280.     packet->op = BOOTREQUEST;
  281.     packet->htype = 1; /* ethernet */
  282.     packet->hlen = ETH_ALEN;
  283.     packet->cookie = htonl(DHCP_MAGIC);
  284.     packet->secs = 0;
  285.     memcpy(packet->chaddr, hwaddr, ETH_ALEN);

  287.     /* DHCP options */
  288.     /* Message type */
  289.     packet->options[index++] = DHCP_MESSAGE_TYPE;
  290.     packet->options[index++] = 1; //length of option data
  291.     packet->options[index++] = DHCPDISCOVER;

  293.     /* Requested parameters */
  294.     packet->options[index++] = DHCP_PARAM_REQ;
  295.     packet->options[index++] = 9; // number of options
  296.     packet->options[index++] = DHCP_SUBNET;
  297.     packet->options[index++] = DHCP_ROUTER;
  298.     packet->options[index++] = DHCP_DNS;
  299.     packet->options[index++] = DHCP_BROADCAST;
  300.     packet->options[index++] = DHCP_STATIC;
  301.     packet->options[index++] = DHCP_NTP;
  302.     packet->options[index++] = DHCP_VENDOR;
  303.     packet->options[index++] = DHCP_SIP;
  304.     packet->options[index++] = DHCP_CLASSLESS_STATIC;

  306.     /* client id */
  307.     packet->options[index++] = DHCP_CLIENT_ID;
  308.     packet->options[index++] = ETH_ALEN + 1;
  309.     packet->options[index++] = 1; //ethernet
  310.     memcpy(&packet->options[index], hwaddr, ETH_ALEN);
  311.     index += ETH_ALEN;

  313.     /* end option */
  314.     packet->options[index] = DHCP_END;
  315. }

  317. /**
  318.  * Calculate position of the END option.
  319.  *
  320.  * @param optionptr Beginning of dhcp options.
  321.  * @return Position of 'end' option.
  322.  */
  323. static int dhcp_end_option(uint8_t* optionptr)
  324. {
  325.     int i = 0;
  326.     while (optionptr[i] != DHCP_END)
  327.     {
  328.         if (optionptr[i] != DHCP_PADDING)
  329.             i += optionptr[i + OPT_LEN] + OPT_DATA - 1;
  330.         i++;
  331.     }
  332.     return i;
  333. }

  335. /**
  336.  * Get an option with bounds checking
  337.  *
  338.  * @param packet DHCP packet.
  339.  * @param code Option code.
  340.  *
  341.  * @return NULL or pointer to beginning of the option data.
  342.  */
  343. static uint8_t* dhcp_get_option(struct dhcp_packet* packet, int code)
  344. {
  345.     uint8_t* optionptr;
  346.     int len;
  347.     int rem;
  348.     int overload = 0;
  349.     enum
  350.     {
  351.         FILE_FIELD101 = FILE_FIELD * 0x101,
  352.         SNAME_FIELD101 = SNAME_FIELD * 0x101,
  353.     };

  355.     /* option bytes: [code][len][data1][data2]...[dataLEN] */
  356.     optionptr = packet->options;
  357.     rem = sizeof(packet->options);
  358.     while (1)
  359.     {
  360.         if (rem <= 0)
  361.         {
  362.             return NULL;
  363.         }
  364.         if (optionptr[OPT_CODE] == DHCP_PADDING)
  365.         {
  366.             rem--;
  367.             optionptr++;
  368.             continue;
  369.         }
  370.         if (optionptr[OPT_CODE] == DHCP_END)
  371.         {
  372.             if ((overload & FILE_FIELD101) == FILE_FIELD)
  373.             {
  374.                 /* we can use packet->file */
  375.                 overload |= FILE_FIELD101;
  376.                 optionptr = packet->file;
  377.                 rem = sizeof(packet->file);
  378.                 continue;
  379.             }
  380.             if ((overload & SNAME_FIELD101) == SNAME_FIELD)
  381.             {
  382.                 /* we can use packet->sname */
  383.                 overload |= SNAME_FIELD101;
  384.                 optionptr = packet->sname;
  385.                 rem = sizeof(packet->sname);
  386.                 continue;
  387.             }
  388.             break;
  389.         }
  390.         len = OPT_DATA + optionptr[OPT_LEN];
  391.         rem -= len;
  392.         if (rem < 0)
  393.             continue;

  395.         if (optionptr[OPT_CODE] == code)
  396.             return optionptr + OPT_DATA;

  398.         if (optionptr[OPT_CODE] == DHCP_OVERLOAD)
  399.             overload |= optionptr[OPT_DATA];

  401.         optionptr += len;
  402.     }

  404.     return NULL;
  405. }

  407. /**
  408.  * Send DHCP DISCOVER
  409.  *
  410.  * @param fd Socket descriptor.
  411.  * @param ifindex Interface index.
  412.  * @param hwaddr MAC address of interface.
  413.  * @param id Unique ID.
  414.  *
  415.  * @return Number of bytes sent on success, -1 on error.
  416.  */
  417. static int dhcp_send_discover(int fd, int ifindex, uint8_t* hwaddr, uint32_t id)
  418. {
  419.     struct sockaddr_ll sa;
  420.     struct ip_udp_dhcp_packet packet;
  421.     unsigned padding;
  422.     int result = -1;

  424.     /* Bind */
  425.     memset(&sa, 0, sizeof(sa));
  426.     sa.sll_family = AF_PACKET;
  427.     sa.sll_protocol = htons(ETH_P_IP);
  428.     sa.sll_ifindex = ifindex;
  429.     sa.sll_halen = ETH_ALEN;
  430.     memset(&sa.sll_addr, 0xff, ETH_ALEN);

  432.     if (bind(fd, (struct sockaddr*)&sa, sizeof(sa)) < 0)
  433.     {
  434.         return result;
  435.     }

  437.     /* Craft packet */
  438.     memset(&packet, 0, sizeof(packet));
  439.     dhcp_init_packet(&packet.data, hwaddr);
  440.     packet.data.xid = id;

  442.     /* For badly configured servers (they drop DHCP packets > 576 octets (with ethernet header),
  443.      * but they may only drop packets > 576 octets without ethernet header (590 with ethernet header).
  444.      * RFC 1542: minimal BOOTP header 300 octets.
  445.      */
  446.     padding = DHCP_OPTIONS_BUF_MAX - 1 - dhcp_end_option(packet.data.options);
  447.     if (padding > DHCP_SIZE - 300)
  448.         padding = DHCP_SIZE - 300;

  450.     /* IP and UDP headers */
  451.     packet.ip.protocol = IPPROTO_UDP;
  452.     packet.ip.saddr = htonl(INADDR_ANY);
  453.     packet.ip.daddr = htonl(INADDR_BROADCAST);
  454.     packet.udp.source = htons(CLIENT_PORT);
  455.     packet.udp.dest = htons(SERVER_PORT);
  456.     /* size, excluding IP header */
  457.     packet.udp.len = htons(UDP_DHCP_SIZE - padding);
  458.     /* for UDP checksumming, ip.len is set to UDP packet len */
  459.     packet.ip.tot_len = packet.udp.len;

  461.     packet.udp.check = inet_chksum((uint16_t*)&packet,
  462.      IP_UDP_DHCP_SIZE - padding);
  463.     /* for sending, it is set to IP packet len */
  464.     packet.ip.tot_len = htons(IP_UDP_DHCP_SIZE - padding);
  465.     packet.ip.version = IPVERSION;
  466.     packet.ip.ihl = sizeof(packet.ip) >> 2;
  467.     packet.ip.ttl = IPDEFTTL;
  468.     packet.ip.check = inet_chksum((uint16_t*)&packet.ip, sizeof(packet.ip));

  470.     /* Send packet */
  471.     result = sendto(fd, &packet, IP_UDP_DHCP_SIZE - padding, 0,
  472.      (struct sockaddr*)&sa, sizeof(sa));

  474.     return result;
  475. }


  478. /**
  479.  * Receive OFFER
  480.  *
  481.  * @param fd Socket descriptor.
  482.  * @param id Unique ID.
  483.  * @param hwaddr MAC address of interface.
  484.  *
  485.  * @return 0 on success, -1 on read error,
  486.  * -2 packet is not correct, -3 on EINTR (time is out).
  487.  */
  488. static int dhcp_recv_offer(int fd, uint32_t id, uint8_t* hwaddr)
  489. {
  490.     int bytes;
  491.     struct ip_udp_dhcp_packet packet;
  492.     struct dhcp_packet data;

  494.     uint8_t* opt_data;
  495.     uint16_t check;
  496.     char ip_str[INET_ADDRSTRLEN];
  497.     uint32_t ip_addr;
  498.     int i;

  500.     memset(&packet, 0, sizeof(packet));
  501.     memset(&data, 0, sizeof(data));

  503.     /* Read packet */
  504.     bytes = read(fd, &packet, sizeof(packet));

  506.     if (bytes < 0)
  507.     {
  508.         if (errno == EINTR)
  509.         {
  510.             return -3;
  511.         }
  512.         else
  513.         {
  514.             return -1;
  515.         }
  516.     }
  517.     /* Packet is too short */
  518.     if (bytes < (int) (sizeof(packet.ip) + sizeof(packet.udp)))
  519.         return -2;
  520.     /* Oversized packet */
  521.     if (bytes < (int) ntohs(packet.ip.tot_len))
  522.         return -2;

  524.     /* Ignore any extra garbage bytes */
  525.     bytes = ntohs(packet.ip.tot_len);

  527.     /* Unrelated/bogus packet */
  528.     if (packet.ip.protocol != IPPROTO_UDP
  529.      || packet.ip.version != IPVERSION
  530.      || packet.ip.ihl != (sizeof(packet.ip) >> 2)
  531.      || packet.udp.dest != htons(CLIENT_PORT)
  532.      || ntohs(packet.udp.len) != (uint16_t)(bytes - sizeof(packet.ip)) )
  533.         return -2;

  535.     /* Verify IP checksum */
  536.     check = packet.ip.check;
  537.     packet.ip.check = 0;
  538.     if (check != inet_chksum((uint16_t*)&packet.ip, sizeof(packet.ip)))
  539.         return -2;

  541.     /* Verify UDP checksum, IP header has to be modified for this */
  542.     memset(&packet.ip, 0, offsetof(struct iphdr, protocol));
  543.     /* ip.xx fields which are not memset: protocol, check, saddr, daddr */
  544.     packet.ip.tot_len = packet.udp.len;
  545.     check = packet.udp.check;
  546.     packet.udp.check = 0;
  547.     if (check && check != inet_chksum((uint16_t*)&packet, bytes))
  548.         return -2;

  550.     memcpy(&data, &packet.data, sizeof(data));

  552.     /* Check DHCP magic */
  553.     if (bytes < (int)offsetof(struct dhcp_packet, options)
  554.      || data.cookie != htonl(DHCP_MAGIC))
  555.         return    -2;

  557.     /* Check xid */
  558.     if (data.xid != id)
  559.         return -2;

  561.     /* Ignore packets that aren't for us */
  562.     if (data.hlen != ETH_ALEN || memcmp(&data.chaddr, hwaddr, ETH_ALEN))
  563.         return -2;

  565.     /* Check message type */
  566.     opt_data = dhcp_get_option(&data, DHCP_MESSAGE_TYPE);
  567.     if (!opt_data || *opt_data != DHCPOFFER)
  568.         return -2;

  570.     /* print output */
  571.     /* Get DHCP server ID */
  572.     opt_data = dhcp_get_option(&data, DHCP_SERVER_ID);
  573.     if (opt_data)
  574.     {
  575.         ip_addr = *(uint32_t*)opt_data;
  576.         if (inet_ntop(AF_INET, &ip_addr, ip_str, sizeof(ip_str)))
  577.             printf("-->> server:%s\n", ip_str);
  578.     }

  580.     /* Get netmask */
  581.     opt_data = dhcp_get_option(&data, DHCP_SUBNET);
  582.     if (opt_data)
  583.     {
  584.         ip_addr = *(uint32_t*)opt_data;
  585.         if (inet_ntop(AF_INET, &ip_addr, ip_str, sizeof(ip_str)))
  586.             printf("-->> mask:%s\n", ip_str);
  587.     }

  589.     /* Get router */
  590.     opt_data = dhcp_get_option(&data, DHCP_ROUTER);
  591.     if (opt_data)
  592.     {
  593.         ip_addr = *(uint32_t*)opt_data;
  594.         if (inet_ntop(AF_INET, &ip_addr, ip_str, sizeof(ip_str)))
  595.             printf("-->> router:%s\n", ip_str);

  597.     }

  599.     /* Get DNS servers */
  600.     opt_data = dhcp_get_option(&data, DHCP_DNS);
  601.     if (opt_data)
  602.     {

  604.         int num = *(opt_data - 1) >> 2; /* get number of servers */
  605.         for (i = 0; i < num; i++)
  606.         {
  607.             ip_addr = (*((uint32_t*)opt_data + i));
  608.             if (inet_ntop(AF_INET, &ip_addr, ip_str, sizeof(ip_str)))
  609.                 printf("-->> dns%d:%s\n", i + 1, ip_str);
  610.             else
  611.                 break;
  612.         }
  613.     }

  615.     /* Get Broadcast address */
  616.     opt_data = dhcp_get_option(&data, DHCP_BROADCAST);
  617.     if (opt_data)
  618.     {
  619.         ip_addr = *(uint32_t*)opt_data;
  620.         if (inet_ntop(AF_INET, &ip_addr, ip_str, sizeof(ip_str)))
  621.             printf("-->> broadcast:%s\n", ip_str);

  623.     }
  624.     /* Get NETBIOS Name servers */
  625.     opt_data = dhcp_get_option(&data, DHCP_NETBIOS_NAME_SRV);
  626.     if (opt_data)
  627.     {
  628.         int num = *(opt_data - 1) >> 2; /* get number of servers */
  629.         for (i = 0; i < num; i++)
  630.         {
  631.             ip_addr = *((uint32_t*)opt_data + i);
  632.             if (inet_ntop(AF_INET, &ip_addr, ip_str, sizeof(ip_str)))
  633.                 printf("-->> netbios%d:%s\n", i + 1, ip_str);
  634.             else
  635.                 break;
  636.         }
  637.     }
  638.     return 0;
  639. }

  641. /**
  642.  * Signal handler
  643.  * @param Signal value.
  644.  *
  645.  * @return Void.
  646.  */
  647. static void handler(int sig)
  648. {
  649.     if (sig == SIGALRM)
  650.         got_alarm = 1;
  651. }


  654. /**
  655.  * Search DHCP server.
  656.  *
  657.  * @param ifname Network interface name.
  658.  * @param time Wait time.
  659.  *
  660.  * @return 1 on success, 0 on time is out, -2 on invalid json object for result,
  661.  * -1 on other errors.
  662.  */
  663. int scan_dhcp(const char* ifname, unsigned int time)
  664. {
  665.     int ifindex;
  666.     uint8_t hwaddr[ETH_ALEN];
  667.     struct sigaction sa;
  668.     uid_t euid;
  669.     uint32_t id;
  670.     int fd = -1;
  671.     int ret = -1;


  674.     /* Check superuser priveleges */
  675.     if ((euid = geteuid()) != 0)
  676.     {
  677.         printf( "You must be root\n");
  678.         goto err_exit;
  679.     }

  681.     /* Check input data */
  682.     /* Check wait time */
  683.     if (time == 0)
  684.         time = 1;

  686.     if (time > MAX_WAIT_TIME)
  687.     {
  688.         printf("Max wait time is %d\n", MAX_WAIT_TIME);
  689.         goto err_exit;
  690.     }

  692.     /* Check interface name */
  693.     if (!ifname || *ifname == '\0')
  694.     {
  695.         printf("Empty interface name\n");
  696.         goto err_exit;
  697.     }

  699.     /* Check interface name length */
  700.     if (strlen(ifname) > IFNAMSIZ)
  701.     {
  702.         printf("Interface name is too long\n");
  703.         goto err_exit;
  704.     }

  706.     /* Get interface index */
  707.     if ((ifindex = get_if_index(ifname)) == 0)
  708.     {
  709.         printf("No interface found\n");
  710.         goto err_exit;
  711.     }

  713.     /* Get MAC address */
  714.     if ((get_if_mac(ifname, hwaddr)) < 0)
  715.     {
  716.         printf( "Can't get MAC address\n");
  717.         goto err_exit;
  718.     }

  720.     /* Create socket */
  721.     fd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));

  723.     if (fd < 0)
  724.     {
  725.         printf("Can't create socket\n");
  726.         goto err_exit;
  727.     }

  729.     /* Establish handler for notification signal */
  730.     memset(&sa, 0, sizeof(struct sigaction));
  731.     sa.sa_flags = 0;
  732.     sigemptyset(&sa.sa_mask);
  733.     sa.sa_handler = handler;
  734.     if ((sigaction(SIGALRM, &sa, NULL)) == -1)
  735.     {
  736.         printf("Can't set handler for timer\n");
  737.         goto err_exit2;
  738.     }

  740.     /* Send Request */
  741.     id = random_id();
  742.     ret = dhcp_send_discover(fd, ifindex, hwaddr, id);
  743.     if (ret < 0)
  744.     {
  745.         printf("Can't send request\n");
  746.         goto err_exit2;
  747.     }

  749.     /* Start timer */
  750.     alarm(time);

  752.     /* Loop, recv packets && search answer for us */
  753.     while(1)
  754.     {
  755.         ret = dhcp_recv_offer(fd, id, hwaddr);

  757.         /* Answer received */
  758.         if (ret == 0)
  759.         {
  760.             ret = 1;
  761.             break;
  762.         }
  763.         /* Read error */
  764.         if (ret == -1)
  765.         {
  766.             printf("Read socket error\n");
  767.             break;
  768.         }

  770.         /* Check timer */
  771.         if (got_alarm == 1)
  772.         {
  773.             ret = 0;
  774.             break;
  775.         }
  776.     }
  777.     /* Cancel timer */
  778.     alarm(0);
  779. err_exit2:
  780.     close(fd);
  781. err_exit:
  782.     return ret;
  783. }


  786. int main(int argc, char** argv)
  787. {
  788.     if(argc < 2)
  789.     {
  790.         printf("must appoint a interface\n");
  791.         return 127;
  792.     }
  793.     return scan_dhcp(argv[1], 3);
  794. }

demo测试：


注意，需要root权限运行
上一篇：池化技术与线程池的简单实现
下一篇：一文读懂内核spin lock接口原理及使用