641 lines
20 KiB
Perl
641 lines
20 KiB
Perl
|
#! /usr/bin/perl
|
||
|
|
#
|
||
|
|
# File: gendhcp.p
|
||
|
|
# Author: Darin Davis, Copyright 1998
|
||
|
|
# Date: 19 January 1998
|
||
|
|
# Update: 28 October 1998
|
||
|
|
# Desc: gendhcp.p is designed to test the ability of a DHCP server
|
||
|
|
# to respond to a large number of DHCP client requests submitted
|
||
|
|
# in rapid succession. Each DISCOVER message contains a unique:
|
||
|
|
#
|
||
|
|
# - Hardware address (CHADDR), beginning with '0fffffff'
|
||
|
|
# and ending with a unique 16-bit number (starting by
|
||
|
|
# default with 1).
|
||
|
|
# - Client ID, identical to the hardware address
|
||
|
|
# - XID, beginning with 'eeee' and ending with the same
|
||
|
|
# ending number as the hardware address
|
||
|
|
# - Hostname, beginning with 'dhcp-client-' and ending
|
||
|
|
# with the same ending number as the hardware address
|
||
|
|
# except in decimal rather than hex
|
||
|
|
#
|
||
|
|
# The script logic can be outlined as follows:
|
||
|
|
#
|
||
|
|
# 1 - Blast out all the DISCOVER msgs and optionally wait a
|
||
|
|
# user-specified number of seconds to give the server a chance
|
||
|
|
# to respond.
|
||
|
|
#
|
||
|
|
# 2 - Send REQUESTS for all the OFFERs in my input socket.
|
||
|
|
#
|
||
|
|
# 3 - Make note of any ACKs I receive.
|
||
|
|
#
|
||
|
|
# 4 - If I haven't received all the OFFERs, then resend DISCOVERs
|
||
|
|
# for each DISCOVER as yet unOFFERed and optionally wait a
|
||
|
|
# user-specified number of seconds to give the server a chance
|
||
|
|
# to respond and go to step 2.
|
||
|
|
#
|
||
|
|
# 5 - If I have received all the OFFERs but not all the ACKs, then
|
||
|
|
# resend a DISCOVER for each ACK I am missing and go to step 2.
|
||
|
|
# Note that this is a departure from the RFC which suggests the
|
||
|
|
# client should reREQUEST not reDISCOVER. But the implementation
|
||
|
|
# was simpler this way.
|
||
|
|
#
|
||
|
|
# When the reDISCOVER is performed, the same XID is used.
|
||
|
|
# This can cause problems for later versions of the QIP DHCP
|
||
|
|
# server which have a configuration parameter "CheckTransactionID".
|
||
|
|
# This parameter defaults to TRUE, meaning that the server will
|
||
|
|
# not issue an address for a previously detected Transaction ID
|
||
|
|
# (XID)/MAC address tuple. To suppress this behavior, set the
|
||
|
|
# "CheckTransactionID" policy to FALSE by putting the following
|
||
|
|
# into the dhcpd.pcy file:
|
||
|
|
#
|
||
|
|
# CheckTransactionID=0
|
||
|
|
#
|
||
|
|
# Thanks to Gary DiFazio for providing this information about QIP.
|
||
|
|
#
|
||
|
|
# There are no timeouts in the script. Only the optional wait.
|
||
|
|
#
|
||
|
|
# gendhcp.p simulates the four packet exchange DISCOVER-OFFER-
|
||
|
|
# REQUEST-ACK, and maintains two associative arrays, one for
|
||
|
|
# outstanding OFFERs and one for outstanding ACKs. The arrays
|
||
|
|
# are indexed by the CHADDR of the DISCOVER packet. gendhcp.p
|
||
|
|
# first blasts out all the DISCOVER messages, noting the CHADDRs
|
||
|
|
# in the Offers and Acks arrays, and then goes into a loop waiting
|
||
|
|
# for responses. If it receives an OFFER, it sends a REQUEST and
|
||
|
|
# deletes the CHADDR from the Offers array. If it receives an ACK,
|
||
|
|
# it deletes the CHADDR from the Acks array. If there are no
|
||
|
|
# responses from a server to read but there are still outstanding
|
||
|
|
# OFFERs or ACKs, it reDISCOVERS everything in the Offers array (or
|
||
|
|
# if empty, the Acks array). It continues this process until all
|
||
|
|
# ACKs have been received.
|
||
|
|
#
|
||
|
|
# Some DHCP servers send their OFFER messages to the IP broadcast
|
||
|
|
# address. Others (such as NTS IPserver) address the OFFER to the
|
||
|
|
# IP address which it is offering. Because the OFFER is not
|
||
|
|
# addressed to the machine on which you run gendhcp.p, gendhcp.p
|
||
|
|
# can't receive the offer. So, to test a server of the latter
|
||
|
|
# variety, use the '-r' option. This puts gendhcp.p in "relay
|
||
|
|
# agent" mode. It puts your machine's address in the GIADDR field,
|
||
|
|
# convincing the unsuspecting DHCP server that your machine is
|
||
|
|
# actually a router. So, the DHCP server addressees the OFFER to
|
||
|
|
# your machine.
|
||
|
|
#
|
||
|
|
# The author used tcpdump (on the same machine as gendhcp.p) in
|
||
|
|
# attempt to measure the effectiveness of the script. tcpdump
|
||
|
|
# didn't capture all the packets sent and received. Therefore,
|
||
|
|
# you would do well to use a standalone Sniffer-like device for
|
||
|
|
# any tracing.
|
||
|
|
#
|
||
|
|
# gendhcp.p is intended for testing a single DHCP server. If
|
||
|
|
# multiple DHCP servers are active, gendhcp.p will REQUEST only
|
||
|
|
# one IP address for a given hardware address (just as a normal
|
||
|
|
# DHCP client would).
|
||
|
|
#
|
||
|
|
# Developed for Linux with modifications for Solaris.
|
||
|
|
#
|
||
|
|
# Usage: See &usage().
|
||
|
|
|
||
|
|
|
||
|
|
########################
|
||
|
|
### GLOBAL CONSTANTS ###
|
||
|
|
########################
|
||
|
|
|
||
|
|
# define which OS this is
|
||
|
|
if (system("test `uname` = SunOS") == 0) {
|
||
|
|
$OS = "SunOS";
|
||
|
|
}
|
||
|
|
else { $OS = "Linux" }
|
||
|
|
#print "OS = $OS\n";
|
||
|
|
|
||
|
|
$AF_INET = 2; # define address family
|
||
|
|
|
||
|
|
if ($OS eq "Linux") { # Linux-specific definitions
|
||
|
|
$SOCK_DGRAM = 2; # define socket type
|
||
|
|
$SO_BROADCAST = 6;
|
||
|
|
$SOL_SOCKET = 1;
|
||
|
|
}
|
||
|
|
else { # Solaris-specific definitions
|
||
|
|
$SOCK_DGRAM = 1; # define socket type
|
||
|
|
$SO_BROADCAST = 32;
|
||
|
|
$SOL_SOCKET = 65535;
|
||
|
|
}
|
||
|
|
|
||
|
|
$SOCKADDR_FMT = 'S n a4 x8'; # set pack format
|
||
|
|
$DHCP_SERVER_PORT = 67;
|
||
|
|
$DHCP_CLIENT_PORT = 68;
|
||
|
|
$MAX_LEN = 1024; # max length of datagram
|
||
|
|
$FLAGS = 0; # flags for recv()
|
||
|
|
$DISC_MAX = 65000; # maximum number of discover msgs
|
||
|
|
# to be generated
|
||
|
|
$INADDR_ANY = pack("C4", split(/\./, "0.0.0.0"));
|
||
|
|
$SO_RCVBUF = 8;
|
||
|
|
$OPT_VAL = 1;
|
||
|
|
$TRUE = 1 == 1;
|
||
|
|
$DISC_MSG = 1;
|
||
|
|
$OFFER_MSG = 2;
|
||
|
|
$RQST_MSG = 3;
|
||
|
|
$ACK_MSG = 5;
|
||
|
|
$DELAY_MAX = 10; # limit on how long to wait before
|
||
|
|
# reading server replies
|
||
|
|
|
||
|
|
|
||
|
|
########################
|
||
|
|
### GLOBAL VARIABLES ###
|
||
|
|
########################
|
||
|
|
|
||
|
|
$Server_hostname = "255.255.255.255"; # default name of server host
|
||
|
|
$Server_pport; # packed remote port number
|
||
|
|
@Server_ipaddr; # server's IP address
|
||
|
|
@Client_ipaddr; # my IP address
|
||
|
|
*CS; # descriptor of socket bound to
|
||
|
|
# local DHCP client port
|
||
|
|
*SS; # descriptor of socket bound to
|
||
|
|
# local DHCP server port
|
||
|
|
$Protocol_name; # name of UDP protocol
|
||
|
|
$Protocol_aliases; # aliases of UDP
|
||
|
|
$Protocol_number; # UDP's protocol number
|
||
|
|
$Addr_family; # client's address family
|
||
|
|
$Discover_count = 1; # number of discover msgs to send
|
||
|
|
$Datagram; # server's reply message
|
||
|
|
$Suppress_request = ! $TRUE; # DO send requests
|
||
|
|
$Offer_cnt = 0; # number of OFFERs received
|
||
|
|
$Ack_cnt = 0; # number of ACKs received
|
||
|
|
$Relay = ! $TRUE; # boolean flag: should I act like a
|
||
|
|
# BOOTP relay agent (by listening
|
||
|
|
# for offers on the BOOTPS port)?
|
||
|
|
$Haddr = 1; # initial hardware address suffix
|
||
|
|
$Rc; # Return Code for system calls
|
||
|
|
%Offers; # outstanding (unreceived) OFFER msgs
|
||
|
|
%Acks; # outstanding (unreceived) ACK msgs
|
||
|
|
@Start_times; # user, system and elapsed start times
|
||
|
|
@End_times; # user, system and elapsed end times
|
||
|
|
$Delay = 0; # how long to wait before trying to
|
||
|
|
# read replies from server
|
||
|
|
$Retry = 0; # how many times we have to reDISCOVER
|
||
|
|
$Last_ack_cnt = 0; # last count of ACKs received
|
||
|
|
$Progress = ! $TRUE; # boolean flag: should I show the
|
||
|
|
# number of ACKs received?
|
||
|
|
|
||
|
|
###################
|
||
|
|
### SUBROUTINES ###
|
||
|
|
###################
|
||
|
|
|
||
|
|
#####################################
|
||
|
|
# defines functions needed to set
|
||
|
|
# socket to non-blocking using fcntl
|
||
|
|
#####################################
|
||
|
|
sub F_SETFL {4;}
|
||
|
|
|
||
|
|
if ($OS eq "Linux") { # Linux-specific definition
|
||
|
|
sub O_NONBLOCK {04000;}
|
||
|
|
}
|
||
|
|
else { # Solaris-specific definition
|
||
|
|
sub O_NONBLOCK {0x80;}
|
||
|
|
}
|
||
|
|
|
||
|
|
######################################
|
||
|
|
# creates socket and binds to
|
||
|
|
# DHCP client port
|
||
|
|
# GLOBAL VARS: Server_hostname,
|
||
|
|
# Server_pport, Client_ipaddr, CS, SS
|
||
|
|
######################################
|
||
|
|
sub setup_socket {
|
||
|
|
local($client_hostname, # name of this host
|
||
|
|
$client_pport # packed local port number
|
||
|
|
);
|
||
|
|
|
||
|
|
chop($client_hostname = `hostname`); # get my hostname
|
||
|
|
|
||
|
|
# get UDP's protocol number
|
||
|
|
($Protocol_name,$Protocol_aliases,$Protocol_number) = getprotobyname('udp');
|
||
|
|
|
||
|
|
# get my IP address
|
||
|
|
($Protocol_name,$Protocol_aliases,$type,$len,@Client_ipaddr) = gethostbyname($client_hostname);
|
||
|
|
|
||
|
|
# get server's IP address
|
||
|
|
($Protocol_name,$Protocol_aliases,$type,$len,@Server_ipaddr) = gethostbyname($Server_hostname);
|
||
|
|
|
||
|
|
# define fully-specified port addrs
|
||
|
|
$client_pport = pack($SOCKADDR_FMT, $AF_INET, $DHCP_CLIENT_PORT, $INADDR_ANY);
|
||
|
|
$Server_pport = pack($SOCKADDR_FMT, $AF_INET, $DHCP_SERVER_PORT, $Server_ipaddr[0]);
|
||
|
|
|
||
|
|
# create UDP socket
|
||
|
|
socket(CS, $AF_INET, $SOCK_DGRAM, $Protocol_number) ||
|
||
|
|
die("$0: cannot create CS socket ($!)");
|
||
|
|
|
||
|
|
# set socket to non-blocking
|
||
|
|
($Rc = fcntl(CS, &F_SETFL, &O_NONBLOCK)) ||
|
||
|
|
printf("error (%d) setting CS to non-blocking\n", $Rc);
|
||
|
|
|
||
|
|
|
||
|
|
# enable send/recv broadcasts
|
||
|
|
$Rc = setsockopt(CS, $SOL_SOCKET, $SO_BROADCAST, $OPT_VAL);
|
||
|
|
if (! defined($Rc)) { print "error calling setsockopt(SO_BROADCAST) for CS\n"; }
|
||
|
|
|
||
|
|
# bind to the socket
|
||
|
|
bind(CS, $client_pport) || die("$0: cannot bind CS socket to DHCP client port ($!)");
|
||
|
|
|
||
|
|
# setup extra socket in case we
|
||
|
|
# have to act as the relay agent
|
||
|
|
if ($Relay) {
|
||
|
|
$client_pport = pack($SOCKADDR_FMT, $AF_INET, $DHCP_SERVER_PORT, $INADDR_ANY);
|
||
|
|
|
||
|
|
# create UDP socket
|
||
|
|
socket(SS, $AF_INET, $SOCK_DGRAM, $Protocol_number) ||
|
||
|
|
die("$0: cannot create SS socket ($!)");
|
||
|
|
|
||
|
|
# set socket to non-blocking
|
||
|
|
($Rc = fcntl(SS, &F_SETFL, &O_NONBLOCK)) ||
|
||
|
|
printf("error (%d) setting SS to non-blocking\n", $Rc);
|
||
|
|
|
||
|
|
# enable send/recv broadcasts
|
||
|
|
$Rc = setsockopt(SS, $SOL_SOCKET, $SO_BROADCAST, $OPT_VAL);
|
||
|
|
if (! defined($Rc)) { print "error calling setsockopt(SO_BROADCAST) for SS\n"; }
|
||
|
|
|
||
|
|
# bind to the socket
|
||
|
|
bind(SS, $client_pport) || die("$0: cannot bind SS socket to DHCP server port ($!)");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#####################################
|
||
|
|
# builds and sends $discover_count
|
||
|
|
# number of DHCP DISCOVER messages
|
||
|
|
# GLOBAL VARS: CS, FLAGS, Server_pport
|
||
|
|
# Haddr
|
||
|
|
#####################################
|
||
|
|
sub send_discovers {
|
||
|
|
local($discover_count) = @_;
|
||
|
|
local($xid, $msg, $hostname, $hnlen, $tmp);
|
||
|
|
|
||
|
|
$xid = $Haddr; # initialize incremental variables
|
||
|
|
|
||
|
|
# build and send DISCOVER messages
|
||
|
|
while ($discover_count-- > 0) {
|
||
|
|
|
||
|
|
$msg = sprintf("0fffffff%04x", $Haddr);
|
||
|
|
$Offers{$msg} = $TRUE; # this DISCOVER msg has an outstanding
|
||
|
|
# OFFER msg
|
||
|
|
$Acks{$msg} = $TRUE; # this DISCOVER msg has an outstanding
|
||
|
|
# ACK msg
|
||
|
|
|
||
|
|
# op, htype, hlen, hops
|
||
|
|
$msg = pack("H2" x 4, "01", "01", "06", "00");
|
||
|
|
# xid, secs, flags
|
||
|
|
$msg .= pack("H4 n H8", "eeee", $xid++, 0);
|
||
|
|
# ciaddr, yiaddr, siaddr, giaddr
|
||
|
|
if ($Relay) {
|
||
|
|
$msg .= pack("H8 H8 H8 C4", 0, 0, 0, unpack("C4", $Client_ipaddr[0]));
|
||
|
|
}
|
||
|
|
else { $msg .= pack("H8 H8 H8 H8", 0, 0, 0, 0); }
|
||
|
|
|
||
|
|
# chaddr
|
||
|
|
$msg .= pack("H8 n H20", "0fffffff", $Haddr, 0);
|
||
|
|
$msg .= pack("H384", "0"); # sname, file
|
||
|
|
$msg .= pack("H8", "63825363"); # magic cookie
|
||
|
|
$msg .= pack("H6", "350101"); # message type DISCOVER
|
||
|
|
# client ID = chaddr
|
||
|
|
$msg .= pack("H4 H8 n", "3d06", "0fffffff", $Haddr);
|
||
|
|
|
||
|
|
### create unique hostname ###
|
||
|
|
$tmp = sprintf("dhcp-client-%05d", $Haddr++);
|
||
|
|
$hostname = "";
|
||
|
|
while (length($tmp) > 0) { # convert string to hex
|
||
|
|
$hostname .= sprintf("%02x", ord($tmp));
|
||
|
|
$tmp =~ s/^.//;
|
||
|
|
}
|
||
|
|
$hnlen = length($hostname); # hostname length
|
||
|
|
$msg .= pack("H2 C H$hnlen", "0c", $hnlen/2, "$hostname");
|
||
|
|
|
||
|
|
$msg .= pack("H2", "ff"); # end of options
|
||
|
|
# send msg
|
||
|
|
send(CS, $msg, $FLAGS, $Server_pport);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#####################################
|
||
|
|
# resends DHCP DISCOVER messages
|
||
|
|
# for each HW addr in %Offers
|
||
|
|
# GLOBAL VARS: CS, FLAGS, Server_pport
|
||
|
|
# Haddr, Retry, Delay
|
||
|
|
# RETURNS: number of DISCOVERs sent
|
||
|
|
#####################################
|
||
|
|
sub rediscover {
|
||
|
|
local($xid, $msg, $cnt, $hostname, $hnlen, $tmp);
|
||
|
|
|
||
|
|
$cnt = 0;
|
||
|
|
$Retry++;
|
||
|
|
# build and send DISCOVER messages
|
||
|
|
foreach $Haddr (keys %Offers) {
|
||
|
|
$xid = $Haddr;
|
||
|
|
$xid =~ s/^0fffffff//; # behead MAC addr prefix
|
||
|
|
|
||
|
|
# op, htype, hlen, hops
|
||
|
|
$msg = pack("H2" x 4, "01", "01", "06", "00");
|
||
|
|
# xid, secs, flags
|
||
|
|
$msg .= pack("H4 n H8", "eeee", $xid, 0);
|
||
|
|
# ciaddr, yiaddr, siaddr, giaddr
|
||
|
|
if ($Relay) {
|
||
|
|
$msg .= pack("H8 H8 H8 C4", 0, 0, 0, unpack("C4", $Client_ipaddr[0]));
|
||
|
|
}
|
||
|
|
else { $msg .= pack("H8 H8 H8 H8", 0, 0, 0, 0); }
|
||
|
|
|
||
|
|
# chaddr
|
||
|
|
$msg .= pack("H12 H20", $Haddr, 0);
|
||
|
|
$msg .= pack("H384", "0"); # sname, file
|
||
|
|
$msg .= pack("H8", "63825363"); # magic cookie
|
||
|
|
$msg .= pack("H6", "350101"); # message type DISCOVER
|
||
|
|
# client ID = chaddr
|
||
|
|
$msg .= pack("H4 H12", "3d06", $Haddr);
|
||
|
|
|
||
|
|
### create unique hostname ###
|
||
|
|
$tmp = sprintf("dhcp-client-%05d", $xid);
|
||
|
|
$hostname = "";
|
||
|
|
while (length($tmp) > 0) { # convert string to hex
|
||
|
|
$hostname .= sprintf("%02x", ord($tmp));
|
||
|
|
$tmp =~ s/^.//;
|
||
|
|
}
|
||
|
|
$hnlen = length($hostname); # hostname length
|
||
|
|
$msg .= pack("H2 C H$hnlen", "0c", $hnlen/2, "$hostname");
|
||
|
|
|
||
|
|
$msg .= pack("H2", "ff"); # end of options
|
||
|
|
|
||
|
|
# send msg
|
||
|
|
send(CS, $msg, $FLAGS, $Server_pport);
|
||
|
|
$cnt++; # incr count of msgs sent
|
||
|
|
}
|
||
|
|
|
||
|
|
if ($Delay > 0) { sleep($Delay); } # give server a chance to respond
|
||
|
|
return($cnt);
|
||
|
|
}
|
||
|
|
###################################
|
||
|
|
# builds and sends a single DHCP
|
||
|
|
# REQUEST message (if the message
|
||
|
|
# from the server is an OFFER not
|
||
|
|
# an ACK)
|
||
|
|
# GLOBAL VARS: CS and almost every
|
||
|
|
# other "local" var used herein
|
||
|
|
# RETURNS: DHCP msg type
|
||
|
|
###################################
|
||
|
|
sub send_request {
|
||
|
|
local($datagram) = @_;
|
||
|
|
local($server_id, $msg_type, $tmp_chaddr,
|
||
|
|
$client_id, $tmp, $hostname, $hnlen);
|
||
|
|
|
||
|
|
$msg_type = 0; # init local vars
|
||
|
|
$server_id = "";
|
||
|
|
|
||
|
|
$DHCP_STRUCT = "H2 H2 H2 H2 H8 H4 H4 H8 H8 H8 H8 H32 H384 H8 H*";
|
||
|
|
($op, $htype, $hlen, $hops, $xid, $secs, $flags, $ciaddr, $yiaddr, $siaddr, $giaddr, $chaddr, $sname_file, $cookie, $options) = unpack($DHCP_STRUCT, $datagram);
|
||
|
|
|
||
|
|
$tmp_opt = $options;
|
||
|
|
$tmp_chaddr = substr($chaddr, 0, 12); # trunc trailing zeros
|
||
|
|
|
||
|
|
# determine whether this is an ACK
|
||
|
|
# or OFFER by searching through
|
||
|
|
# options
|
||
|
|
while (length($tmp_opt) > 3) {
|
||
|
|
# ASSUMES no pad options!
|
||
|
|
$option = substr($tmp_opt, 0, 2); # extract option
|
||
|
|
$length = substr($tmp_opt, 2, 2); # extract length
|
||
|
|
# extract value
|
||
|
|
$value = substr($tmp_opt, 4, 2 * hex($length));
|
||
|
|
# behead leading option
|
||
|
|
$tmp_opt = substr($tmp_opt, 4 + 2 * hex($length));
|
||
|
|
|
||
|
|
if ($option eq "35") { # if this is DHCP_Msg_Type option
|
||
|
|
$msg_type = hex($value);
|
||
|
|
if ($msg_type == $ACK_MSG) { # if this is an ACK
|
||
|
|
|
||
|
|
# if I haven't yet seen this addr's ACK
|
||
|
|
if (defined($Acks{$tmp_chaddr})) {
|
||
|
|
delete($Acks{$tmp_chaddr}); # remove addr from ACK list
|
||
|
|
$Ack_cnt++; # increment number of ACKs recv'd
|
||
|
|
}
|
||
|
|
return($msg_type); # stop processing
|
||
|
|
}
|
||
|
|
|
||
|
|
if ($msg_type != $OFFER_MSG) { # if this is NOT an OFFER
|
||
|
|
return($msg_type); # then stop processing
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ($option eq "36") { # if this is Server_ID option
|
||
|
|
$server_id = $value;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ($msg_type != $OFFER_MSG) { # there was no DHCP_Msg_Type option
|
||
|
|
return($msg_type); # so stop processing
|
||
|
|
}
|
||
|
|
# this addr no longer has an
|
||
|
|
# outstanding OFFER
|
||
|
|
if (defined($Offers{$tmp_chaddr})) {
|
||
|
|
delete($Offers{$tmp_chaddr}); # remove addr from list
|
||
|
|
$Offer_cnt++; # increment number of OFFERs recv'd
|
||
|
|
}
|
||
|
|
else { return($msg_type); }
|
||
|
|
|
||
|
|
$rqst_msg = "350103"; # build REQUEST message type
|
||
|
|
$addr_rqst = "3204$yiaddr"; # build address request
|
||
|
|
if ($server_id) {
|
||
|
|
$srvr_id = "3604$server_id"; # server identifier
|
||
|
|
}
|
||
|
|
else { $srvr_id = "3604$siaddr"; }
|
||
|
|
|
||
|
|
$client_id = "3d06$tmp_chaddr"; # client identifier
|
||
|
|
|
||
|
|
### create unique hostname ###
|
||
|
|
$tmp_chaddr =~ s/^0fffffff//; # behead prefix
|
||
|
|
$tmp = sprintf("dhcp-client-%05d", hex($tmp_chaddr));
|
||
|
|
$hostname = "";
|
||
|
|
while (length($tmp) > 0) { # convert string to hex
|
||
|
|
$hostname .= sprintf("%02x", ord($tmp));
|
||
|
|
$tmp =~ s/^.//;
|
||
|
|
}
|
||
|
|
$hnlen = length($hostname); # hostname length
|
||
|
|
$hostname = sprintf("0c%02x$hostname", $hnlen/2);
|
||
|
|
|
||
|
|
$end_opt = "ff"; # end of options
|
||
|
|
|
||
|
|
$datagram = pack($DHCP_STRUCT, "01", $htype, $hlen, $hops, $xid, $secs, $flags, $ciaddr, "00000000", "00000000", $giaddr, $chaddr, $sname_file, $cookie, "$rqst_msg$addr_rqst$srvr_id$client_id$hostname$end_opt");
|
||
|
|
|
||
|
|
# send REQUEST msg
|
||
|
|
send(CS, $datagram, $FLAGS, $Server_pport);
|
||
|
|
|
||
|
|
return($msg_type);
|
||
|
|
}
|
||
|
|
#########################
|
||
|
|
# prints program usage
|
||
|
|
#########################
|
||
|
|
sub usage {
|
||
|
|
print <<END_USAGE;
|
||
|
|
|
||
|
|
Usage: $0 <flag> <value>
|
||
|
|
|
||
|
|
\tFlags\tValues
|
||
|
|
\t-a\tstarting hardware Address (default: 1)
|
||
|
|
\t-d\tnumber of Discover messages to send (default: 1)
|
||
|
|
\t-h, -?\tshow Help
|
||
|
|
\t-p\tshow Progress (number of ACKs received)
|
||
|
|
\t-r\tact like a Relay agent
|
||
|
|
\t-R\tsuppress sending REQUEST messages
|
||
|
|
\t-s\tServer hostname or IP address (default: broadcast)
|
||
|
|
\t-w\tWait time (in seconds) between retries (default: 0)
|
||
|
|
|
||
|
|
END_USAGE
|
||
|
|
|
||
|
|
exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
#################
|
||
|
|
### MAIN CODE ###
|
||
|
|
#################
|
||
|
|
|
||
|
|
$| = 1; # flush writes
|
||
|
|
|
||
|
|
# ensure we're root so we can
|
||
|
|
# bind to priviledged sockets
|
||
|
|
chomp($USER = `whoami`);
|
||
|
|
if ($USER ne "root") {
|
||
|
|
print "\n\t*** You must be root to run this program. ***\n";
|
||
|
|
&usage;
|
||
|
|
}
|
||
|
|
|
||
|
|
# process arguments
|
||
|
|
while($#ARGV >= 0) {
|
||
|
|
ARG_SWITCH: {
|
||
|
|
if ($ARGV[0] =~ /^(-h|-\?)$/) { &usage; }
|
||
|
|
|
||
|
|
# show progress
|
||
|
|
if ($ARGV[0] =~ /^-p$/) {
|
||
|
|
shift(@ARGV); # discard flag
|
||
|
|
$Progress = $TRUE;
|
||
|
|
last ARG_SWITCH;
|
||
|
|
}
|
||
|
|
# don't send request messages
|
||
|
|
if ($ARGV[0] =~ /^-R$/) {
|
||
|
|
shift(@ARGV); # discard flag
|
||
|
|
$Suppress_request = $TRUE;
|
||
|
|
last ARG_SWITCH;
|
||
|
|
}
|
||
|
|
# act as a relay agent
|
||
|
|
if ($ARGV[0] =~ /^-r$/) {
|
||
|
|
shift(@ARGV); # discard flag
|
||
|
|
$Relay = $TRUE;
|
||
|
|
last ARG_SWITCH;
|
||
|
|
}
|
||
|
|
# user specified server
|
||
|
|
if ($ARGV[0] =~ /^-s$/) {
|
||
|
|
shift(@ARGV); # discard flag
|
||
|
|
$Server_hostname = $ARGV[0];
|
||
|
|
shift(@ARGV); # discard server hostname
|
||
|
|
last ARG_SWITCH;
|
||
|
|
}
|
||
|
|
# user specified DISCOVER count
|
||
|
|
if ($ARGV[0] =~ /^-d$/) {
|
||
|
|
shift(@ARGV); # discard flag
|
||
|
|
$Discover_count = $ARGV[0];
|
||
|
|
if ($Discover_count < 1 || $Discover_count > $DISC_MAX) {
|
||
|
|
print "Discover count must be between 1 and $DISC_MAX.\n";
|
||
|
|
exit;
|
||
|
|
}
|
||
|
|
shift(@ARGV); # discard server hostname
|
||
|
|
last ARG_SWITCH;
|
||
|
|
}
|
||
|
|
# user specified Wait time
|
||
|
|
if ($ARGV[0] =~ /^-w$/) {
|
||
|
|
shift(@ARGV); # discard flag
|
||
|
|
$Delay = $ARGV[0];
|
||
|
|
if ($Delay < 0 || $Delay > $DELAY_MAX) {
|
||
|
|
print "Wait time be between 0 and $DELAY_MAX.\n";
|
||
|
|
exit;
|
||
|
|
}
|
||
|
|
shift(@ARGV); # discard Wait time
|
||
|
|
last ARG_SWITCH;
|
||
|
|
}
|
||
|
|
# user specified starting HW addr
|
||
|
|
if ($ARGV[0] =~ /^-a$/) {
|
||
|
|
shift(@ARGV); # discard flag
|
||
|
|
$Haddr = $ARGV[0];
|
||
|
|
if ($Haddr < 1 || $Haddr > $DISC_MAX) {
|
||
|
|
print "Starting hardware address must be between 1 and $DISC_MAX.\n";
|
||
|
|
exit;
|
||
|
|
}
|
||
|
|
shift(@ARGV); # discard server hostname
|
||
|
|
last ARG_SWITCH;
|
||
|
|
}
|
||
|
|
print "Unknown flag '$ARGV[0]'.\n";
|
||
|
|
exit;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
# create socket capable of broadcasts
|
||
|
|
&setup_socket($Server_hostname);
|
||
|
|
|
||
|
|
# get the start user, system, and...
|
||
|
|
($Start_times[0], $Start_times[1], $junk, $junk) = times;
|
||
|
|
$Start_times[2] = time; # ...absolute times
|
||
|
|
|
||
|
|
# blast out all the DISCOVER msgs
|
||
|
|
print "Sending $Discover_count DISCOVER messages...\n";
|
||
|
|
&send_discovers($Discover_count);
|
||
|
|
|
||
|
|
if ($Delay > 0) { sleep($Delay); } # give server a chance to respond
|
||
|
|
|
||
|
|
if ($Suppress_request) { exit; } # should I process the OFFER msgs?
|
||
|
|
|
||
|
|
# yes
|
||
|
|
print "Waiting for $Discover_count ACKs...\n";
|
||
|
|
while ($Ack_cnt < $Discover_count) {
|
||
|
|
|
||
|
|
# if I'm supposed to report progress
|
||
|
|
# then do so
|
||
|
|
if ($Progress) {
|
||
|
|
if (($Ack_cnt % 10) == 0 && $Ack_cnt > $Last_ack_cnt) {
|
||
|
|
print "$Ack_cnt ACKs...\n";
|
||
|
|
$Last_ack_cnt = $Ack_cnt;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
# receive the OFFER/ACK msg
|
||
|
|
if ($Relay) {
|
||
|
|
$Rc = recv(SS, $Datagram, $MAX_LEN, $FLAGS);
|
||
|
|
}
|
||
|
|
else { $Rc = recv(CS, $Datagram, $MAX_LEN, $FLAGS); }
|
||
|
|
|
||
|
|
if (! defined($Rc)) { # if no more incoming messages
|
||
|
|
# to process
|
||
|
|
if ($Offer_cnt < $Discover_count) {
|
||
|
|
&rediscover;
|
||
|
|
}
|
||
|
|
else { # we've received all the OFFERs
|
||
|
|
|
||
|
|
if ($Ack_cnt < $Discover_count) { # if we're missing some ACKs
|
||
|
|
%Offers = %Acks; # then reDISCOVER (rather than
|
||
|
|
# reREQUEST as advised in RFC2131;
|
||
|
|
# this choice is for the sake of
|
||
|
|
# simplicity in this program)
|
||
|
|
$Offer_cnt = $Ack_cnt;
|
||
|
|
&rediscover;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else { # I have a reply to process
|
||
|
|
&send_request($Datagram); # send the REQUEST msg
|
||
|
|
}
|
||
|
|
}
|
||
|
|
### print statistics ###
|
||
|
|
|
||
|
|
print "Received $Ack_cnt Acks.\n";
|
||
|
|
|
||
|
|
# get the ending user, system, and...
|
||
|
|
($End_times[0], $End_times[1], $junk, $junk) = times;
|
||
|
|
$End_times[2] = time; # ...absolute times
|
||
|
|
|
||
|
|
printf("\nTimes: %.2f user, %.2f system, %d elapsed\n",
|
||
|
|
$End_times[0] - $Start_times[0],
|
||
|
|
$End_times[1] - $Start_times[1],
|
||
|
|
$End_times[2] - $Start_times[2]);
|
||
|
|
|
||
|
|
print "Number of reDISCOVERies: $Retry\n";
|
||
|
|
|
||
|
|
close(CS); # close client socket
|
||
|
|
|
||
|
|
if ($Relay) { close(SS); } # close server socket
|