dhcp 服务探测-凯发app官方网站

凯发app官方网站-凯发k8官网下载客户端中心 | | 凯发app官方网站-凯发k8官网下载客户端中心

苦海澜石

凯发app官方网站首页　| 　博文目录　| 　关于我

khls27

  • 博客访问： 752867
  • 博文数量： 144
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 1150
  • 用 户 组： 普通用户
  • 注册时间： 2014-03-17 14:32
个人简介

小公司研发总监，既当司令也当兵！

文章分类

全部博文（144）

推荐博文
相关博文
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
dhcp 服务探测

分类： linux

2020-11-05 11:03:53


在一些网络环境中，需要用到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权限运行
阅读(1890) | 评论(0) | 转发(0) |
0

上一篇：池化技术与线程池的简单实现

下一篇：一文读懂内核spin lock接口原理及使用

给主人留下些什么吧！~~
| | | | |

凯发app官方网站 copyright 2001-2010 chinaunix.net all rights reserved 北京皓辰网域网络信息技术有限公司. 凯发k8官网下载客户端中心的版权所有

感谢所有关心和支持过chinaunix的朋友们
")); function link(t){ var href= $(t).attr('href'); href ="?url=" encodeuricomponent(location.href); $(t).attr('href',href); //setcookie("returnouturl", location.href, 60, "/"); }
网站地图