1 /*****************************************************************************
3 * Nagios check_dhcp plugin
6 * Copyright (c) 2001-2004 Ethan Galstad (nagios@nagios.org)
7 * Copyright (c) 2001-2007 Nagios Plugin Development Team
9 * Last Modified: $Date$
13 * This file contains the check_dhcp plugin
15 * This plugin tests the availability of DHCP servers on a network.
17 * Unicast mode was originally implemented by Heiti of Boras Kommun with
18 * general improvements as well as usability fixes and "forward"-porting by
19 * Andreas Ericsson of OP5 AB.
22 * This program is free software: you can redistribute it and/or modify
23 * it under the terms of the GNU General Public License as published by
24 * the Free Software Foundation, either version 3 of the License, or
25 * (at your option) any later version.
27 * This program is distributed in the hope that it will be useful,
28 * but WITHOUT ANY WARRANTY; without even the implied warranty of
29 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 * GNU General Public License for more details.
32 * You should have received a copy of the GNU General Public License
33 * along with this program. If not, see <http://www.gnu.org/licenses/>.
37 *****************************************************************************/
39 const char *progname
= "check_dhcp";
40 const char *revision
= "$Revision$";
41 const char *copyright
= "2001-2007";
42 const char *email
= "nagiosplug-devel@lists.sourceforge.net";
55 #include <sys/ioctl.h>
58 #include <sys/socket.h>
59 #include <sys/types.h>
61 #include <netinet/in.h>
63 #include <arpa/inet.h>
65 #include <sys/sockio.h>
68 #if defined( __linux__ )
70 #include <linux/if_ether.h>
73 #elif defined (__bsd__)
75 #include <netinet/if_ether.h>
76 #include <sys/param.h>
77 #include <sys/sysctl.h>
78 #include <net/if_dl.h>
80 #elif defined(__sun__) || defined(__solaris__) || defined(__hpux__)
87 #include <sys/stropts.h>
91 #define bcopy(source, destination, length) memcpy(destination, source, length)
93 #define AREA_SZ 5000 /* buffer length in bytes */
94 static u_long ctl_area
[AREA_SZ
];
95 static u_long dat_area
[AREA_SZ
];
96 static struct strbuf ctl
= {AREA_SZ
, 0, (char *)ctl_area
};
97 static struct strbuf dat
= {AREA_SZ
, 0, (char *)dat_area
};
105 #define u_int8_t uint8_t
106 #define u_int16_t uint16_t
107 #define u_int32_t uint32_t
109 static int get_msg(int);
110 static int check_ctrl(int);
111 static int put_ctrl(int, int, int);
112 static int put_both(int, int, int, int);
113 static int dl_open(const char *, int, int *);
114 static int dl_bind(int, int, u_char
*);
115 long mac_addr_dlpi( const char *, int, u_char
*);
121 /**** Common definitions ****/
130 /**** DHCP definitions ****/
132 #define MAX_DHCP_CHADDR_LENGTH 16
133 #define MAX_DHCP_SNAME_LENGTH 64
134 #define MAX_DHCP_FILE_LENGTH 128
135 #define MAX_DHCP_OPTIONS_LENGTH 312
138 typedef struct dhcp_packet_struct
{
139 u_int8_t op
; /* packet type */
140 u_int8_t htype
; /* type of hardware address for this machine (Ethernet, etc) */
141 u_int8_t hlen
; /* length of hardware address (of this machine) */
142 u_int8_t hops
; /* hops */
143 u_int32_t xid
; /* random transaction id number - chosen by this machine */
144 u_int16_t secs
; /* seconds used in timing */
145 u_int16_t flags
; /* flags */
146 struct in_addr ciaddr
; /* IP address of this machine (if we already have one) */
147 struct in_addr yiaddr
; /* IP address of this machine (offered by the DHCP server) */
148 struct in_addr siaddr
; /* IP address of DHCP server */
149 struct in_addr giaddr
; /* IP address of DHCP relay */
150 unsigned char chaddr
[MAX_DHCP_CHADDR_LENGTH
]; /* hardware address of this machine */
151 char sname
[MAX_DHCP_SNAME_LENGTH
]; /* name of DHCP server */
152 char file
[MAX_DHCP_FILE_LENGTH
]; /* boot file name (used for diskless booting?) */
153 char options
[MAX_DHCP_OPTIONS_LENGTH
]; /* options */
157 typedef struct dhcp_offer_struct
{
158 struct in_addr server_address
; /* address of DHCP server that sent this offer */
159 struct in_addr offered_address
; /* the IP address that was offered to us */
160 u_int32_t lease_time
; /* lease time in seconds */
161 u_int32_t renewal_time
; /* renewal time in seconds */
162 u_int32_t rebinding_time
; /* rebinding time in seconds */
163 struct dhcp_offer_struct
*next
;
167 typedef struct requested_server_struct
{
168 struct in_addr server_address
;
170 struct requested_server_struct
*next
;
174 #define BOOTREQUEST 1
177 #define DHCPDISCOVER 1
179 #define DHCPREQUEST 3
180 #define DHCPDECLINE 4
183 #define DHCPRELEASE 7
185 #define DHCP_OPTION_MESSAGE_TYPE 53
186 #define DHCP_OPTION_HOST_NAME 12
187 #define DHCP_OPTION_BROADCAST_ADDRESS 28
188 #define DHCP_OPTION_REQUESTED_ADDRESS 50
189 #define DHCP_OPTION_LEASE_TIME 51
190 #define DHCP_OPTION_SERVER_IDENTIFIER 54
191 #define DHCP_OPTION_RENEWAL_TIME 58
192 #define DHCP_OPTION_REBINDING_TIME 59
193 #define DHCP_OPTION_END 255
195 #define DHCP_INFINITE_TIME 0xFFFFFFFF
197 #define DHCP_BROADCAST_FLAG 32768
198 #define DHCP_UNICAST_FLAG 0
200 #define DHCP_SERVER_PORT 67
201 #define DHCP_CLIENT_PORT 68
203 #define ETHERNET_HARDWARE_ADDRESS 1 /* used in htype field of dhcp packet */
204 #define ETHERNET_HARDWARE_ADDRESS_LENGTH 6 /* length of Ethernet hardware addresses */
206 u_int8_t unicast
= 0; /* unicast mode: mimic a DHCP relay */
207 struct in_addr my_ip
; /* our address (required for relay) */
208 struct in_addr dhcp_ip
; /* server to query (if in unicast mode) */
209 unsigned char client_hardware_address
[MAX_DHCP_CHADDR_LENGTH
]="";
210 unsigned char *user_specified_mac
=NULL
;
212 char network_interface_name
[IFNAMSIZ
]="eth0";
214 u_int32_t packet_xid
=0;
216 u_int32_t dhcp_lease_time
=0;
217 u_int32_t dhcp_renewal_time
=0;
218 u_int32_t dhcp_rebinding_time
=0;
220 int dhcpoffer_timeout
=2;
222 dhcp_offer
*dhcp_offer_list
=NULL
;
223 requested_server
*requested_server_list
=NULL
;
225 int valid_responses
=0; /* number of valid DHCPOFFERs we received */
226 int requested_servers
=0;
227 int requested_responses
=0;
229 int request_specific_address
=FALSE
;
230 int received_requested_address
=FALSE
;
232 struct in_addr requested_address
;
235 int process_arguments(int, char **);
236 int call_getopt(int, char **);
237 int validate_arguments(void);
238 void print_usage(void);
239 void print_help(void);
241 void resolve_host(const char *in
,struct in_addr
*out
);
242 unsigned char *mac_aton(const char *);
243 void print_hardware_address(const unsigned char *);
244 int get_hardware_address(int,char *);
245 int get_ip_address(int,char *);
247 int send_dhcp_discover(int);
248 int get_dhcp_offer(int);
250 int get_results(void);
252 int add_dhcp_offer(struct in_addr
,dhcp_packet
*);
253 int free_dhcp_offer_list(void);
254 int free_requested_server_list(void);
256 int create_dhcp_socket(void);
257 int close_dhcp_socket(int);
258 int send_dhcp_packet(void *,int,int,struct sockaddr_in
*);
259 int receive_dhcp_packet(void *,int,int,int,struct sockaddr_in
*);
263 int main(int argc
, char **argv
){
265 int result
= STATE_UNKNOWN
;
267 setlocale (LC_ALL
, "");
268 bindtextdomain (PACKAGE
, LOCALEDIR
);
269 textdomain (PACKAGE
);
271 if(process_arguments(argc
,argv
)!=OK
){
272 usage4 (_("Could not parse arguments"));
275 /* this plugin almost certainly needs root permissions. */
276 np_warn_if_not_root();
278 /* create socket for DHCP communications */
279 dhcp_socket
=create_dhcp_socket();
281 /* get hardware address of client machine */
282 if(user_specified_mac
!=NULL
)
283 memcpy(client_hardware_address
,user_specified_mac
,6);
285 get_hardware_address(dhcp_socket
,network_interface_name
);
287 if(unicast
) /* get IP address of client machine */
288 get_ip_address(dhcp_socket
,network_interface_name
);
290 /* send DHCPDISCOVER packet */
291 send_dhcp_discover(dhcp_socket
);
293 /* wait for a DHCPOFFER packet */
294 get_dhcp_offer(dhcp_socket
);
296 /* close socket we created */
297 close_dhcp_socket(dhcp_socket
);
299 /* determine state/plugin output to return */
300 result
=get_results();
302 /* free allocated memory */
303 free_dhcp_offer_list();
304 free_requested_server_list();
311 /* determines hardware address on client machine */
312 int get_hardware_address(int sock
,char *interface_name
){
314 #if defined(__linux__)
317 strncpy((char *)&ifr
.ifr_name
,interface_name
,sizeof(ifr
.ifr_name
)-1);
318 ifr
.ifr_name
[sizeof(ifr
.ifr_name
)-1]='\0';
320 /* try and grab hardware address of requested interface */
321 if(ioctl(sock
,SIOCGIFHWADDR
,&ifr
)<0){
322 printf(_("Error: Could not get hardware address of interface '%s'\n"),interface_name
);
326 memcpy(&client_hardware_address
[0],&ifr
.ifr_hwaddr
.sa_data
,6);
328 #elif defined(__bsd__)
329 /* King 2004 see ACKNOWLEDGEMENTS */
334 struct if_msghdr
*ifm
;
335 struct sockaddr_dl
*sdl
;
341 mib
[4] = NET_RT_IFLIST
;
343 if((mib
[5] = if_nametoindex(interface_name
)) == 0){
344 printf(_("Error: if_nametoindex error - %s.\n"), strerror(errno
));
348 if(sysctl(mib
, 6, NULL
, &len
, NULL
, 0) < 0){
349 printf(_("Error: Couldn't get hardware address from %s. sysctl 1 error - %s.\n"), interface_name
, strerror(errno
));
353 if((buf
= malloc(len
)) == NULL
){
354 printf(_("Error: Couldn't get hardware address from interface %s. malloc error - %s.\n"), interface_name
, strerror(errno
));
358 if(sysctl(mib
, 6, buf
, &len
, NULL
, 0) < 0){
359 printf(_("Error: Couldn't get hardware address from %s. sysctl 2 error - %s.\n"), interface_name
, strerror(errno
));
363 ifm
= (struct if_msghdr
*)buf
;
364 sdl
= (struct sockaddr_dl
*)(ifm
+ 1);
365 ptr
= (unsigned char *)LLADDR(sdl
);
366 memcpy(&client_hardware_address
[0], ptr
, 6) ;
369 #elif defined(__sun__) || defined(__solaris__)
371 /* Kompf 2000-2003 see ACKNOWLEDGEMENTS */
373 char dev
[20] = "/dev/";
377 for(p
= interface_name
; *p
&& isalpha(*p
); p
++)
382 strncat(dev
, interface_name
, 6) ;
385 printf(_("Error: can't find unit number in interface_name (%s) - expecting TypeNumber eg lnc0.\n"), interface_name
);
388 stat
= mac_addr_dlpi(dev
, unit
, client_hardware_address
);
390 printf(_("Error: can't read MAC address from DLPI streams interface for device %s unit %d.\n"), dev
, unit
);
394 #elif defined(__hpux__)
397 char dev
[20] = "/dev/dlpi" ;
400 stat
= mac_addr_dlpi(dev
, unit
, client_hardware_address
);
402 printf(_("Error: can't read MAC address from DLPI streams interface for device %s unit %d.\n"), dev
, unit
);
405 /* Kompf 2000-2003 */
408 printf(_("Error: can't get MAC address for this architecture. Use the --mac option.\n"));
413 print_hardware_address(client_hardware_address
);
418 /* determines IP address of the client interface */
419 int get_ip_address(int sock
,char *interface_name
){
420 #if defined(SIOCGIFADDR)
423 strncpy((char *)&ifr
.ifr_name
,interface_name
,sizeof(ifr
.ifr_name
)-1);
424 ifr
.ifr_name
[sizeof(ifr
.ifr_name
)-1]='\0';
426 if(ioctl(sock
,SIOCGIFADDR
,&ifr
)<0){
427 printf(_("Error: Cannot determine IP address of interface %s\n"),
432 my_ip
=((struct sockaddr_in
*)&ifr
.ifr_addr
)->sin_addr
;
435 printf(_("Error: Cannot get interface IP address on this platform.\n"));
440 printf(_("Pretending to be relay client %s\n"),inet_ntoa(my_ip
));
445 /* sends a DHCPDISCOVER broadcast message in an attempt to find DHCP servers */
446 int send_dhcp_discover(int sock
){
447 dhcp_packet discover_packet
;
448 struct sockaddr_in sockaddr_broadcast
;
452 /* clear the packet data structure */
453 bzero(&discover_packet
,sizeof(discover_packet
));
456 /* boot request flag (backward compatible with BOOTP servers) */
457 discover_packet
.op
=BOOTREQUEST
;
459 /* hardware address type */
460 discover_packet
.htype
=ETHERNET_HARDWARE_ADDRESS
;
462 /* length of our hardware address */
463 discover_packet
.hlen
=ETHERNET_HARDWARE_ADDRESS_LENGTH
;
466 * transaction ID is supposed to be random. We won't use the address so
467 * we don't care about high entropy here. time(2) is good enough.
471 discover_packet
.xid
=htonl(packet_xid
);
473 /**** WHAT THE HECK IS UP WITH THIS?!? IF I DON'T MAKE THIS CALL, ONLY ONE SERVER RESPONSE IS PROCESSED!!!! ****/
474 /* downright bizzarre... */
475 ntohl(discover_packet
.xid
);
477 /*discover_packet.secs=htons(65535);*/
478 discover_packet
.secs
=0xFF;
481 * server needs to know if it should broadcast or unicast its response:
482 * 0x8000L == 32768 == 1 << 15 == broadcast, 0 == unicast
484 discover_packet
.flags
= unicast
? 0 : htons(DHCP_BROADCAST_FLAG
);
486 /* our hardware address */
487 memcpy(discover_packet
.chaddr
,client_hardware_address
,ETHERNET_HARDWARE_ADDRESS_LENGTH
);
489 /* first four bytes of options field is magic cookie (as per RFC 2132) */
490 discover_packet
.options
[0]='\x63';
491 discover_packet
.options
[1]='\x82';
492 discover_packet
.options
[2]='\x53';
493 discover_packet
.options
[3]='\x63';
496 /* DHCP message type is embedded in options field */
497 discover_packet
.options
[opts
++]=DHCP_OPTION_MESSAGE_TYPE
; /* DHCP message type option identifier */
498 discover_packet
.options
[opts
++]='\x01'; /* DHCP message option length in bytes */
499 discover_packet
.options
[opts
++]=DHCPDISCOVER
;
501 /* the IP address we're requesting */
502 if(request_specific_address
==TRUE
){
503 discover_packet
.options
[opts
++]=DHCP_OPTION_REQUESTED_ADDRESS
;
504 discover_packet
.options
[opts
++]='\x04';
505 memcpy(&discover_packet
.options
[opts
],&requested_address
,sizeof(requested_address
));
506 opts
+= sizeof(requested_address
);
508 discover_packet
.options
[opts
++]=DHCP_OPTION_END
;
512 discover_packet
.giaddr
.s_addr
= my_ip
.s_addr
;
514 /* see RFC 1542, 4.1.1 */
515 discover_packet
.hops
= unicast
? 1 : 0;
517 /* send the DHCPDISCOVER packet to broadcast address */
518 sockaddr_broadcast
.sin_family
=AF_INET
;
519 sockaddr_broadcast
.sin_port
=htons(DHCP_SERVER_PORT
);
520 sockaddr_broadcast
.sin_addr
.s_addr
= unicast
? dhcp_ip
.s_addr
: INADDR_BROADCAST
;
521 bzero(&sockaddr_broadcast
.sin_zero
,sizeof(sockaddr_broadcast
.sin_zero
));
525 printf(_("DHCPDISCOVER to %s port %d\n"),inet_ntoa(sockaddr_broadcast
.sin_addr
),ntohs(sockaddr_broadcast
.sin_port
));
526 printf("DHCPDISCOVER XID: %u (0x%X)\n",ntohl(discover_packet
.xid
),ntohl(discover_packet
.xid
));
527 printf("DHCDISCOVER ciaddr: %s\n",inet_ntoa(discover_packet
.ciaddr
));
528 printf("DHCDISCOVER yiaddr: %s\n",inet_ntoa(discover_packet
.yiaddr
));
529 printf("DHCDISCOVER siaddr: %s\n",inet_ntoa(discover_packet
.siaddr
));
530 printf("DHCDISCOVER giaddr: %s\n",inet_ntoa(discover_packet
.giaddr
));
533 /* send the DHCPDISCOVER packet out */
534 send_dhcp_packet(&discover_packet
,sizeof(discover_packet
),sock
,&sockaddr_broadcast
);
545 /* waits for a DHCPOFFER message from one or more DHCP servers */
546 int get_dhcp_offer(int sock
){
547 dhcp_packet offer_packet
;
548 struct sockaddr_in source
;
549 struct sockaddr_in via
;
558 /* receive as many responses as we can */
559 for(responses
=0,valid_responses
=0;;){
562 if((current_time
-start_time
)>=dhcpoffer_timeout
)
568 bzero(&source
,sizeof(source
));
569 bzero(&via
,sizeof(via
));
570 bzero(&offer_packet
,sizeof(offer_packet
));
573 result
=receive_dhcp_packet(&offer_packet
,sizeof(offer_packet
),sock
,dhcpoffer_timeout
,&source
);
577 printf(_("Result=ERROR\n"));
583 printf(_("Result=OK\n"));
588 /* The "source" is either a server or a relay. */
589 /* Save a copy of "source" into "via" even if it's via itself */
590 memcpy(&via
,&source
,sizeof(source
)) ;
592 /* If siaddr is non-zero, set "source" to siaddr */
593 if(offer_packet
.siaddr
.s_addr
!= 0L){
594 source
.sin_addr
.s_addr
= offer_packet
.siaddr
.s_addr
;
598 printf(_("DHCPOFFER from IP address %s"),inet_ntoa(source
.sin_addr
));
599 printf(_(" via %s\n"),inet_ntoa(via
.sin_addr
));
600 printf("DHCPOFFER XID: %u (0x%X)\n",ntohl(offer_packet
.xid
),ntohl(offer_packet
.xid
));
603 /* check packet xid to see if its the same as the one we used in the discover packet */
604 if(ntohl(offer_packet
.xid
)!=packet_xid
){
606 printf(_("DHCPOFFER XID (%u) did not match DHCPDISCOVER XID (%u) - ignoring packet\n"),ntohl(offer_packet
.xid
),packet_xid
);
611 /* check hardware address */
614 printf("DHCPOFFER chaddr: ");
616 for(x
=0;x
<ETHERNET_HARDWARE_ADDRESS_LENGTH
;x
++){
618 printf("%02X",(unsigned char)offer_packet
.chaddr
[x
]);
620 if(offer_packet
.chaddr
[x
]!=client_hardware_address
[x
])
628 printf(_("DHCPOFFER hardware address did not match our own - ignoring packet\n"));
634 printf("DHCPOFFER ciaddr: %s\n",inet_ntoa(offer_packet
.ciaddr
));
635 printf("DHCPOFFER yiaddr: %s\n",inet_ntoa(offer_packet
.yiaddr
));
636 printf("DHCPOFFER siaddr: %s\n",inet_ntoa(offer_packet
.siaddr
));
637 printf("DHCPOFFER giaddr: %s\n",inet_ntoa(offer_packet
.giaddr
));
640 add_dhcp_offer(source
.sin_addr
,&offer_packet
);
646 printf(_("Total responses seen on the wire: %d\n"),responses
);
647 printf(_("Valid responses for this machine: %d\n"),valid_responses
);
655 /* sends a DHCP packet */
656 int send_dhcp_packet(void *buffer
, int buffer_size
, int sock
, struct sockaddr_in
*dest
){
659 result
=sendto(sock
,(char *)buffer
,buffer_size
,0,(struct sockaddr
*)dest
,sizeof(*dest
));
662 printf(_("send_dhcp_packet result: %d\n"),result
);
672 /* receives a DHCP packet */
673 int receive_dhcp_packet(void *buffer
, int buffer_size
, int sock
, int timeout
, struct sockaddr_in
*address
){
678 socklen_t address_size
;
679 struct sockaddr_in source_address
;
683 /* wait for data to arrive (up time timeout) */
688 FD_SET(sock
,&readfds
);
689 FD_SET(sock
,&oobfds
);
690 nfound
= select(sock
+1,&readfds
,NULL
,&oobfds
,&tv
);
692 /* make sure some data has arrived */
693 if(!FD_ISSET(sock
,&readfds
)){
695 printf(_("No (more) data received (nfound: %d)\n"), nfound
);
701 /* why do we need to peek first? i don't know, its a hack. without it, the source address of the first packet received was
702 not being interpreted correctly. sigh... */
703 bzero(&source_address
,sizeof(source_address
));
704 address_size
=sizeof(source_address
);
705 recv_result
=recvfrom(sock
,(char *)buffer
,buffer_size
,MSG_PEEK
,(struct sockaddr
*)&source_address
,&address_size
);
707 printf("recv_result_1: %d\n",recv_result
);
708 recv_result
=recvfrom(sock
,(char *)buffer
,buffer_size
,0,(struct sockaddr
*)&source_address
,&address_size
);
710 printf("recv_result_2: %d\n",recv_result
);
714 printf(_("recvfrom() failed, "));
715 printf("errno: (%d) -> %s\n",errno
,strerror(errno
));
721 printf(_("receive_dhcp_packet() result: %d\n"),recv_result
);
722 printf(_("receive_dhcp_packet() source: %s\n"),inet_ntoa(source_address
.sin_addr
));
725 memcpy(address
,&source_address
,sizeof(source_address
));
734 /* creates a socket for DHCP communication */
735 int create_dhcp_socket(void){
736 struct sockaddr_in myname
;
737 struct ifreq interface
;
741 /* Set up the address we're going to bind to. */
742 bzero(&myname
,sizeof(myname
));
743 myname
.sin_family
=AF_INET
;
744 /* listen to DHCP server port if we're in unicast mode */
745 myname
.sin_port
= htons(unicast
? DHCP_SERVER_PORT
: DHCP_CLIENT_PORT
);
746 myname
.sin_addr
.s_addr
= unicast
? my_ip
.s_addr
: INADDR_ANY
;
747 bzero(&myname
.sin_zero
,sizeof(myname
.sin_zero
));
749 /* create a socket for DHCP communications */
750 sock
=socket(AF_INET
,SOCK_DGRAM
,IPPROTO_UDP
);
752 printf(_("Error: Could not create socket!\n"));
757 printf("DHCP socket: %d\n",sock
);
759 /* set the reuse address flag so we don't get errors when restarting */
761 if(setsockopt(sock
,SOL_SOCKET
,SO_REUSEADDR
,(char *)&flag
,sizeof(flag
))<0){
762 printf(_("Error: Could not set reuse address option on DHCP socket!\n"));
766 /* set the broadcast option - we need this to listen to DHCP broadcast messages */
767 if(setsockopt(sock
,SOL_SOCKET
,SO_BROADCAST
,(char *)&flag
,sizeof flag
)<0){
768 printf(_("Error: Could not set broadcast option on DHCP socket!\n"));
772 /* bind socket to interface */
773 #if defined(__linux__)
774 strncpy(interface
.ifr_ifrn
.ifrn_name
,network_interface_name
,IFNAMSIZ
-1);
775 interface
.ifr_ifrn
.ifrn_name
[IFNAMSIZ
-1]='\0';
776 if(setsockopt(sock
,SOL_SOCKET
,SO_BINDTODEVICE
,(char *)&interface
,sizeof(interface
))<0){
777 printf(_("Error: Could not bind socket to interface %s. Check your privileges...\n"),network_interface_name
);
782 strncpy(interface
.ifr_name
,network_interface_name
,IFNAMSIZ
-1);
783 interface
.ifr_name
[IFNAMSIZ
-1]='\0';
786 /* bind the socket */
787 if(bind(sock
,(struct sockaddr
*)&myname
,sizeof(myname
))<0){
788 printf(_("Error: Could not bind to DHCP socket (port %d)! Check your privileges...\n"),DHCP_CLIENT_PORT
);
796 /* closes DHCP socket */
797 int close_dhcp_socket(int sock
){
805 /* adds a requested server address to list in memory */
806 int add_requested_server(struct in_addr server_address
){
807 requested_server
*new_server
;
809 new_server
=(requested_server
*)malloc(sizeof(requested_server
));
813 new_server
->server_address
=server_address
;
814 new_server
->answered
=FALSE
;
816 new_server
->next
=requested_server_list
;
817 requested_server_list
=new_server
;
822 printf(_("Requested server address: %s\n"),inet_ntoa(new_server
->server_address
));
830 /* adds a DHCP OFFER to list in memory */
831 int add_dhcp_offer(struct in_addr source
,dhcp_packet
*offer_packet
){
832 dhcp_offer
*new_offer
;
834 unsigned option_type
;
835 unsigned option_length
;
836 struct in_addr serv_ident
= {0};
838 if(offer_packet
==NULL
)
841 /* process all DHCP options present in the packet */
842 for(x
=4;x
<MAX_DHCP_OPTIONS_LENGTH
;){
844 /* end of options (0 is really just a pad, but bail out anyway) */
845 if((int)offer_packet
->options
[x
]==-1 || (int)offer_packet
->options
[x
]==0)
848 /* get option type */
849 option_type
=offer_packet
->options
[x
++];
851 /* get option length */
852 option_length
=offer_packet
->options
[x
++];
855 printf("Option: %d (0x%02X)\n",option_type
,option_length
);
857 /* get option data */
859 case DHCP_OPTION_LEASE_TIME
:
860 memcpy(&dhcp_lease_time
, &offer_packet
->options
[x
],sizeof(dhcp_lease_time
));
861 dhcp_lease_time
= ntohl(dhcp_lease_time
);
863 case DHCP_OPTION_RENEWAL_TIME
:
864 memcpy(&dhcp_renewal_time
, &offer_packet
->options
[x
],sizeof(dhcp_renewal_time
));
865 dhcp_renewal_time
= ntohl(dhcp_renewal_time
);
867 case DHCP_OPTION_REBINDING_TIME
:
868 memcpy(&dhcp_rebinding_time
, &offer_packet
->options
[x
],sizeof(dhcp_rebinding_time
));
869 dhcp_rebinding_time
= ntohl(dhcp_rebinding_time
);
871 case DHCP_OPTION_SERVER_IDENTIFIER
:
872 memcpy(&serv_ident
.s_addr
, &offer_packet
->options
[x
],sizeof(serv_ident
.s_addr
));
876 /* skip option data we're ignoring */
877 if(option_type
!=DHCP_OPTION_REBINDING_TIME
)
882 if(dhcp_lease_time
==DHCP_INFINITE_TIME
)
883 printf(_("Lease Time: Infinite\n"));
885 printf(_("Lease Time: %lu seconds\n"),(unsigned long)dhcp_lease_time
);
886 if(dhcp_renewal_time
==DHCP_INFINITE_TIME
)
887 printf(_("Renewal Time: Infinite\n"));
889 printf(_("Renewal Time: %lu seconds\n"),(unsigned long)dhcp_renewal_time
);
890 if(dhcp_rebinding_time
==DHCP_INFINITE_TIME
)
891 printf(_("Rebinding Time: Infinite\n"));
892 printf(_("Rebinding Time: %lu seconds\n"),(unsigned long)dhcp_rebinding_time
);
895 new_offer
=(dhcp_offer
*)malloc(sizeof(dhcp_offer
));
901 * RFC 2131 (2.) says: "DHCP clarifies the interpretation of the
902 * 'siaddr' field as the address of the server to use in the next step
903 * of the client's bootstrap process. A DHCP server may return its own
904 * address in the 'siaddr' field, if the server is prepared to supply
905 * the next bootstrap service (e.g., delivery of an operating system
906 * executable image). A DHCP server always returns its own address in
907 * the 'server identifier' option." 'serv_ident' is the 'server
908 * identifier' option, 'source' is the 'siaddr' field or (if 'siaddr'
909 * wasn't available) the IP address we received the DHCPOFFER from. If
910 * 'serv_ident' isn't available for some reason, we use 'source'.
912 new_offer
->server_address
=serv_ident
.s_addr
?serv_ident
:source
;
913 new_offer
->offered_address
=offer_packet
->yiaddr
;
914 new_offer
->lease_time
=dhcp_lease_time
;
915 new_offer
->renewal_time
=dhcp_renewal_time
;
916 new_offer
->rebinding_time
=dhcp_rebinding_time
;
920 printf(_("Added offer from server @ %s"),inet_ntoa(new_offer
->server_address
));
921 printf(_(" of IP address %s\n"),inet_ntoa(new_offer
->offered_address
));
924 /* add new offer to head of list */
925 new_offer
->next
=dhcp_offer_list
;
926 dhcp_offer_list
=new_offer
;
932 /* frees memory allocated to DHCP OFFER list */
933 int free_dhcp_offer_list(void){
934 dhcp_offer
*this_offer
;
935 dhcp_offer
*next_offer
;
937 for(this_offer
=dhcp_offer_list
;this_offer
!=NULL
;this_offer
=next_offer
){
938 next_offer
=this_offer
->next
;
946 /* frees memory allocated to requested server list */
947 int free_requested_server_list(void){
948 requested_server
*this_server
;
949 requested_server
*next_server
;
951 for(this_server
=requested_server_list
;this_server
!=NULL
;this_server
=next_server
){
952 next_server
=this_server
->next
;
960 /* gets state and plugin output to return */
961 int get_results(void){
962 dhcp_offer
*temp_offer
;
963 requested_server
*temp_server
;
965 u_int32_t max_lease_time
=0;
967 received_requested_address
=FALSE
;
969 /* checks responses from requested servers */
970 requested_responses
=0;
971 if(requested_servers
>0){
973 for(temp_server
=requested_server_list
;temp_server
!=NULL
;temp_server
=temp_server
->next
){
975 for(temp_offer
=dhcp_offer_list
;temp_offer
!=NULL
;temp_offer
=temp_offer
->next
){
977 /* get max lease time we were offered */
978 if(temp_offer
->lease_time
>max_lease_time
|| temp_offer
->lease_time
==DHCP_INFINITE_TIME
)
979 max_lease_time
=temp_offer
->lease_time
;
981 /* see if we got the address we requested */
982 if(!memcmp(&requested_address
,&temp_offer
->offered_address
,sizeof(requested_address
)))
983 received_requested_address
=TRUE
;
985 /* see if the servers we wanted a response from talked to us or not */
986 if(!memcmp(&temp_offer
->server_address
,&temp_server
->server_address
,sizeof(temp_server
->server_address
))){
988 printf(_("DHCP Server Match: Offerer=%s"),inet_ntoa(temp_offer
->server_address
));
989 printf(_(" Requested=%s"),inet_ntoa(temp_server
->server_address
));
990 if(temp_server
->answered
)
991 printf(_(" (duplicate)"));
994 if(temp_server
->answered
== FALSE
){
995 requested_responses
++;
996 temp_server
->answered
=TRUE
;
1004 /* else check and see if we got our requested address from any server */
1007 for(temp_offer
=dhcp_offer_list
;temp_offer
!=NULL
;temp_offer
=temp_offer
->next
){
1009 /* get max lease time we were offered */
1010 if(temp_offer
->lease_time
>max_lease_time
|| temp_offer
->lease_time
==DHCP_INFINITE_TIME
)
1011 max_lease_time
=temp_offer
->lease_time
;
1013 /* see if we got the address we requested */
1014 if(!memcmp(&requested_address
,&temp_offer
->offered_address
,sizeof(requested_address
)))
1015 received_requested_address
=TRUE
;
1020 if(valid_responses
==0)
1021 result
=STATE_CRITICAL
;
1022 else if(requested_servers
>0 && requested_responses
==0)
1023 result
=STATE_CRITICAL
;
1024 else if(requested_responses
<requested_servers
)
1025 result
=STATE_WARNING
;
1026 else if(request_specific_address
==TRUE
&& received_requested_address
==FALSE
)
1027 result
=STATE_WARNING
;
1029 if(result
==0) /* garrett honeycutt 2005 */
1032 printf("WARNING: ");
1034 printf("CRITICAL: ");
1036 printf("UNKNOWN: ");
1038 /* we didn't receive any DHCPOFFERs */
1039 if(dhcp_offer_list
==NULL
){
1040 printf(_("No DHCPOFFERs were received.\n"));
1044 printf(_("Received %d DHCPOFFER(s)"),valid_responses
);
1046 if(requested_servers
>0)
1047 printf(_(", %s%d of %d requested servers responded"),((requested_responses
<requested_servers
) && requested_responses
>0)?"only ":"",requested_responses
,requested_servers
);
1049 if(request_specific_address
==TRUE
)
1050 printf(_(", requested address (%s) was %soffered"),inet_ntoa(requested_address
),(received_requested_address
==TRUE
)?"":_("not "));
1052 printf(_(", max lease time = "));
1053 if(max_lease_time
==DHCP_INFINITE_TIME
)
1054 printf(_("Infinity"));
1056 printf("%lu sec",(unsigned long)max_lease_time
);
1064 /* process command-line arguments */
1065 int process_arguments(int argc
, char **argv
){
1072 while((c
+=(call_getopt(argc
-c
,&argv
[c
])))<argc
){
1075 if(is_option(argv[c]))
1080 return validate_arguments();
1085 int call_getopt(int argc
, char **argv
){
1089 int option_index
= 0;
1090 static struct option long_options
[] =
1092 {"serverip", required_argument
,0,'s'},
1093 {"requestedip", required_argument
,0,'r'},
1094 {"timeout", required_argument
,0,'t'},
1095 {"interface", required_argument
,0,'i'},
1096 {"mac", required_argument
,0,'m'},
1097 {"unicast", no_argument
, 0,'u'},
1098 {"verbose", no_argument
, 0,'v'},
1099 {"version", no_argument
, 0,'V'},
1100 {"help", no_argument
, 0,'h'},
1105 c
=getopt_long(argc
,argv
,"+hVvt:s:r:t:i:m:u",long_options
,&option_index
);
1109 if(c
==-1||c
==EOF
||c
==1)
1125 case 's': /* DHCP server address */
1126 resolve_host(optarg
,&dhcp_ip
);
1127 add_requested_server(dhcp_ip
);
1130 case 'r': /* address we are requested from DHCP servers */
1131 resolve_host(optarg
,&requested_address
);
1132 request_specific_address
=TRUE
;
1135 case 't': /* timeout */
1138 if(is_intnonneg(optarg))
1141 dhcpoffer_timeout
=atoi(optarg
);
1144 usage("Time interval must be a nonnegative integer\n");
1148 case 'm': /* MAC address */
1150 if((user_specified_mac
=mac_aton(optarg
)) == NULL
)
1151 usage("Cannot parse MAC address.\n");
1153 print_hardware_address(user_specified_mac
);
1157 case 'i': /* interface name */
1159 strncpy(network_interface_name
,optarg
,sizeof(network_interface_name
)-1);
1160 network_interface_name
[sizeof(network_interface_name
)-1]='\x0';
1164 case 'u': /* unicast testing */
1168 case 'V': /* version */
1169 print_revision(progname
,revision
);
1172 case 'h': /* help */
1176 case 'v': /* verbose */
1180 case '?': /* help */
1193 int validate_arguments(void){
1199 #if defined(__sun__) || defined(__solaris__) || defined(__hpux__)
1200 /* Kompf 2000-2003 see ACKNOWLEDGEMENTS */
1202 /* get a message from a stream; return type of message */
1203 static int get_msg(int fd
){
1209 res
= getmsg(fd
, &ctl
, &dat
, &flags
);
1216 printf("%s\n", "get_msg FAILED.");
1230 /* verify that dl_primitive in ctl_area = prim */
1231 static int check_ctrl(int prim
){
1232 dl_error_ack_t
*err_ack
= (dl_error_ack_t
*)ctl_area
;
1234 if(err_ack
->dl_primitive
!= prim
){
1235 printf(_("Error: DLPI stream API failed to get MAC in check_ctrl: %s.\n"), strerror(errno
));
1236 exit(STATE_UNKNOWN
);
1242 /* put a control message on a stream */
1243 static int put_ctrl(int fd
, int len
, int pri
){
1246 if(putmsg(fd
, &ctl
, 0, pri
) < 0){
1247 printf(_("Error: DLPI stream API failed to get MAC in put_ctrl/putmsg(): %s.\n"), strerror(errno
));
1248 exit(STATE_UNKNOWN
);
1254 /* put a control + data message on a stream */
1255 static int put_both(int fd
, int clen
, int dlen
, int pri
){
1259 if(putmsg(fd
, &ctl
, &dat
, pri
) < 0){
1260 printf(_("Error: DLPI stream API failed to get MAC in put_both/putmsg().\n"), strerror(errno
));
1261 exit(STATE_UNKNOWN
);
1267 /* open file descriptor and attach */
1268 static int dl_open(const char *dev
, int unit
, int *fd
){
1269 dl_attach_req_t
*attach_req
= (dl_attach_req_t
*)ctl_area
;
1271 if((*fd
= open(dev
, O_RDWR
)) == -1){
1272 printf(_("Error: DLPI stream API failed to get MAC in dl_attach_req/open(%s..): %s.\n"), dev
, strerror(errno
));
1273 exit(STATE_UNKNOWN
);
1275 attach_req
->dl_primitive
= DL_ATTACH_REQ
;
1276 attach_req
->dl_ppa
= unit
;
1277 put_ctrl(*fd
, sizeof(dl_attach_req_t
), 0);
1279 return check_ctrl(DL_OK_ACK
);
1282 /* send DL_BIND_REQ */
1283 static int dl_bind(int fd
, int sap
, u_char
*addr
){
1284 dl_bind_req_t
*bind_req
= (dl_bind_req_t
*)ctl_area
;
1285 dl_bind_ack_t
*bind_ack
= (dl_bind_ack_t
*)ctl_area
;
1287 bind_req
->dl_primitive
= DL_BIND_REQ
;
1288 bind_req
->dl_sap
= sap
;
1289 bind_req
->dl_max_conind
= 1;
1290 bind_req
->dl_service_mode
= DL_CLDLS
;
1291 bind_req
->dl_conn_mgmt
= 0;
1292 bind_req
->dl_xidtest_flg
= 0;
1293 put_ctrl(fd
, sizeof(dl_bind_req_t
), 0);
1295 if (GOT_ERR
== check_ctrl(DL_BIND_ACK
)){
1296 printf(_("Error: DLPI stream API failed to get MAC in dl_bind/check_ctrl(): %s.\n"), strerror(errno
));
1297 exit(STATE_UNKNOWN
);
1299 bcopy((u_char
*)bind_ack
+ bind_ack
->dl_addr_offset
, addr
,
1300 bind_ack
->dl_addr_length
);
1305 /***********************************************************************
1307 * function mac_addr_dlpi - get the mac address of the interface with
1308 * type dev (eg lnc, hme) and unit (0, 1 ..)
1310 * parameter: addr: an array of six bytes, has to be allocated by the caller
1312 * return: 0 if OK, -1 if the address could not be determined
1315 ***********************************************************************/
1317 long mac_addr_dlpi( const char *dev
, int unit
, u_char
*addr
){
1319 u_char mac_addr
[25];
1321 if(GOT_ERR
!= dl_open(dev
, unit
, &fd
)){
1322 if(GOT_ERR
!= dl_bind(fd
, INSAP
, mac_addr
)){
1323 bcopy( mac_addr
, addr
, 6);
1332 /* Kompf 2000-2003 */
1336 /* resolve host name or die (TODO: move this to netutils.c!) */
1337 void resolve_host(const char *in
,struct in_addr
*out
){
1338 struct addrinfo hints
, *ai
;
1340 memset(&hints
,0,sizeof(hints
));
1341 hints
.ai_family
=PF_INET
;
1342 if (getaddrinfo(in
,NULL
,&hints
,&ai
) != 0)
1343 usage_va(_("Invalid hostname/address - %s"),optarg
);
1345 memcpy(out
,&((struct sockaddr_in
*)ai
->ai_addr
)->sin_addr
,sizeof(*out
));
1350 /* parse MAC address string, return 6 bytes (unterminated) or NULL */
1351 unsigned char *mac_aton(const char *string
){
1352 static unsigned char result
[6];
1356 for(i
=0, j
=0; string
[i
] != '\0' && j
< sizeof(result
); i
++){
1357 /* ignore ':' and any other non-hex character */
1358 if(!isxdigit(string
[i
]) || !isxdigit(string
[i
+1]))
1363 result
[j
]=strtol(tmp
,(char **)NULL
,16);
1368 return (j
==6) ? result
: NULL
;
1372 void print_hardware_address(const unsigned char *address
){
1375 printf(_("Hardware address: "));
1377 printf("%2.2x:", address
[i
]);
1378 printf("%2.2x", address
[i
]);
1383 /* print usage help */
1384 void print_help(void){
1386 print_revision(progname
,revision
);
1388 printf("Copyright (c) 2001-2004 Ethan Galstad (nagios@nagios.org)\n");
1389 printf (COPYRIGHT
, copyright
, email
);
1391 printf("%s\n", _("This plugin tests the availability of DHCP servers on a network."));
1397 printf (_(UT_HELP_VRSN
));
1399 printf (_(UT_VERBOSE
));
1401 printf (" %s\n", "-s, --serverip=IPADDRESS");
1402 printf (" %s\n", _("IP address of DHCP server that we must hear from"));
1403 printf (" %s\n", "-r, --requestedip=IPADDRESS");
1404 printf (" %s\n", _("IP address that should be offered by at least one DHCP server"));
1405 printf (" %s\n", "-t, --timeout=INTEGER");
1406 printf (" %s\n", _("Seconds to wait for DHCPOFFER before timeout occurs"));
1407 printf (" %s\n", "-i, --interface=STRING");
1408 printf (" %s\n", _("Interface to to use for listening (i.e. eth0)"));
1409 printf (" %s\n", "-m, --mac=STRING");
1410 printf (" %s\n", _("MAC address to use in the DHCP request"));
1411 printf (" %s\n", "-u, --unicast");
1412 printf (" %s\n", _("Unicast testing: mimic a DHCP relay, requires -s"));
1414 printf (_(UT_SUPPORT
));
1422 printf (_("Usage:"));
1423 printf (" %s [-v] [-u] [-s serverip] [-r requestedip] [-t timeout]\n",progname
);
1424 printf (" [-i interface] [-m mac]\n");