diff options
35 files changed, 13529 insertions, 0 deletions
diff --git a/contrib/isc-dhcp/FREEBSD-upgrade b/contrib/isc-dhcp/FREEBSD-upgrade new file mode 100644 index 000000000000..d07c7acbc96b --- /dev/null +++ b/contrib/isc-dhcp/FREEBSD-upgrade @@ -0,0 +1,43 @@ +# ex:ts=8 + +ISC DHCP client 2.0b1pl11 + originals can be found at: ftp://ftp.isc.org/isc/dhcp/ + + +For the import of ISC-dhclient the following files were removed: + Makefile.conf Makefile.dist configure + docs/* relay/* server/* + + client/ + Makefile.dist dhclient-script.cat8 dhclient.cat8 + dhclient.conf.cat5 dhclient.leases.cat5 + + client/scripts/ + bsdos linux netbsd + nextstep solaris + + common/ + Makefile.dist dhcp-options.cat5 + + include/cf/ + alphaosf.h bsdos.h cygwin32.h + hpux.h linux.h netbsd.h + nextstep.h qnx.h rhapsody.h + sample.h sco.h sunos4.h + sunos5-5.h ultrix.h + + +Imported by: + + cvs import -ko -m 'Virgin import of ISC-DHCP v2.0b1pl11' \ + src/contrib/isc-dhcp ISC isc_dhcp_2_0_b_1_pl_11 + + +To make local changes to isc-dhcp, simply patch and commit to the main +branch (aka HEAD). Never make local changes on the vendor (ISC) branch. + +All local changes should be submitted to the ISC for inclusion in the +next vendor release. + +obrien@NUXI.com +9-Feburary-1999 diff --git a/contrib/isc-dhcp/README b/contrib/isc-dhcp/README new file mode 100644 index 000000000000..83c03bbb7dc1 --- /dev/null +++ b/contrib/isc-dhcp/README @@ -0,0 +1,288 @@ + Internet Software Consortium + Dynamic Host Configuration Protocol Distribution + Version 2, Beta 1, Patchlevel 11 + February 8, 1998 + +This is the first Beta release of Version 2 of the Internet Software +Consortium DHCP Distribution. In version 2.0, this distribution +includes a DHCP server, a DHCP client, and a BOOTP/DHCP relay agent. +This beta is believed to be fairly stable. However, DHCP server users +running a production environment should probably still use version +1.0, which is more stable, having been in a feature freeze since +November of 1996. + +In this release, the server and relay agent currently work well on +NetBSD, Linux, FreeBSD, BSD/OS, Ultrix, Digital Alpha OSF/1, and SunOS +4.1.4. They can also be run usefully on Solaris as long as only one +broadcast network interface is configured. They also runs on QNX as +long as only one broadcast network interface is configured and a host +route is added from that interface to the 255.255.255.255 broadcast +address. If you are running a Linux 2.0.30 or previous kernel, the +DHCP daemons will only be able to operate on machines with a single +network interface. + +The DHCP client currently only knows how to configure the network on +NetBSD, FreeBSD, BSD/os, Linux, Solaris and NextStep. The client +depends on a system-dependent shell script to do network +configuration - support for other operating systems is simply a matter +of porting this shell script to the new platform. + +If you wish to run the DHCP Distribution on Linux, please see the +Linux-specific notes later in this document. If you wish to run on an +SCO release, please see the SCO-specific notes later in this document. +You particularly need to read these notes if you intend to support +Windows 95 clients. If you are running a version of FreeBSD prior to +2.2, please read the note on FreeBSD. If you are running HP-UX or +Ultrix, please read the notes for those operating systems below. +If you are running NeXTSTEP, please see the notes on NeXTSTEP below. + +If you start dhcpd and get a message, "no free bpf", that means you +need to configure the Berkeley Packet Filter into your operating +system kernel. On NetBSD, FreeBSD and BSD/os, type ``man bpf'' for +information. On Digital Unix, type ``man pfilt''. + + + BUILDING THE DHCP DISTRIBUTION + +To build the DHCP Distribution, unpack the compressed tar file using +the tar utility and the gzip command - type something like: + + zcat dhcp-2.0b1pl11.tar.gz |tar xvf - + +Now, cd to the dhcp-2.0b1pl11 subdirectory that you've just created and +configure the source tree by typing: + + ./configure + +If the configure utility can figure out what sort of system you're +running on, it will create a custom Makefile for you for that +system; otherwise, it will complain. If it can't figure out what +system you are using, that system is not supported - you are on +your own. + +Once you've run configure, just type ``make'', and after a while +you should have a dhcp server. If you get compile errors on one +of the supported systems mentioned earlier, please let us know. +If you get warnings, it's not likely to be a problem - the DHCP +server compiles completely warning-free on as many architectures +as we can manage, but there are a few for which this is difficult. +If you get errors on a system not mentioned above, you will need +to do some programming or debugging on your own to get the DHCP +Distribution working. + +Once you have successfully gotten the DHCP Distribution to build, you +can install it by typing ``make install''. If you already have an old +version of the DHCP Distribution installed, you may want to save it +before typing ``make install''. + + LINUX + +There are three big LINUX issues: the all-ones broadcast address, +Linux 2.1 ip_bootp_agent enabling, and operations with more than one +network interface. There are also two potential compilation/runtime +problems for Linux 2.1/2.2: the "SO_ATTACH_FILTER undeclared" problem +and the "protocol not configured" problem. + + LINUX: SO_ATTACH_FILTER UNDECLARED + +In addition, there is a minor issue that we will mention here because +this release is so close on the heels of the Linux 2.2 release: there +is a symlink in /usr/include that points at the linux asm headers. It +appears to be not uncommon that this link won't be updated correctly, +in which case you'll get the following error when you try to build: + + lpf.c: In function `if_register_receive': + lpf.c:152: `SO_ATTACH_FILTER' undeclared (first use this function) + lpf.c:152: (Each undeclared identifier is reported only once + lpf.c:152: for each function it appears in.) + +The line numbers may be different, of course. If you see this +header, your linux asm header link is probably bad, and you should +make sure it's pointing to correct linux source directory. + + LINUX: PROTOCOL NOT CONFIGURED + +One additional Linux 2.1/2.2 issue: if you get the following message, +it's because your kernel doesn't have the linux packetfilter +configured: + + Can't install packet filter program: Protocol not available + exiting. + +If this happens, you need to edit your linux kernel .config file, set +CONFIG_FILTER=y, and rebuild your kernel. If the preceding sentence +made no sense to you, ask your Linux vendor/guru for help - please +don't ask us. + + LINUX: BROADCAST + +In order for dhcpd to work correctly with picky DHCP clients (e.g., +Windows 95), it must be able to send packets with an IP destination +address of 255.255.255.255. Unfortunately, Linux insists on changing +255.255.255.255 into the local subnet broadcast address (here, that's +192.5.5.223). This results in a DHCP protocol violation, and while +many DHCP clients don't notice the problem, some (e.g., all Microsoft +DHCP clients) do. Clients that have this problem will appear not to +see DHCPOFFER messages from the server. + +It is possible to work around this problem on some versions of Linux +by creating a host route from your network interface address to +255.255.255.255. The command you need to use to do this on Linux +varies from version to version. The easiest version is: + + route add -host 255.255.255.255 dev eth0 + +On some older Linux systems, you will get an error if you try to do +this. On those systems, try adding the following entry to your +/etc/hosts file: + +255.255.255.255 all-ones + +Then, try: + + route add -host all-ones dev eth0 + +Another route that has worked for some users is: + + route add -net 255.255.255.0 dev eth0 + +If you are not using eth0 as your network interface, you should +specify the network interface you *are* using in your route command. + + LINUX: IP BOOTP AGENT + +Some versions of the Linux 2.1 kernel apparently prevent dhcpd from +working unless you enable it by doing the following: + + echo 1 >/proc/sys/net/ipv4/ip_bootp_agent + + + LINUX: MULTIPLE INTERFACES + +Most older versions of the Linux kernel do not provide a networking +API that allows dhcpd to operate correctly if the system has more than +one broadcast network interface. However, Linux 2.0 kernels with +version numbers greater than or equal to 2.0.31 add an API feature: +the SO_BINDTODEVICE socket option. If SO_BINDTODEVICE is present, it +is possible for dhcpd to operate on Linux with more than one network +interface. In order to take advantage of this, you must be running a +2.0.31 or greater kernel, and you must have 2.0.31 or later system +headers installed *before* you build the DHCP Distribution. + +We have heard reports that you must still add routes to 255.255.255.255 +in order for the all-ones broadcast to work, even on 2.0.31 kernels. +In fact, you now need to add a route for each interface. Hopefully +the Linux kernel gurus will get this straight eventually. + + SCO + +SCO has the same problem as Linux (described earlier). The thing is, +SCO *really* doesn't want to let you add a host route to the all-ones +broadcast address. One technique that has been successful on some +versions of SCO is the very bizarre command: + + ifconfig net0 alias 10.1.1.1 netmask 8.0.0.0 + +Apparently this works because of an interaction between SCO's support +for network classes and the weird netmask. The 10.* network is just a +dummy that can generally be assumed to be safe. Don't ask why this +works. Just try it. If it works for you, great. If not, SCO is +supposedly adding hooks to support real DHCP service in a future +release - I have this on good authority from the people at SCO who do +*their* DHCP server and client. + + HP-UX + +HP-UX has the same problem with the all-ones broadcast address that +SCO and Linux have. One user reported that adding the following to +/etc/rc.config.d/netconf helped (you may have to modify this to suit +your local configuration): + +INTERFACE_NAME[0]=lan0 +IP_ADDRESS[0]=1.1.1.1 +SUBNET_MASK[0]=255.255.255.0 +BROADCAST_ADDRESS[0]="255.255.255.255" +LANCONFIG_ARGS[0]="ether" +DHCP_ENABLE[0]=0 + + ULTRIX + +Now that we have Ultrix packet filter support, the DHCP Distribution +on Ultrix should be pretty trouble-free. However, one thing you do +need to be aware of is that it now requires that the pfilt device be +configured into your kernel and present in /dev. If you type ``man +packetfilter'', you will get some information on how to configure your +kernel for the packet filter (if it isn't already) and how to make an +entry for it in /dev. + + FreeBSD + +Versions of FreeBSD prior to 2.2 have a bug in BPF support in that the +ethernet driver swaps the ethertype field in the ethernet header +downstream from BPF, which corrupts the output packet. If you are +running a version of FreeBSD prior to 2.2, and you find that dhcpd +can't communicate with its clients, you should #define BROKEN_FREEBSD_BPF +in site.h and recompile. + + NeXTSTEP + +The NeXTSTEP support uses the NeXTSTEP Berkeley Packet Filter +extension, which is not included in the base NextStep system. You +must install this extension in order to get dhcpd or dhclient to work. + + SOLARIS + +One problem which has been observed and is not fixed in this patchlevel +has to do with using DLPI on Solaris 2.6 machines, probably only on Intel, +but possibly also on SPARC. The symptom of this problem is that you never +receive any DHCP packets. If you are running Solaris 2.6, and you +encounter this symptom, and you are running the DHCP server on a machine +with a single broadcast network interface, you may wish to edit the +includes/site.h file and uncomment the #define USE_SOCKETS line. Then +type ``make clean; make''. + + SUPPORT + +The Internet Software Consortium DHCP server is not a commercial +product, and is not supported in that sense. However, it has +attracted a fairly sizable following on the Internet, which means that +there are a lot of knowledgable users who may be able to help you if +you get stuck. These people generally read the dhcp-server@fugue.com +mailing list. + +If you are going to use dhcpd, you should probably subscribe to the +dhcp-server and dhcp-announce mailing lists. If you will be using +dhclient, you should subscribe to the dhcp-client mailing list. +PLEASE DO NOT send queries about non-isc clients to the dhcp-client +mailing list. If you're asking about them on an ISC mailing list, +it's probably because you're using the ISC DHCP server, so ask there. + +Please see http://www.fugue.com/dhcp/lists for details on how to +subscribe. If you don't have WorldWide Web access, you can send mail +to dhcp-request@fugue.com and tell me which lists you want to +subscribe to, but please use the web interface if you can, since I +have to handle the -request mailing list manually, and I will give you +the third degree if you make me do your subscription manually. + +PLEASE DO NOT SEND REQUESTS FOR SUPPORT DIRECTLY TO ME! The number of +people using the DHCP Distribution is sufficiently large that if I +take an interrupt every time any one of those people runs into +trouble, I will never get any more coding done. + +PLEASE DO NOT CALL ME ON THE PHONE FOR SUPPORT! Answering the phone +takes a lot more of my time and attention than answering email. If you +do call me on the phone, I will tell you to send email to the mailing +list, and I won't answer your question, so there's no point in doing +it. + + BUGS + +This release of the DHCP Distribution does not yet contain support for +DHCPINFORM. Support for DHCPINFORM will be present in the release at +a later time. DHCPINFORM is somewhat tangential to the main purpose +of the DHCP protocol, so this probably won't be a major problem for +most users. + +Vendor tags and User tags are not currently supported. + + diff --git a/contrib/isc-dhcp/RELNOTES b/contrib/isc-dhcp/RELNOTES new file mode 100644 index 000000000000..c136fd7bac69 --- /dev/null +++ b/contrib/isc-dhcp/RELNOTES @@ -0,0 +1,447 @@ + Internet Software Consortium + Dynamic Host Configuration Protocol Distribution + Version 2, Beta 1, Patchlevel 10 + February 8, 1998 + + Release Notes + +This is the first Beta release of Version 2 of the Internet Software +Consortium DHCP Distribution. This beta is believed to be fairly +stable. + + PLANS + +Version 1 of the ISC DHCP Distribution includes just a DHCP Server. +Version 1 has been in feature freeze since late 1996, and is quite +stable. This is the release that we would expect very conservative +sites to run in production, but it is no longer recommended. + +Version 2 of the ISC DHCP Distribution adds a DHCP Client and a +DHCP/BOOTP Relay Agent to the DHCP Server that was offered in version +1.0. In addition, some new capabilities have been added to the +server: + + - IP addresses are now tested before they are assigned to + clients. This allows the DHCP server to detect rogue + machines that may have hijacked IP addresses before an IP + address conflict can occur. + + - The server may be configured so that some DHCP clients can + be excluded from booting. + + - Improved NAKing behaviour, so that clients that are using + addresses other than the one the server knows they should be + using are disciplined quickly. + +This version has been in a near feature freeze since January of 1998, +has been in Beta test since then, and is planned for final release in +mid-1999. It has a number of important features, and is the release +that we would expect most sites to run. It is possible to run the +Version 1 server with the Version 2 client at sites that want to be +really conservative. + +Version 3 of the ISC DHCP Distribution will add conditional behaviour, +client classing, Dynamic DNS Support, DHCPv4 16-bit option codes, +asynchronous DNS query resolution, DHCP Authentication, and possibly +support for a DHCP Interserver Protocol and live querying of the DHCP +database. Currently, only client classing and conditional behaviour +have been implemented - the DNS code is waiting for an enhanced DNS +resolver. The code has gone through a major internal restructuring +which will help to support wider option codes, and possibly IPv6, as +well as a more sensible memory allocation strategy. This release is +running in producion at the ISC, but is not expected to be stable in +the near future, and is intended for sites that are in a position to +experiment, or for sites that desperately need the new features. + + CHANGES FROM VERSION 2.0 BETA 1 PATCHLEVEL 10 + +- Update top-level Makefile so that it exits correctly on errors in + submakes under bash/gnu make (dunno which is the culprit, and don't + really care). + +- Print a more helpful message if no free BPF devices are found. + +- Add support for specifying that the server is or is not + authoritative for a particular network segment. + +- Fix two stupid typos in lpf.c. + +- Print a more helpful message if we can't create an LPF socket or + can't attach a filter to it. + + CHANGES FROM VERSION 2.0 BETA 1 PATCHLEVEL 9 + +- Correct the hopelessly outdated information about Linux at the top + of the README - many apologies to the Linux people who have had to + read that nonsense for the past couple of snapshots and have been + confused or annoyed by it. I simply hadn't read it recently, and + didn't realize how out-of-date it was. + +- Print a message if the client finds no broadcast interfaces to + configure. + +- Add support for use-lease-addr-for-default-route flag in server, so + that Windows machines can be made to ARP for all addresses. + +- Update README file to mention new Linux gotchas. + +- After finally understanding Brian Murrel's code (my fault, not his) + to get interface names from /proc/net/dev on Linux, fix what I broke + of his code and document it. + +- Use sendto rather than send for SOCK_PACKET sockets, because they + can't be connected, only bound. :'( + +- Fix up SOCK_PACKET creation so that the kernel doesn't complain + about it. + +- Fix incorrect tests in linux client script: + [ $relmajor == 2 ] -> [ $relmajor -eq 2 ] + +- Make typedefs for u8, u16 and u32 types. These are Linux kernel + internal data types which are unfortunately exposed in the linux + packetfilter header file. + +- Don't include <net/ethernet.h> in lpf.c - it defines things we're + already correctly defining elsewhere, and doesn't define any useful + new stuff. + +- Finally fix client PREINIT bug that causes interfaces not specified + on the command line to be preinitialized. If no interfaces are + specified on the command line, all interfaces are still + preinitialized. + + CHANGES FROM VERSION 2.0 BETA 1 PATCHLEVEL 8 + +- Fix socket API fallback setup code, which was causing Linux servers + and clients to loop endlessly on select when run as daemons. + +- Add support for Linux 2.2 version number (treated the same as Linux + 2.1, for now). + +- Correct apparent error in DHCPREQUEST destination address handling + when in INIT-REBOOT state. + +- Do not set BROADCAST flag if we have a valid IP address. + +- Remove hard-coded filenames and use system-specific manifest + constants. + +- Add entry and exit hooks to Linux dhclient-script (should be added + to all operating systems once tested). + +- Test for linux major and minor version so as to correctly invoke + network configuration programs. + +- Add support for Linux's gratuitous name change of bpf_insn structure + (can't pollute precious Linux sources with the "Berkeley" word, I + guess. + +- Correct USE_BPF_{SEND,RECEIVE} ifdefs for if_reinitialize_* + functions. + +- Ensure that we have ifreq structure before initializing interface - + if an interface was specified on the command line on Linux, this was + not the case. + +- Get rid of references to enstamp structure in lpf.c. Correctly + declare and initialize sock_fprog structure (aka bpf_filter + structure on non-Linux machines). + +- Define ssize_t on Ultrix. + + CHANGES FROM VERSION 2.0 BETA 1 PATCHLEVEL 7 + +- Generalize FDDI support. + +- Fix potential core dump in interface discovery code. + +- Put explicit release versions on startup messages. + + CHANGES FROM VERSION 2.0 BETA 1 PATCHLEVEL 6 + +- Add support for Linux Packet Filter (thanks to Brian Murrell, Interlinx). + +- Add support for FDDI hardware type. + +- Fix a long-standing bug in DLPI support where the ethertype was + being set incorrectly (thanks to Gong Wei, CCENet). + +- Don't use DLPI RAW mode on Solaris. + +- In the client, when a lease expires, the interface to which that + lease is attached is unconfigured. On systems that use the socket + API, the interface needs to then be reconfigured with the 0.0.0.0 + address so that it can be used to get a new address. + +- Add fallback support for Linux. This fixes a problem with the + relay agent when relaying over non-broadcast links, and may also fix + some obscure problems with unicasting DHCPACKs in both the server and + relay agent. + +- When allocating leases, if the oldest lease is abandoned, try to + find a younger-but-still-expired lease rather than reclaiming the + abandoned lease. + +- Add more documentation to README. + +- The absence of the /etc/dhclient.conf file is no longer considered + an error. + +- The dhcp client's lease file name can be specified on the command + line. + +- The DHCP client should no longer zap interfaces that it has not been + directed to configure. + +- If a client starts up in the init-reboot state, the xid will be a + "random" number rather than always being zero, as was previously the + case. + +- In addition to comparing transaction IDs, compare hardware addresses + in response packets to verify that they are ours. + +- Rewrite the client lease database after 20 leases have been written. + +- Fix the exponential backoff code. + +- Add a Y2k comment to indicate that something suspicious-looking is + in fact _not_ a problem. + +- Use mkstemp if possible. + +- Add missing fi in various client scripts. + +- Use "search" instead of "domain" in linux resolv.conf files. + +- Specify a hop count in all route command on solaris. + +- If an allocation fails, don't try to zero out the allocation buffer + we didn't get. + +- Support subnets that are subsets of other subnets - that is, for + example, 10.0.1.0/24 and 10.0.0.0/16. This is useful in fairly + obscure circumstances. + +- Don't set the lease end time if it's already expired. + +- Don't define INADDR_LOOPBACK on FreeBSD if it's already defined in a + system header. + +- Use the broadcast address in the relay agent if we are using the BSD + socket API. + +- Allow host declarations without names. + +- Allow the server identifier option to be specified. + +- Don't dump hostnames into the lease file if they contain + non-printable characters. + +- Copy the entire client hardware address buffer that the client sends + to the output packet, not just the portion of it that's supposedly + significant according to the hardware address length field. This + is done for the benefit of certain Microsoft clients. + +- Don't send a second ICMP echo request if we receive two DHCPDISCOVER + messages in quick succession. This prevents a rather annoying + timing race in configuring some Win95 clients. + +- Fix up dhcp-options man page to make it more readable. Note that + netbios-name-server is the same thing as WINS. + + + CHANGES FROM VERSION 2.0 BETA 1 PATCHLEVEL 5 + +- Define some extra DLPI support flags that make DLPI work much better + on Solaris. + +- Fix inet_aton prototype/declaration to match Internet Software + Consortium BIND distribution. + +- Document new server-identifier functionality. + + CHANGES FROM VERSION 2.0 BETA 1 PATCHLEVEL 4 + +- Do not use -Wstrict-prototypes on Solaris with gcc - if the Internet + Software Consortium BIND distribution is not installed, this produces + errors. + +- Actually use the new DLPI support on Solaris - although the code was + added in Patchlevel 2, it wasn't enabled (blush). + +- Fix a prototype bug that's exposed when DLPI support is enabled on + Solaris. + + CHANGES FROM VERSION 2.0 BETA 1 PATCHLEVEL 3 + +- Fix a makefile botch that prevents the DHCP Distribution from + from compiling on Solaris with gcc. Sigh. + + CHANGES FROM VERSION 2.0 BETA 1 PATCHLEVEL 2 + +- Allow server-identifier in any scope. Use in-scope server + identifier option rather than the default, if one exists. + +- Delete newlines from abandoned lease reclaimation warning. + +- Only release other applicable leases held by a client when the + client sends a DHCPREQUEST. + +- Fix core dump when find_lease didn't find a lease. + +- Update dhcpd.leases man page. + + CHANGES FROM VERSION 2.0 BETA 1 PATCHLEVEL 1 + +- Use -Wno-char-subscript on Solaris to prevent bogus warnings from + gcc on Solaris 2.6. + +- Add support for Apple's new Rhapsody operating system. + +- Use DLPI on Solaris instead of using the BSD Sockets API. + +- Fix two network input buffer overflow problems which could allow an + attacker to pervert the stack. + +- Fix an ancient typo that could theoretically cause memory + corruption. + +- Sort abandoned leases in at current time rather than end of time. + This allows abandoned leases to be reclaimed if there are no + available free leases. + +- If a client explicitly requests a lease that's been abandoned, it's + probably the system that was answering pings on that address, so let it + have the lease. + +- Fix a bunch of type conversion errors that are flagged by the Solaris + C compiler. + + CHANGES FROM VERSION 2.0 BETA 1 PATCHLEVEL 0 + +- Fix two potential buffer overflow problems. + +- Differentiate between versions of Linux for better success in + compiling. + +- Fix bug in linux client script regarding routing setup. + +- Clarify socket API error message on multiple interfaces. + +- Fix broken comparison that was setting IP source address to zero. + +- Reclaim abandoned leases if we run out of free leases. + + CHANGES FROM THE DECEMBER 2, 1997 SNAPSHOT + +- Use %ld to print pid_t and cast pid_t values to long to avoid + inconsistent declarations between different POSIX flavours. + +- Add support for ARPHRD_IEEE802 (token ring) hardware type. + +- If we own an address and a client requests it, but we can't assign + it to that client, we now NAK it so that the client doesn't try to + reuse it. + + CHANGES FROM THE JUNE SNAPSHOT + +- Support for NeXTstep 3.x and 4.x + +- Added man pages for dhcpd.leases, dhclient-script, dhclient.leases + and dhclient.conf. Move general documentation of DHCP options into + a seperate man page which is referred to by the dhclient.conf and + dhcpd.conf man pages. + +- Updated README to answer some frequently asked questions. + +- Fixed a bug in command-line interface specification in dhclient - it + was formerly not possible to specify that only certain interfaces be + configured. + +- Do not leave client scripts lying around in /tmp after they've been + used unless the -D flag is specified. + +- Add a new, non-standard, not-guaranteed-to-stay-the-same system + configuration status message server which can be used to trigger the + client to recheck its address, e.g., after a laptop has been put to + sleep and then awakened (this has yet to be documented). + +- Fix handling of media selection in the REBOOT phase - previously the + media type would not be remembered, which could cause severe delays + in reacquiring an address if the default media type was wrong. + +- Allocate space for a NUL terminator on the end of client options - + this was previously overlooked, and could cause garbage characters + to be written to the temporary client script files. + +- Use mkstemp if it's available. + +- Supply network number and broadcast address to the client script so + that on systems that need these values, they don't need to be + computed with an awk script. + +- Keep a PID file for the client and the relay agent, and have the + relay agent background itself by default. + +- Add client script for bsd/os, fix many niggling bugs in existing + client scripts and add support for static routing tables to all bsd + scripts. + +- Add a -q option to the client, server and relay agent so that they + can be started from /etc/rc scripts without spewing a bunch of + garbage on the console. By default, all three daemons still print + startup messages, since these are helpful in bug reporting. + +- Don't print anything to stderr or stdout after going into + background. + +- Fix bug where hostname keyword was not being recognized in + dhcpd.leases file, resulting in the loss of lease database entries. + +- Fix problem on some operating systems where zero-length ifreq + structures were being offset incorrectly when scanning the interface + list on startup. + +- Unless a BOOTP client requests it, never send more than 64 bytes of + options. + +- Don't ping static leases, since we don't have a lease structure on + the heap to work with later. + +- Fixed a compile problem on Solaris 2.6. + +- Support interface aliases on Solaris. + +- Print day and month with leading zero in lease files if less than + ten, for easier parsing by perl/sed/awk scripts. + +- Never make the lease database world writable, even if dhcpd is + invoked with a bogus umask. + +- Fix DHCPRELEASE handling (before, addressed would never be + released.) + +- If there is more than one lease for a particular client on a + particular network, find the lease the client is asking for so as to + avoid a cycle of NAKs. + +- If a BOOTP request is received from a particular client and that + client has previously received a DHCP address, make sure that we + still find a valid BOOTP lease so that we don't cycle through + addresses. + +- Remove server-identifier option from documentation, other than to + document that it has been deprecated. + +- Don't give up if we get an EINTR or EAGAIN while polling or + selecting - these return statuses can occur spuriously without + indicating a fatal problem. + +- Do not select for exceptions, since we don't handle them. This was + causing massive CPU consumption on some systems. + +- When a DHCP client has been assigned a fixed address but had + previously had a lease, it will request the old leased address. In + such an event, send a DHCPNAK so that it will discover its new + static binding. diff --git a/contrib/isc-dhcp/client/clparse.c b/contrib/isc-dhcp/client/clparse.c new file mode 100644 index 000000000000..49e6d02bc8dc --- /dev/null +++ b/contrib/isc-dhcp/client/clparse.c @@ -0,0 +1,1028 @@ +/* clparse.c + + Parser for dhclient config and lease files... */ + +/* + * Copyright (c) 1997 The Internet Software Consortium. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of The Internet Software Consortium nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND + * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This software has been written for the Internet Software Consortium + * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie + * Enterprises. To learn more about the Internet Software Consortium, + * see ``http://www.vix.com/isc''. To learn more about Vixie + * Enterprises, see ``http://www.vix.com''. + */ + +#ifndef lint +static char copyright[] = +"$Id: clparse.c,v 1.13.2.2 1998/07/10 23:17:00 mellon Exp $ Copyright (c) 1997 The Internet Software Consortium. All rights reserved.\n"; +#endif /* not lint */ + +#include "dhcpd.h" +#include "dhctoken.h" + +static TIME parsed_time; + +struct client_config top_level_config; +u_int32_t requested_lease_time; + +/* client-conf-file :== client-declarations EOF + client-declarations :== <nil> + | client-declaration + | client-declarations client-declaration */ + +int read_client_conf () +{ + FILE *cfile; + char *val; + int token; + int declaration = 0; + struct client_config *config; + struct client_state *state; + struct interface_info *ip; + + new_parse (path_dhclient_conf); + + /* Set up the initial dhcp option universe. */ + initialize_universes (); + + /* Initialize the top level client configuration. */ + memset (&top_level_config, 0, sizeof top_level_config); + + /* Set some defaults... */ + top_level_config.timeout = 60; + top_level_config.select_interval = 0; + top_level_config.reboot_timeout = 10; + top_level_config.retry_interval = 300; + top_level_config.backoff_cutoff = 120; + top_level_config.initial_interval = 10; + top_level_config.bootp_policy = ACCEPT; + top_level_config.script_name = "/sbin/dhclient-script"; + top_level_config.requested_options + [top_level_config.requested_option_count++] = + DHO_SUBNET_MASK; + top_level_config.requested_options + [top_level_config.requested_option_count++] = + DHO_BROADCAST_ADDRESS; + top_level_config.requested_options + [top_level_config.requested_option_count++] = + DHO_TIME_OFFSET; + top_level_config.requested_options + [top_level_config.requested_option_count++] = + DHO_ROUTERS; + top_level_config.requested_options + [top_level_config.requested_option_count++] = + DHO_DOMAIN_NAME; + top_level_config.requested_options + [top_level_config.requested_option_count++] = + DHO_DOMAIN_NAME_SERVERS; + top_level_config.requested_options + [top_level_config.requested_option_count++] = + DHO_HOST_NAME; + requested_lease_time = 7200; + top_level_config.send_options [DHO_DHCP_LEASE_TIME].data + = (unsigned char *)&requested_lease_time; + top_level_config.send_options [DHO_DHCP_LEASE_TIME].len + = sizeof requested_lease_time; + + if ((cfile = fopen (path_dhclient_conf, "r")) != NULL) { + do { + token = peek_token (&val, cfile); + if (token == EOF) + break; + parse_client_statement (cfile, + (struct interface_info *)0, + &top_level_config); + } while (1); + token = next_token (&val, cfile); /* Clear the peek buffer */ + fclose (cfile); + } + + /* Set up state and config structures for clients that don't + have per-interface configuration declarations. */ + config = (struct client_config *)0; + for (ip = interfaces; ip; ip = ip -> next) { + if (!ip -> client) { + ip -> client = (struct client_state *) + malloc (sizeof (struct client_state)); + if (!ip -> client) + error ("no memory for client state."); + memset (ip -> client, 0, sizeof *(ip -> client)); + } + if (!ip -> client -> config) { + if (!config) { + config = (struct client_config *) + malloc (sizeof (struct client_config)); + if (!config) + error ("no memory for client config."); + memcpy (config, &top_level_config, + sizeof top_level_config); + } + ip -> client -> config = config; + } + } + + return !warnings_occurred; +} + +/* lease-file :== client-lease-statements EOF + client-lease-statements :== <nil> + | client-lease-statements LEASE client-lease-statement */ + +void read_client_leases () +{ + FILE *cfile; + char *val; + int token; + + new_parse (path_dhclient_db); + + /* Open the lease file. If we can't open it, just return - + we can safely trust the server to remember our state. */ + if ((cfile = fopen (path_dhclient_db, "r")) == NULL) + return; + do { + token = next_token (&val, cfile); + if (token == EOF) + break; + if (token != LEASE) { + warn ("Corrupt lease file - possible data loss!"); + skip_to_semi (cfile); + break; + } else + parse_client_lease_statement (cfile, 0); + + } while (1); +} + +/* client-declaration :== + SEND option-decl | + DEFAULT option-decl | + SUPERSEDE option-decl | + PREPEND option-decl | + APPEND option-decl | + hardware-declaration | + REQUEST option-list | + REQUIRE option-list | + TIMEOUT number | + RETRY number | + REBOOT number | + SELECT_TIMEOUT number | + SCRIPT string | + interface-declaration | + LEASE client-lease-statement | + ALIAS client-lease-statement */ + +void parse_client_statement (cfile, ip, config) + FILE *cfile; + struct interface_info *ip; + struct client_config *config; +{ + int token; + char *val; + struct option *option; + + switch (next_token (&val, cfile)) { + case SEND: + parse_option_decl (cfile, &config -> send_options [0]); + return; + + case DEFAULT: + option = parse_option_decl (cfile, &config -> defaults [0]); + if (option) + config -> default_actions [option -> code] = + ACTION_DEFAULT; + return; + + case SUPERSEDE: + option = parse_option_decl (cfile, &config -> defaults [0]); + if (option) + config -> default_actions [option -> code] = + ACTION_SUPERSEDE; + return; + + case APPEND: + option = parse_option_decl (cfile, &config -> defaults [0]); + if (option) + config -> default_actions [option -> code] = + ACTION_APPEND; + return; + + case PREPEND: + option = parse_option_decl (cfile, &config -> defaults [0]); + if (option) + config -> default_actions [option -> code] = + ACTION_PREPEND; + return; + + case MEDIA: + parse_string_list (cfile, &config -> media, 1); + return; + + case HARDWARE: + if (ip) { + parse_hardware_param (cfile, &ip -> hw_address); + } else { + parse_warn ("hardware address parameter %s", + "not allowed here."); + skip_to_semi (cfile); + } + return; + + case REQUEST: + config -> requested_option_count = + parse_option_list (cfile, config -> requested_options); + return; + + case REQUIRE: + memset (config -> required_options, 0, + sizeof config -> required_options); + parse_option_list (cfile, config -> required_options); + return; + + case TIMEOUT: + parse_lease_time (cfile, &config -> timeout); + return; + + case RETRY: + parse_lease_time (cfile, &config -> retry_interval); + return; + + case SELECT_TIMEOUT: + parse_lease_time (cfile, &config -> select_interval); + return; + + case REBOOT: + parse_lease_time (cfile, &config -> reboot_timeout); + return; + + case BACKOFF_CUTOFF: + parse_lease_time (cfile, &config -> backoff_cutoff); + return; + + case INITIAL_INTERVAL: + parse_lease_time (cfile, &config -> initial_interval); + return; + + case SCRIPT: + config -> script_name = parse_string (cfile); + return; + + case INTERFACE: + if (ip) + parse_warn ("nested interface declaration."); + parse_interface_declaration (cfile, config); + return; + + case LEASE: + parse_client_lease_statement (cfile, 1); + return; + + case ALIAS: + parse_client_lease_statement (cfile, 2); + return; + + case REJECT: + parse_reject_statement (cfile, config); + return; + + default: + parse_warn ("expecting a statement."); + skip_to_semi (cfile); + break; + } + token = next_token (&val, cfile); + if (token != SEMI) { + parse_warn ("semicolon expected."); + skip_to_semi (cfile); + } +} + +int parse_X (cfile, buf, max) + FILE *cfile; + u_int8_t *buf; + int max; +{ + int token; + char *val; + int len; + u_int8_t *s; + + token = peek_token (&val, cfile); + if (token == NUMBER_OR_NAME || token == NUMBER) { + len = 0; + do { + token = next_token (&val, cfile); + if (token != NUMBER && token != NUMBER_OR_NAME) { + parse_warn ("expecting hexadecimal constant."); + skip_to_semi (cfile); + return 0; + } + convert_num (&buf [len], val, 16, 8); + if (len++ > max) { + parse_warn ("hexadecimal constant too long."); + skip_to_semi (cfile); + return 0; + } + token = peek_token (&val, cfile); + if (token == COLON) + token = next_token (&val, cfile); + } while (token == COLON); + val = (char *)buf; + } else if (token == STRING) { + token = next_token (&val, cfile); + len = strlen (val); + if (len + 1 > max) { + parse_warn ("string constant too long."); + skip_to_semi (cfile); + return 0; + } + memcpy (buf, val, len + 1); + } else { + parse_warn ("expecting string or hexadecimal data"); + skip_to_semi (cfile); + return 0; + } + return len; +} + +/* option-list :== option_name | + option_list COMMA option_name */ + +int parse_option_list (cfile, list) + FILE *cfile; + u_int8_t *list; +{ + int ix, i; + int token; + char *val; + + ix = 0; + do { + token = next_token (&val, cfile); + if (!is_identifier (token)) { + parse_warn ("expected option name."); + skip_to_semi (cfile); + return 0; + } + for (i = 0; i < 256; i++) { + if (!strcasecmp (dhcp_options [i].name, val)) + break; + } + if (i == 256) { + parse_warn ("%s: expected option name."); + skip_to_semi (cfile); + return 0; + } + list [ix++] = i; + if (ix == 256) { + parse_warn ("%s: too many options.", val); + skip_to_semi (cfile); + return 0; + } + token = next_token (&val, cfile); + } while (token == COMMA); + if (token != SEMI) { + parse_warn ("expecting semicolon."); + skip_to_semi (cfile); + return 0; + } + return ix; +} + +/* interface-declaration :== + INTERFACE string LBRACE client-declarations RBRACE */ + +void parse_interface_declaration (cfile, outer_config) + FILE *cfile; + struct client_config *outer_config; +{ + int token; + char *val; + + struct interface_info dummy_interface, *ip; + struct client_state dummy_state; + struct client_config dummy_config; + + token = next_token (&val, cfile); + if (token != STRING) { + parse_warn ("expecting interface name (in quotes)."); + skip_to_semi (cfile); + return; + } + + ip = interface_or_dummy (val); + + if (!ip -> client) + make_client_state (ip); + + if (!ip -> client -> config) + make_client_config (ip, outer_config); + + ip -> flags &= ~INTERFACE_AUTOMATIC; + interfaces_requested = 1; + + token = next_token (&val, cfile); + if (token != LBRACE) { + parse_warn ("expecting left brace."); + skip_to_semi (cfile); + return; + } + + do { + token = peek_token (&val, cfile); + if (token == EOF) { + parse_warn ("unterminated interface declaration."); + return; + } + if (token == RBRACE) + break; + parse_client_statement (cfile, ip, ip -> client -> config); + } while (1); + token = next_token (&val, cfile); +} + +struct interface_info *interface_or_dummy (name) + char *name; +{ + struct interface_info *ip; + + /* Find the interface (if any) that matches the name. */ + for (ip = interfaces; ip; ip = ip -> next) { + if (!strcmp (ip -> name, name)) + break; + } + + /* If it's not a real interface, see if it's on the dummy list. */ + if (!ip) { + for (ip = dummy_interfaces; ip; ip = ip -> next) { + if (!strcmp (ip -> name, name)) + break; + } + } + + /* If we didn't find an interface, make a dummy interface as + a placeholder. */ + if (!ip) { + ip = ((struct interface_info *)malloc (sizeof *ip)); + if (!ip) + error ("Insufficient memory to record interface %s", + name); + memset (ip, 0, sizeof *ip); + strcpy (ip -> name, name); + ip -> next = dummy_interfaces; + dummy_interfaces = ip; + } + return ip; +} + +void make_client_state (ip) + struct interface_info *ip; +{ + ip -> client = + ((struct client_state *)malloc (sizeof *(ip -> client))); + if (!ip -> client) + error ("no memory for state on %s\n", ip -> name); + memset (ip -> client, 0, sizeof *(ip -> client)); +} + +void make_client_config (ip, config) + struct interface_info *ip; + struct client_config *config; +{ + ip -> client -> config = + ((struct client_config *) + malloc (sizeof (struct client_config))); + if (!ip -> client -> config) + error ("no memory for config for %s\n", ip -> name); + memset (ip -> client -> config, 0, + sizeof *(ip -> client -> config)); + memcpy (ip -> client -> config, config, sizeof *config); +} + +/* client-lease-statement :== + RBRACE client-lease-declarations LBRACE + + client-lease-declarations :== + <nil> | + client-lease-declaration | + client-lease-declarations client-lease-declaration */ + + +void parse_client_lease_statement (cfile, is_static) + FILE *cfile; + int is_static; +{ + struct client_lease *lease, *lp, *pl; + struct interface_info *ip; + int token; + char *val; + + token = next_token (&val, cfile); + if (token != LBRACE) { + parse_warn ("expecting left brace."); + skip_to_semi (cfile); + return; + } + + lease = (struct client_lease *)malloc (sizeof (struct client_lease)); + if (!lease) + error ("no memory for lease.\n"); + memset (lease, 0, sizeof *lease); + lease -> is_static = is_static; + + ip = (struct interface_info *)0; + + do { + token = peek_token (&val, cfile); + if (token == EOF) { + parse_warn ("unterminated lease declaration."); + return; + } + if (token == RBRACE) + break; + parse_client_lease_declaration (cfile, lease, &ip); + } while (1); + token = next_token (&val, cfile); + + /* If the lease declaration didn't include an interface + declaration that we recognized, it's of no use to us. */ + if (!ip) { + free_client_lease (lease); + return; + } + + /* Make sure there's a client state structure... */ + if (!ip -> client) + make_client_state (ip); + + /* If this is an alias lease, it doesn't need to be sorted in. */ + if (is_static == 2) { + ip -> client -> alias = lease; + return; + } + + /* The new lease may supersede a lease that's not the + active lease but is still on the lease list, so scan the + lease list looking for a lease with the same address, and + if we find it, toss it. */ + pl = (struct client_lease *)0; + for (lp = ip -> client -> leases; lp; lp = lp -> next) { + if (lp -> address.len == lease -> address.len && + !memcmp (lp -> address.iabuf, lease -> address.iabuf, + lease -> address.len)) { + if (pl) + pl -> next = lp -> next; + else + ip -> client -> leases = lp -> next; + free_client_lease (lp); + break; + } + } + + /* If this is a preloaded lease, just put it on the list of recorded + leases - don't make it the active lease. */ + if (is_static) { + lease -> next = ip -> client -> leases; + ip -> client -> leases = lease; + return; + } + + /* The last lease in the lease file on a particular interface is + the active lease for that interface. Of course, we don't know + what the last lease in the file is until we've parsed the whole + file, so at this point, we assume that the lease we just parsed + is the active lease for its interface. If there's already + an active lease for the interface, and this lease is for the same + ip address, then we just toss the old active lease and replace + it with this one. If this lease is for a different address, + then if the old active lease has expired, we dump it; if not, + we put it on the list of leases for this interface which are + still valid but no longer active. */ + if (ip -> client -> active) { + if (ip -> client -> active -> expiry < cur_time) + free_client_lease (ip -> client -> active); + else if (ip -> client -> active -> address.len == + lease -> address.len && + !memcmp (ip -> client -> active -> address.iabuf, + lease -> address.iabuf, + lease -> address.len)) + free_client_lease (ip -> client -> active); + else { + ip -> client -> active -> next = + ip -> client -> leases; + ip -> client -> leases = ip -> client -> active; + } + } + ip -> client -> active = lease; + + /* phew. */ +} + +/* client-lease-declaration :== + BOOTP | + INTERFACE string | + FIXED_ADDR ip_address | + FILENAME string | + SERVER_NAME string | + OPTION option-decl | + RENEW time-decl | + REBIND time-decl | + EXPIRE time-decl */ + +void parse_client_lease_declaration (cfile, lease, ipp) + FILE *cfile; + struct client_lease *lease; + struct interface_info **ipp; +{ + int token; + char *val; + char *t, *n; + struct interface_info *ip; + + switch (next_token (&val, cfile)) { + case BOOTP: + lease -> is_bootp = 1; + break; + + case INTERFACE: + token = next_token (&val, cfile); + if (token != STRING) { + parse_warn ("expecting interface name (in quotes)."); + skip_to_semi (cfile); + break; + } + ip = interface_or_dummy (val); + *ipp = ip; + break; + + case FIXED_ADDR: + if (!parse_ip_addr (cfile, &lease -> address)) + return; + break; + + case MEDIUM: + parse_string_list (cfile, &lease -> medium, 0); + return; + + case FILENAME: + lease -> filename = parse_string (cfile); + return; + + case SERVER_NAME: + lease -> server_name = parse_string (cfile); + return; + + case RENEW: + lease -> renewal = parse_date (cfile); + return; + + case REBIND: + lease -> rebind = parse_date (cfile); + return; + + case EXPIRE: + lease -> expiry = parse_date (cfile); + return; + + case OPTION: + parse_option_decl (cfile, lease -> options); + return; + + default: + parse_warn ("expecting lease declaration."); + skip_to_semi (cfile); + break; + } + token = next_token (&val, cfile); + if (token != SEMI) { + parse_warn ("expecting semicolon."); + skip_to_semi (cfile); + } +} + +struct option *parse_option_decl (cfile, options) + FILE *cfile; + struct option_data *options; +{ + char *val; + int token; + u_int8_t buf [4]; + u_int8_t hunkbuf [1024]; + int hunkix = 0; + char *vendor; + char *fmt; + struct universe *universe; + struct option *option; + struct iaddr ip_addr; + u_int8_t *dp; + int len; + int nul_term = 0; + + token = next_token (&val, cfile); + if (!is_identifier (token)) { + parse_warn ("expecting identifier after option keyword."); + if (token != SEMI) + skip_to_semi (cfile); + return (struct option *)0; + } + vendor = malloc (strlen (val) + 1); + if (!vendor) + error ("no memory for vendor information."); + strcpy (vendor, val); + token = peek_token (&val, cfile); + if (token == DOT) { + /* Go ahead and take the DOT token... */ + token = next_token (&val, cfile); + + /* The next token should be an identifier... */ + token = next_token (&val, cfile); + if (!is_identifier (token)) { + parse_warn ("expecting identifier after '.'"); + if (token != SEMI) + skip_to_semi (cfile); + return (struct option *)0; + } + + /* Look up the option name hash table for the specified + vendor. */ + universe = ((struct universe *) + hash_lookup (&universe_hash, + (unsigned char *)vendor, 0)); + /* If it's not there, we can't parse the rest of the + declaration. */ + if (!universe) { + parse_warn ("no vendor named %s.", vendor); + skip_to_semi (cfile); + return (struct option *)0; + } + } else { + /* Use the default hash table, which contains all the + standard dhcp option names. */ + val = vendor; + universe = &dhcp_universe; + } + + /* Look up the actual option info... */ + option = (struct option *)hash_lookup (universe -> hash, + (unsigned char *)val, 0); + + /* If we didn't get an option structure, it's an undefined option. */ + if (!option) { + if (val == vendor) + parse_warn ("no option named %s", val); + else + parse_warn ("no option named %s for vendor %s", + val, vendor); + skip_to_semi (cfile); + return (struct option *)0; + } + + /* Free the initial identifier token. */ + free (vendor); + + /* Parse the option data... */ + do { + /* Set a flag if this is an array of a simple type (i.e., + not an array of pairs of IP addresses, or something + like that. */ + int uniform = option -> format [1] == 'A'; + + for (fmt = option -> format; *fmt; fmt++) { + if (*fmt == 'A') + break; + switch (*fmt) { + case 'X': + len = parse_X (cfile, &hunkbuf [hunkix], + sizeof hunkbuf - hunkix); + hunkix += len; + break; + + case 't': /* Text string... */ + token = next_token (&val, cfile); + if (token != STRING) { + parse_warn ("expecting string."); + skip_to_semi (cfile); + return (struct option *)0; + } + len = strlen (val); + if (hunkix + len + 1 > sizeof hunkbuf) { + parse_warn ("option data buffer %s", + "overflow"); + skip_to_semi (cfile); + return (struct option *)0; + } + memcpy (&hunkbuf [hunkix], val, len + 1); + nul_term = 1; + hunkix += len; + break; + + case 'I': /* IP address. */ + if (!parse_ip_addr (cfile, &ip_addr)) + return (struct option *)0; + len = ip_addr.len; + dp = ip_addr.iabuf; + + alloc: + if (hunkix + len > sizeof hunkbuf) { + parse_warn ("option data buffer %s", + "overflow"); + skip_to_semi (cfile); + return (struct option *)0; + } + memcpy (&hunkbuf [hunkix], dp, len); + hunkix += len; + break; + + case 'L': /* Unsigned 32-bit integer... */ + case 'l': /* Signed 32-bit integer... */ + token = next_token (&val, cfile); + if (token != NUMBER) { + need_number: + parse_warn ("expecting number."); + if (token != SEMI) + skip_to_semi (cfile); + return (struct option *)0; + } + convert_num (buf, val, 0, 32); + len = 4; + dp = buf; + goto alloc; + + case 's': /* Signed 16-bit integer. */ + case 'S': /* Unsigned 16-bit integer. */ + token = next_token (&val, cfile); + if (token != NUMBER) + goto need_number; + convert_num (buf, val, 0, 16); + len = 2; + dp = buf; + goto alloc; + + case 'b': /* Signed 8-bit integer. */ + case 'B': /* Unsigned 8-bit integer. */ + token = next_token (&val, cfile); + if (token != NUMBER) + goto need_number; + convert_num (buf, val, 0, 8); + len = 1; + dp = buf; + goto alloc; + + case 'f': /* Boolean flag. */ + token = next_token (&val, cfile); + if (!is_identifier (token)) { + parse_warn ("expecting identifier."); + bad_flag: + if (token != SEMI) + skip_to_semi (cfile); + return (struct option *)0; + } + if (!strcasecmp (val, "true") + || !strcasecmp (val, "on")) + buf [0] = 1; + else if (!strcasecmp (val, "false") + || !strcasecmp (val, "off")) + buf [0] = 0; + else { + parse_warn ("expecting boolean."); + goto bad_flag; + } + len = 1; + dp = buf; + goto alloc; + + default: + warn ("Bad format %c in parse_option_param.", + *fmt); + skip_to_semi (cfile); + return (struct option *)0; + } + } + token = next_token (&val, cfile); + } while (*fmt == 'A' && token == COMMA); + + if (token != SEMI) { + parse_warn ("semicolon expected."); + skip_to_semi (cfile); + return (struct option *)0; + } + + options [option -> code].data = + (unsigned char *)malloc (hunkix + nul_term); + if (!options [option -> code].data) + error ("out of memory allocating option data."); + memcpy (options [option -> code].data, hunkbuf, hunkix + nul_term); + options [option -> code].len = hunkix; + return option; +} + +void parse_string_list (cfile, lp, multiple) + FILE *cfile; + struct string_list **lp; + int multiple; +{ + int token; + char *val; + struct string_list *cur, *tmp; + + /* Find the last medium in the media list. */ + if (*lp) { + for (cur = *lp; cur -> next; cur = cur -> next) + ; + } else { + cur = (struct string_list *)0; + } + + do { + token = next_token (&val, cfile); + if (token != STRING) { + parse_warn ("Expecting media options."); + skip_to_semi (cfile); + return; + } + + tmp = (struct string_list *)malloc (strlen (val) + 1 + + sizeof + (struct string_list *)); + if (!tmp) + error ("no memory for string list entry."); + + strcpy (tmp -> string, val); + tmp -> next = (struct string_list *)0; + + /* Store this medium at the end of the media list. */ + if (cur) + cur -> next = tmp; + else + *lp = tmp; + cur = tmp; + + token = next_token (&val, cfile); + } while (multiple && token == COMMA); + + if (token != SEMI) { + parse_warn ("expecting semicolon."); + skip_to_semi (cfile); + } +} + +void parse_reject_statement (cfile, config) + FILE *cfile; + struct client_config *config; +{ + int token; + char *val; + struct iaddr addr; + struct iaddrlist *list; + + do { + if (!parse_ip_addr (cfile, &addr)) { + parse_warn ("expecting IP address."); + skip_to_semi (cfile); + return; + } + + list = (struct iaddrlist *)malloc (sizeof (struct iaddrlist)); + if (!list) + error ("no memory for reject list!"); + + list -> addr = addr; + list -> next = config -> reject_list; + config -> reject_list = list; + + token = next_token (&val, cfile); + } while (token == COMMA); + + if (token != SEMI) { + parse_warn ("expecting semicolon."); + skip_to_semi (cfile); + } +} diff --git a/contrib/isc-dhcp/client/dhclient-script.8 b/contrib/isc-dhcp/client/dhclient-script.8 new file mode 100644 index 000000000000..1a1d78b9d5b4 --- /dev/null +++ b/contrib/isc-dhcp/client/dhclient-script.8 @@ -0,0 +1,190 @@ +.\" dhclient-script.8 +.\" +.\" Copyright (c) 1997 The Internet Software Consortium. +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" 3. Neither the name of The Internet Software Consortium nor the names +.\" of its contributors may be used to endorse or promote products derived +.\" from this software without specific prior written permission. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND +.\" CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, +.\" INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +.\" MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +.\" DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR +.\" CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +.\" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +.\" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF +.\" USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +.\" ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +.\" OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT +.\" OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" This software has been written for the Internet Software Consortium +.\" by Ted Lemon <mellon@fugue.com> in cooperation with Vixie +.\" Enterprises. To learn more about the Internet Software Consortium, +.\" see ``http://www.isc.org/isc''. To learn more about Vixie +.\" Enterprises, see ``http://www.vix.com''. +.TH dhclient 8 +.SH NAME +dhclient-script - DHCP client network configuration script +.SH DESCRIPTION +The DHCP client network configuration script is invoked from time to +time by \fBdhclient(8)\fR. This script is used by the dhcp client to +set each interface's initial configuration prior to requesting an +address, to test the address once it has been offered, and to set the +interface's final configuration once a lease has been acquired. If no +lease is acquired, the script is used to test predefined leases, if +any, and also called once if no valid lease can be identified. +.PP +This script is not meant to be customized by the end user. However, +the script may not work on particular versions of particular operating +systems (indeed, no standard script exists for some operating +systems), so a pioneering user may well need to create a new script or +modify an existing one. In general, customizations specific to a +particular computer should be done in the +.B /etc/dhclient.conf +script. If you find that you can't make such a customization without +customizing dhclient.conf, please submit a bug report. +.SH OPERATION +When dhclient needs to invoke the client configuration script, it +writes a shell script into /tmp which defines a variety of variables. +In all cases, $reason is set to the name of the reason why the script +has been invoked. The following reasons are currently defined: +MEDIUM, PREINIT, ARPCHECK, ARPSEND, BOUND, RENEW, REBIND, REBOOT, +EXPIRE, FAIL and TIMEOUT. +.PP +.SH MEDIUM +The DHCP client is requesting that an interface's media type +be set. The interface name is passed in $interface, and the media +type is passed in $medium. +.SH PREINIT +The DHCP client is requesting that an interface be configured as +required in order to send packets prior to receiving an actual +address. For clients which use the BSD socket library, this means +configuring the interface with an IP address of 0.0.0.0 and a +broadcast address of 255.255.255.255. For other clients, it may be +possible to simply configure the interface up without actually giving +it an IP address at all. The interface name is passed in $interface, +and the media type in $medium. +.PP +If an IP alias has been declared in dhclient.conf, its address will be +passed in $alias_ip_address, and that ip alias should be deleted from +the interface, along with any routes to it. +.SH ARPSEND +The DHCP client is requesting that an address that has been offered to +it be checked to see if somebody else is using it, by sending an ARP +request for that address. It's not clear how to implement this, so +no examples exist yet. The IP address to check is passed in +$new_ip_address, and the interface name is passed in $interface. +.SH ARPCHECK +The DHCP client wants to know if a response to the ARP request send +using ARPCHECK has been received. If one has, the script should exit +with a nonzero status, indicating that the offered address has already +been requested and should be declined. $new_ip_address and +$interface are set as with ARPSEND. +.SH BOUND +The DHCP client has done an initial binding to a new address. The +new ip address is passed in $new_ip_address, and the interface name is +passed in $interface. The media type is passed in $medium. Any +options acquired from the server are passed using the option name +described in \fBdhcp-options\fR, except that dashes ('-') are replaced +by underscores ('_') in order to make valid shell variables, and the +variable names start with new_. So for example, the new subnet mask +would be passed in $new_subnet_mask. +.PP +When a binding has been completed, a lot of network parameters are +likely to need to be set up. A new /etc/resolv.conf needs to be +created, using the values of $new_domain_name and +$new_domain_name_servers (which may list more than one server, +seperated by spaces). A default route should be set using +$new_routers, and static routes may need to be set up using +$new_static_routes. +.PP +If an IP alias has been declared, it must be set up here. The alias +IP address will be written as $alias_ip_address, and other DHCP +options that are set for the alias (e.g., subnet mask) will be passed +in variables named as described previously except starting with +$alias_ instead of $new_. Care should be taken that the alias IP +address not be used if it is identical to the bound IP address +($new_ip_address), since the other alias parameters may be incorrect +in this case. +.SH RENEW +When a binding has been renewed, the script is called as in BOUND, +except that in addition to all the variables starting with $new_, +there is another set of variables starting with $old_. Persistent +settings that may have changed need to be deleted - for example, if a +local route to the bound address is being configured, the old local +route should be deleted. If the default route has changed, the old default +route should be deleted. If the static routes have changed, the old +ones should be deleted. Otherwise, processing can be done as with +BOUND. +.SH REBIND +The DHCP client has rebound to a new DHCP server. This can be handled +as with RENEW, except that if the IP address has changed, the ARP +table should be cleared. +.SH REBOOT +The DHCP client has successfully reacquired its old address after a +reboot. This can be processed as with BOUND. +.SH EXPIRE +The DHCP client has failed to renew its lease or acquire a new one, +and the lease has expired. The IP address must be relinquished, and +all related parameters should be deleted, as in RENEW and REBIND. +.SH FAIL +The DHCP client has been unable to contact any DHCP servers, and any +leases that have been tested have not proved to be valid. The +parameters from the last lease tested should be deconfigured. This +can be handled in the same way as EXPIRE. +.SH TIMEOUT +The DHCP client has been unable to contact any DHCP servers. +However, an old lease has been identified, and its parameters have +been passed in as with BOUND. The client configuration script should +test these parameters and, if it has reason to believe they are valid, +should exit with a value of zero. If not, it should exit with a +nonzero value. +.PP +The usual way to test a lease is to set up the network as with REBIND +(since this may be called to test more than one lease) and then ping +the first router defined in $routers. If a response is received, the +lease must be valid for the network to which the interface is +currently connected. It would be more complete to try to ping all of +the routers listed in $new_routers, as well as those listed in +$new_static_routes, but current scripts do not do this. +.SH FILES +Each operating system should generally have its own script file, +although the script files for similar operating systems may be similar +or even identical. The script files included in the Internet +Software Consortium DHCP distribution appear in the distribution tree +under client/scripts, and bear the names of the operating systems on +which they are intended to work. +.SH BUGS +If more than one interface is being used, there's no obvious way to +avoid clashes between server-supplied configuration parameters - for +example, the stock dhclient-script rewrites /etc/resolv.conf. If +more than one interface is being configured, /etc/resolv.conf will be +repeatedly initialized to the values provided by one server, and then +the other. Assuming the information provided by both servers is +valid, this shouldn't cause any real problems, but it could be +confusing. +.SH SEE ALSO +dhclient.conf(5), dhclient.leases(5), dhclient(8) +.SH AUTHOR +.B dhclient-script(8) +has been written for the Internet Software Consortium +by Ted Lemon <mellon@fugue.com> in cooperation with Vixie +Enterprises. To learn more about the Internet Software Consortium, +see +.B http://www.vix.com/isc. +To learn more about Vixie +Enterprises, see +.B http://www.vix.com. diff --git a/contrib/isc-dhcp/client/dhclient.8 b/contrib/isc-dhcp/client/dhclient.8 new file mode 100644 index 000000000000..a6f2d5512b08 --- /dev/null +++ b/contrib/isc-dhcp/client/dhclient.8 @@ -0,0 +1,169 @@ +.\" dhclient.8 +.\" +.\" Copyright (c) 1997 The Internet Software Consortium. +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" 3. Neither the name of The Internet Software Consortium nor the names +.\" of its contributors may be used to endorse or promote products derived +.\" from this software without specific prior written permission. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND +.\" CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, +.\" INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +.\" MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +.\" DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR +.\" CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +.\" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +.\" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF +.\" USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +.\" ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +.\" OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT +.\" OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" This software has been written for the Internet Software Consortium +.\" by Ted Lemon <mellon@fugue.com> in cooperation with Vixie +.\" Enterprises. To learn more about the Internet Software Consortium, +.\" see ``http://www.isc.org/isc''. To learn more about Vixie +.\" Enterprises, see ``http://www.vix.com''. +.TH dhclient 8 +.SH NAME +dhclient - Dynamic Host Configuration Protocol Client +.SH SYNOPSIS +.B dhclient +[ +.B -p +.I port +] +[ +.B -1 +] +[ +.B -d +] +[ +.I if0 +[ +.I ...ifN +] +] +.SH DESCRIPTION +The Internet Software Consortium DHCP Client, dhclient, provides a +means for configuring one or more network interfaces using the Dynamic +Host Configuration Protocol, BOOTP protocol, or if these protocols +fail, by statically assigning an address. +.SH OPERATION +.PP +The DHCP protocol allows a host to contact a central server which +maintains a list of IP addresses which may be assigned on one or more +subnets. A DHCP client may request an address from this pool, and +then use it on a temporary basis for communication on network. The +DHCP protocol also provides a mechanism whereby a client can learn +important details about the network to which it is attached, such as +the location of a default router, the location of a name server, and +so on. +.PP +On startup, dhclient reads the +.IR dhclient.conf +for configuration instructions. It then gets a list of all the +network interfaces that are configured in the current system. For +each interface, it attempts to configure the interface using the DHCP +protocol. +.PP +In order to keep track of leases across system reboots and server +restarts, dhclient keeps a list of leases it has been assigned in the +dhclient.leases(5) file. On startup, after reading the dhclient.conf +file, dhclient reads the dhclient.leases file to refresh its memory +about what leases it has been assigned. +.PP +When a new lease is acquired, it is appended to the end of the +dhclient.leases file. In order to prevent the file from becoming +arbitrarily large, from time to time dhclient creates a new +dhclient.leases file from its in-core lease database. The old version +of the dhclient.leases file is retained under the name +.IR dhcpd.leases~ +until the next time dhclient rewrites the database. +.PP +Old leases are kept around in case the DHCP server is unavailable when +dhclient is first invoked (generally during the initial system boot +process). In that event, old leases from the dhclient.leases file +which have not yet expired are tested, and if they are determined to +be valid, they are used until either they expire or the DHCP server +becomes available. +.PP +A mobile host which may sometimes need to access a network on which no +DHCP server exists may be preloaded with a lease for a fixed +address on that network. When all attempts to contact a DHCP server +have failed, dhclient will try to validate the static lease, and if it +succeeds, will use that lease until it is restarted. +.PP +A mobile host may also travel to some networks on which DHCP is not +available but BOOTP is. In that case, it may be advantageous to +arrange with the network administrator for an entry on the BOOTP +database, so that the host can boot quickly on that network rather +than cycling through the list of old leases. +.SH COMMAND LINE +.PP +The names of the network interfaces that dhclient should attempt to +configure may be specified on the command line. If no interface names +are specified on the command line dhclient will identify all network +interfaces, elimininating non-broadcast interfaces if possible, and +attempt to configure each interface. +.PP +If dhclient should listen and transmit on a port other than the +standard (port 68), the +.B -p +flag may used. It should be followed by the udp port number that +dhclient should use. This is mostly useful for debugging purposes. +.PP +Dhclient will normally run in the foreground until it has configured +an interface, and then will revert to running in the background. +To run force dhclient to always run as a foreground process, the +.B -d +flag should be specified. This is useful when running dhclient under +a debugger, or when running it out of inittab on System V systems. +The +.B -1 +flag cause dhclient to try once to get a lease. If it fails, dhclient exits. +.PP +.SH CONFIGURATION +The syntax of the dhclient.conf(8) file is discussed seperately. +.SH FILES +.B /etc/dhclient.conf, /var/db/dhclient.leases, /var/run/dhclient.pid, +.B /var/db/dhclient.leases~. +.SH SEE ALSO +dhclient.conf(5), dhclient.leases(5), dhclient-script(8) +.SH AUTHOR +.B dhclient(8) +has been written for the Internet Software Consortium +by Ted Lemon <mellon@fugue.com> in cooperation with Vixie +Enterprises. To learn more about the Internet Software Consortium, +see +.B http://www.vix.com/isc. +To learn more about Vixie +Enterprises, see +.B http://www.vix.com. +.PP +This client was substantially modified and enhanced by Elliot Poger +for use on Linux while he was working on the MosquitoNet project at +Stanford. +.PP +The current version owes much to Elliot's Linux enhancements, but +was substantially reorganized and partially rewritten by Ted Lemon +so as to use the same networking framework that the Internet Software +Consortium DHCP server uses. Much system-specific configuration code +was moved into a shell script so that as support for more operating +systems is added, it will not be necessary to port and maintain +system-specific configuration code to these operating systems - instead, +the shell script can invoke the native tools to accomplish the same +purpose. +.PP diff --git a/contrib/isc-dhcp/client/dhclient.c b/contrib/isc-dhcp/client/dhclient.c new file mode 100644 index 000000000000..f5f8eb78fd27 --- /dev/null +++ b/contrib/isc-dhcp/client/dhclient.c @@ -0,0 +1,2128 @@ +/* dhclient.c + + DHCP Client. */ + +/* + * Copyright (c) 1995, 1996, 1997, 1998, 1999 + * The Internet Software Consortium. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of The Internet Software Consortium nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND + * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This software has been written for the Internet Software Consortium + * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie + * Enterprises. To learn more about the Internet Software Consortium, + * see ``http://www.vix.com/isc''. To learn more about Vixie + * Enterprises, see ``http://www.vix.com''. + * + * This client was substantially modified and enhanced by Elliot Poger + * for use on Linux while he was working on the MosquitoNet project at + * Stanford. + * + * The current version owes much to Elliot's Linux enhancements, but + * was substantially reorganized and partially rewritten by Ted Lemon + * so as to use the same networking framework that the Internet Software + * Consortium DHCP server uses. Much system-specific configuration code + * was moved into a shell script so that as support for more operating + * systems is added, it will not be necessary to port and maintain + * system-specific configuration code to these operating systems - instead, + * the shell script can invoke the native tools to accomplish the same + * purpose. + */ + +#ifndef lint +static char ocopyright[] = +"$Id: dhclient.c,v 1.44.2.14 1999/02/09 04:59:50 mellon Exp $ Copyright (c) 1995, 1996, 1997, 1998, 1999 The Internet Software Consortium. All rights reserved.\n"; +#endif /* not lint */ + +#include "dhcpd.h" + +TIME cur_time; +TIME default_lease_time = 43200; /* 12 hours... */ +TIME max_lease_time = 86400; /* 24 hours... */ +struct tree_cache *global_options [256]; + +char *path_dhclient_conf = _PATH_DHCLIENT_CONF; +char *path_dhclient_db = _PATH_DHCLIENT_DB; +char *path_dhclient_pid = _PATH_DHCLIENT_PID; + +int interfaces_requested = 0; + +int log_perror = 1; + +struct iaddr iaddr_broadcast = { 4, { 255, 255, 255, 255 } }; +struct iaddr iaddr_any = { 4, { 0, 0, 0, 0 } }; +struct in_addr inaddr_any; +struct sockaddr_in sockaddr_broadcast; + +/* ASSERT_STATE() does nothing now; it used to be + assert (state_is == state_shouldbe). */ +#define ASSERT_STATE(state_is, state_shouldbe) {} + +u_int16_t local_port; +u_int16_t remote_port; +int log_priority; +int no_daemon; +int save_scripts; +int onetry; + +static char copyright[] = +"Copyright 1995, 1996, 1997, 1998, 1999 The Internet Software Consortium."; +static char arr [] = "All rights reserved."; +static char message [] = "Internet Software Consortium DHCP Client V2.0b1pl11"; +static char contrib [] = "\nPlease contribute if you find this software useful."; +static char url [] = "For info, please visit http://www.isc.org/dhcp-contrib.html\n"; + +static void usage PROTO ((void)); + +int main (argc, argv, envp) + int argc; + char **argv, **envp; +{ + int i; + struct servent *ent; + struct interface_info *ip; + int seed; + int quiet; + +#ifdef SYSLOG_4_2 + openlog ("dhclient", LOG_NDELAY); + log_priority = LOG_DAEMON; +#else + openlog ("dhclient", LOG_NDELAY, LOG_DAEMON); +#endif + +#if !(defined (DEBUG) || defined (SYSLOG_4_2) || defined (__CYGWIN32__)) + setlogmask (LOG_UPTO (LOG_INFO)); +#endif + + for (i = 1; i < argc; i++) { + if (!strcmp (argv [i], "-p")) { + if (++i == argc) + usage (); + local_port = htons (atoi (argv [i])); + debug ("binding to user-specified port %d", + ntohs (local_port)); + } else if (!strcmp (argv [i], "-d")) { + no_daemon = 1; + } else if (!strcmp (argv [i], "-D")) { + save_scripts = 1; + } else if (!strcmp (argv [i], "-1")) { + onetry = 1; + } else if (!strcmp (argv [i], "-lf")) { + if (++i == argc) + usage (); + path_dhclient_db = argv [i]; + } else if (!strcmp (argv [i], "-q")) { + quiet = 1; + quiet_interface_discovery = 1; + } else if (argv [i][0] == '-') { + usage (); + } else { + struct interface_info *tmp = + ((struct interface_info *) + dmalloc (sizeof *tmp, "specified_interface")); + if (!tmp) + error ("Insufficient memory to %s %s", + "record interface", argv [i]); + memset (tmp, 0, sizeof *tmp); + strcpy (tmp -> name, argv [i]); + tmp -> next = interfaces; + tmp -> flags = INTERFACE_REQUESTED; + interfaces_requested = 1; + interfaces = tmp; + } + } + + if (!quiet) { + note (message); + note (copyright); + note (arr); + note (contrib); + note (url); + } + + /* Default to the DHCP/BOOTP port. */ + if (!local_port) { + ent = getservbyname ("dhcpc", "udp"); + if (!ent) + local_port = htons (68); + else + local_port = ent -> s_port; +#ifndef __CYGWIN32__ + endservent (); +#endif + } + remote_port = htons (ntohs (local_port) - 1); /* XXX */ + + /* Get the current time... */ + GET_TIME (&cur_time); + + sockaddr_broadcast.sin_family = AF_INET; + sockaddr_broadcast.sin_port = remote_port; + sockaddr_broadcast.sin_addr.s_addr = INADDR_BROADCAST; +#ifdef HAVE_SA_LEN + sockaddr_broadcast.sin_len = sizeof sockaddr_broadcast; +#endif + inaddr_any.s_addr = INADDR_ANY; + + /* Discover all the network interfaces. */ + discover_interfaces (DISCOVER_UNCONFIGURED); + + /* Parse the dhclient.conf file. */ + read_client_conf (); + + /* Parse the lease database. */ + read_client_leases (); + + /* Rewrite the lease database... */ + rewrite_client_leases (); + + /* If no broadcast interfaces were discovered, call the script + and tell it so. */ + if (!interfaces) { + script_init ((struct interface_info *)0, "NBI", + (struct string_list *)0); + script_go ((struct interface_info *)0); + + note ("No broadcast interfaces found - exiting."); + /* Nothing more to do. */ + exit (0); + } else { + /* Call the script with the list of interfaces. */ + for (ip = interfaces; ip; ip = ip -> next) { + /* If interfaces were specified, don't configure + interfaces that weren't specified! */ + if (interfaces_requested && + ((ip -> flags & (INTERFACE_REQUESTED | + INTERFACE_AUTOMATIC)) != + INTERFACE_REQUESTED)) + continue; + script_init (ip, "PREINIT", (struct string_list *)0); + if (ip -> client -> alias) + script_write_params (ip, "alias_", + ip -> client -> alias); + script_go (ip); + } + } + + /* At this point, all the interfaces that the script thinks + are relevant should be running, so now we once again call + discover_interfaces(), and this time ask it to actually set + up the interfaces. */ + discover_interfaces (interfaces_requested + ? DISCOVER_REQUESTED + : DISCOVER_RUNNING); + + /* Make up a seed for the random number generator from current + time plus the sum of the last four bytes of each + interface's hardware address interpreted as an integer. + Not much entropy, but we're booting, so we're not likely to + find anything better. */ + seed = 0; /* Unfortunately, what's on the stack isn't random. :') */ + for (ip = interfaces; ip; ip = ip -> next) { + int junk; + memcpy (&junk, + &ip -> hw_address.haddr [ip -> hw_address.hlen - + sizeof seed], sizeof seed); + seed += junk; + } + srandom (seed + cur_time); + + /* Start a configuration state machine for each interface. */ + for (ip = interfaces; ip; ip = ip -> next) { + ip -> client -> state = S_INIT; + state_reboot (ip); + } + + /* Set up the bootp packet handler... */ + bootp_packet_handler = do_packet; + + /* Start dispatching packets and timeouts... */ + dispatch (); + + /*NOTREACHED*/ + return 0; +} + +static void usage () +{ + error ("Usage: dhclient [-1] [-c] [-p <port>] [-lf lease-file] [interface]"); +} + +void cleanup () +{ +} + +/* Individual States: + * + * Each routine is called from the dhclient_state_machine() in one of + * these conditions: + * -> entering INIT state + * -> recvpacket_flag == 0: timeout in this state + * -> otherwise: received a packet in this state + * + * Return conditions as handled by dhclient_state_machine(): + * Returns 1, sendpacket_flag = 1: send packet, reset timer. + * Returns 1, sendpacket_flag = 0: just reset the timer (wait for a milestone). + * Returns 0: finish the nap which was interrupted for no good reason. + * + * Several per-interface variables are used to keep track of the process: + * active_lease: the lease that is being used on the interface + * (null pointer if not configured yet). + * offered_leases: leases corresponding to DHCPOFFER messages that have + * been sent to us by DHCP servers. + * acked_leases: leases corresponding to DHCPACK messages that have been + * sent to us by DHCP servers. + * sendpacket: DHCP packet we're trying to send. + * destination: IP address to send sendpacket to + * In addition, there are several relevant per-lease variables. + * T1_expiry, T2_expiry, lease_expiry: lease milestones + * In the active lease, these control the process of renewing the lease; + * In leases on the acked_leases list, this simply determines when we + * can no longer legitimately use the lease. + */ + +void state_reboot (ipp) + void *ipp; +{ + struct interface_info *ip = ipp; + + /* If we don't remember an active lease, go straight to INIT. */ + if (!ip -> client -> active || + ip -> client -> active -> is_bootp) { + state_init (ip); + return; + } + + /* We are in the rebooting state. */ + ip -> client -> state = S_REBOOTING; + + /* make_request doesn't initialize xid because it normally comes + from the DHCPDISCOVER, but we haven't sent a DHCPDISCOVER, + so pick an xid now. */ + ip -> client -> xid = random (); + + /* Make a DHCPREQUEST packet, and set appropriate per-interface + flags. */ + make_request (ip, ip -> client -> active); + ip -> client -> destination = iaddr_broadcast; + ip -> client -> first_sending = cur_time; + ip -> client -> interval = ip -> client -> config -> initial_interval; + + /* Zap the medium list... */ + ip -> client -> medium = (struct string_list *)0; + + /* Send out the first DHCPREQUEST packet. */ + send_request (ip); +} + +/* Called when a lease has completely expired and we've been unable to + renew it. */ + +void state_init (ipp) + void *ipp; +{ + struct interface_info *ip = ipp; + + ASSERT_STATE(state, S_INIT); + + /* Make a DHCPDISCOVER packet, and set appropriate per-interface + flags. */ + make_discover (ip, ip -> client -> active); + ip -> client -> xid = ip -> client -> packet.xid; + ip -> client -> destination = iaddr_broadcast; + ip -> client -> state = S_SELECTING; + ip -> client -> first_sending = cur_time; + ip -> client -> interval = ip -> client -> config -> initial_interval; + + /* Add an immediate timeout to cause the first DHCPDISCOVER packet + to go out. */ + send_discover (ip); +} + +/* state_selecting is called when one or more DHCPOFFER packets have been + received and a configurable period of time has passed. */ + +void state_selecting (ipp) + void *ipp; +{ + struct interface_info *ip = ipp; + + struct client_lease *lp, *next, *picked; + + ASSERT_STATE(state, S_SELECTING); + + /* Cancel state_selecting and send_discover timeouts, since either + one could have got us here. */ + cancel_timeout (state_selecting, ip); + cancel_timeout (send_discover, ip); + + /* We have received one or more DHCPOFFER packets. Currently, + the only criterion by which we judge leases is whether or + not we get a response when we arp for them. */ + picked = (struct client_lease *)0; + for (lp = ip -> client -> offered_leases; lp; lp = next) { + next = lp -> next; + + /* Check to see if we got an ARPREPLY for the address + in this particular lease. */ + if (!picked) { + script_init (ip, "ARPCHECK", lp -> medium); + script_write_params (ip, "check_", lp); + + /* If the ARPCHECK code detects another + machine using the offered address, it exits + nonzero. We need to send a DHCPDECLINE and + toss the lease. */ + if (script_go (ip)) { + make_decline (ip, lp); + send_decline (ip); + goto freeit; + } + picked = lp; + picked -> next = (struct client_lease *)0; + } else { + freeit: + free_client_lease (lp); + } + } + ip -> client -> offered_leases = (struct client_lease *)0; + + /* If we just tossed all the leases we were offered, go back + to square one. */ + if (!picked) { + ip -> client -> state = S_INIT; + state_init (ip); + return; + } + + /* If it was a BOOTREPLY, we can just take the address right now. */ + if (!picked -> options [DHO_DHCP_MESSAGE_TYPE].len) { + ip -> client -> new = picked; + + /* Make up some lease expiry times + XXX these should be configurable. */ + ip -> client -> new -> expiry = cur_time + 12000; + ip -> client -> new -> renewal += cur_time + 8000; + ip -> client -> new -> rebind += cur_time + 10000; + + ip -> client -> state = S_REQUESTING; + + /* Bind to the address we received. */ + bind_lease (ip); + return; + } + + /* Go to the REQUESTING state. */ + ip -> client -> destination = iaddr_broadcast; + ip -> client -> state = S_REQUESTING; + ip -> client -> first_sending = cur_time; + ip -> client -> interval = ip -> client -> config -> initial_interval; + + /* Make a DHCPREQUEST packet from the lease we picked. */ + make_request (ip, picked); + ip -> client -> xid = ip -> client -> packet.xid; + + /* Toss the lease we picked - we'll get it back in a DHCPACK. */ + free_client_lease (picked); + + /* Add an immediate timeout to send the first DHCPREQUEST packet. */ + send_request (ip); +} + +/* state_requesting is called when we receive a DHCPACK message after + having sent out one or more DHCPREQUEST packets. */ + +void dhcpack (packet) + struct packet *packet; +{ + struct interface_info *ip = packet -> interface; + struct client_lease *lease; + int i; + + /* If we're not receptive to an offer right now, or if the offer + has an unrecognizable transaction id, then just drop it. */ + if (packet -> interface -> client -> xid != packet -> raw -> xid || + (packet -> interface -> hw_address.hlen != + packet -> raw -> hlen) || + (memcmp (packet -> interface -> hw_address.haddr, + packet -> raw -> chaddr, packet -> raw -> hlen))) { + debug ("DHCPACK in wrong transaction."); + return; + } + + if (ip -> client -> state != S_REBOOTING && + ip -> client -> state != S_REQUESTING && + ip -> client -> state != S_RENEWING && + ip -> client -> state != S_REBINDING) { + debug ("DHCPACK in wrong state."); + return; + } + + note ("DHCPACK from %s", piaddr (packet -> client_addr)); + + lease = packet_to_lease (packet); + if (!lease) { + note ("packet_to_lease failed."); + return; + } + + ip -> client -> new = lease; + + /* Stop resending DHCPREQUEST. */ + cancel_timeout (send_request, ip); + + /* Figure out the lease time. */ + ip -> client -> new -> expiry = + getULong (ip -> client -> + new -> options [DHO_DHCP_LEASE_TIME].data); + + /* Take the server-provided renewal time if there is one; + otherwise figure it out according to the spec. */ + if (ip -> client -> new -> options [DHO_DHCP_RENEWAL_TIME].len) + ip -> client -> new -> renewal = + getULong (ip -> client -> + new -> options [DHO_DHCP_RENEWAL_TIME].data); + else + ip -> client -> new -> renewal = + ip -> client -> new -> expiry / 2; + + /* Same deal with the rebind time. */ + if (ip -> client -> new -> options [DHO_DHCP_REBINDING_TIME].len) + ip -> client -> new -> rebind = + getULong (ip -> client -> new -> + options [DHO_DHCP_REBINDING_TIME].data); + else + ip -> client -> new -> rebind = + ip -> client -> new -> renewal + + ip -> client -> new -> renewal / 2 + + ip -> client -> new -> renewal / 4; + + ip -> client -> new -> expiry += cur_time; + ip -> client -> new -> renewal += cur_time; + ip -> client -> new -> rebind += cur_time; + + bind_lease (ip); +} + +void bind_lease (ip) + struct interface_info *ip; +{ + /* Remember the medium. */ + ip -> client -> new -> medium = ip -> client -> medium; + + /* Write out the new lease. */ + write_client_lease (ip, ip -> client -> new, 0); + + /* Run the client script with the new parameters. */ + script_init (ip, (ip -> client -> state == S_REQUESTING + ? "BOUND" + : (ip -> client -> state == S_RENEWING + ? "RENEW" + : (ip -> client -> state == S_REBOOTING + ? "REBOOT" : "REBIND"))), + ip -> client -> new -> medium); + if (ip -> client -> active && ip -> client -> state != S_REBOOTING) + script_write_params (ip, "old_", ip -> client -> active); + script_write_params (ip, "new_", ip -> client -> new); + if (ip -> client -> alias) + script_write_params (ip, "alias_", ip -> client -> alias); + script_go (ip); + + /* Replace the old active lease with the new one. */ + if (ip -> client -> active) + free_client_lease (ip -> client -> active); + ip -> client -> active = ip -> client -> new; + ip -> client -> new = (struct client_lease *)0; + + /* Set up a timeout to start the renewal process. */ + add_timeout (ip -> client -> active -> renewal, + state_bound, ip); + + note ("bound to %s -- renewal in %d seconds.", + piaddr (ip -> client -> active -> address), + ip -> client -> active -> renewal - cur_time); + ip -> client -> state = S_BOUND; + reinitialize_interfaces (); + go_daemon (); +} + +/* state_bound is called when we've successfully bound to a particular + lease, but the renewal time on that lease has expired. We are + expected to unicast a DHCPREQUEST to the server that gave us our + original lease. */ + +void state_bound (ipp) + void *ipp; +{ + struct interface_info *ip = ipp; + + ASSERT_STATE(state, S_BOUND); + + /* T1 has expired. */ + make_request (ip, ip -> client -> active); + ip -> client -> xid = ip -> client -> packet.xid; + + if (ip -> client -> active -> + options [DHO_DHCP_SERVER_IDENTIFIER].len == 4) { + memcpy (ip -> client -> destination.iabuf, + ip -> client -> active -> + options [DHO_DHCP_SERVER_IDENTIFIER].data, 4); + ip -> client -> destination.len = 4; + } else + ip -> client -> destination = iaddr_broadcast; + + ip -> client -> first_sending = cur_time; + ip -> client -> interval = ip -> client -> config -> initial_interval; + ip -> client -> state = S_RENEWING; + + /* Send the first packet immediately. */ + send_request (ip); +} + +int commit_leases () +{ + return 0; +} + +int write_lease (lease) + struct lease *lease; +{ + return 0; +} + +void db_startup () +{ +} + +void bootp (packet) + struct packet *packet; +{ + struct iaddrlist *ap; + + if (packet -> raw -> op != BOOTREPLY) + return; + + /* If there's a reject list, make sure this packet's sender isn't + on it. */ + for (ap = packet -> interface -> client -> config -> reject_list; + ap; ap = ap -> next) { + if (addr_eq (packet -> client_addr, ap -> addr)) { + note ("BOOTREPLY from %s rejected.", + piaddr (ap -> addr)); + return; + } + } + + dhcpoffer (packet); + +} + +void dhcp (packet) + struct packet *packet; +{ + struct iaddrlist *ap; + void (*handler) PROTO ((struct packet *)); + char *type; + + switch (packet -> packet_type) { + case DHCPOFFER: + handler = dhcpoffer; + type = "DHCPOFFER"; + break; + + case DHCPNAK: + handler = dhcpnak; + type = "DHCPNACK"; + break; + + case DHCPACK: + handler = dhcpack; + type = "DHCPACK"; + break; + + default: + return; + } + + /* If there's a reject list, make sure this packet's sender isn't + on it. */ + for (ap = packet -> interface -> client -> config -> reject_list; + ap; ap = ap -> next) { + if (addr_eq (packet -> client_addr, ap -> addr)) { + note ("%s from %s rejected.", + type, piaddr (ap -> addr)); + return; + } + } + (*handler) (packet); +} + +void dhcpoffer (packet) + struct packet *packet; +{ + struct interface_info *ip = packet -> interface; + struct client_lease *lease, *lp; + int i; + int arp_timeout_needed, stop_selecting; + char *name = (packet -> options [DHO_DHCP_MESSAGE_TYPE].len + ? "DHCPOFFER" : "BOOTREPLY"); + struct iaddrlist *ap; + +#ifdef DEBUG_PACKET + dump_packet (packet); +#endif + + /* If we're not receptive to an offer right now, or if the offer + has an unrecognizable transaction id, then just drop it. */ + if (ip -> client -> state != S_SELECTING || + packet -> interface -> client -> xid != packet -> raw -> xid || + (packet -> interface -> hw_address.hlen != + packet -> raw -> hlen) || + (memcmp (packet -> interface -> hw_address.haddr, + packet -> raw -> chaddr, packet -> raw -> hlen))) { + debug ("%s in wrong transaction.", name); + return; + } + + note ("%s from %s", name, piaddr (packet -> client_addr)); + + + /* If this lease doesn't supply the minimum required parameters, + blow it off. */ + for (i = 0; ip -> client -> config -> required_options [i]; i++) { + if (!packet -> options [ip -> client -> config -> + required_options [i]].len) { + note ("%s isn't satisfactory.", name); + return; + } + } + + /* If we've already seen this lease, don't record it again. */ + for (lease = ip -> client -> offered_leases; + lease; lease = lease -> next) { + if (lease -> address.len == sizeof packet -> raw -> yiaddr && + !memcmp (lease -> address.iabuf, + &packet -> raw -> yiaddr, lease -> address.len)) { + debug ("%s already seen.", name); + return; + } + } + + lease = packet_to_lease (packet); + if (!lease) { + note ("packet_to_lease failed."); + return; + } + + /* If this lease was acquired through a BOOTREPLY, record that + fact. */ + if (!packet -> options [DHO_DHCP_MESSAGE_TYPE].len) + lease -> is_bootp = 1; + + /* Record the medium under which this lease was offered. */ + lease -> medium = ip -> client -> medium; + + /* Send out an ARP Request for the offered IP address. */ + script_init (ip, "ARPSEND", lease -> medium); + script_write_params (ip, "check_", lease); + /* If the script can't send an ARP request without waiting, + we'll be waiting when we do the ARPCHECK, so don't wait now. */ + if (script_go (ip)) + arp_timeout_needed = 0; + else + arp_timeout_needed = 2; + + /* Figure out when we're supposed to stop selecting. */ + stop_selecting = (ip -> client -> first_sending + + ip -> client -> config -> select_interval); + + /* If this is the lease we asked for, put it at the head of the + list, and don't mess with the arp request timeout. */ + if (lease -> address.len == ip -> client -> requested_address.len && + !memcmp (lease -> address.iabuf, + ip -> client -> requested_address.iabuf, + ip -> client -> requested_address.len)) { + lease -> next = ip -> client -> offered_leases; + ip -> client -> offered_leases = lease; + } else { + /* If we already have an offer, and arping for this + offer would take us past the selection timeout, + then don't extend the timeout - just hope for the + best. */ + if (ip -> client -> offered_leases && + (cur_time + arp_timeout_needed) > stop_selecting) + arp_timeout_needed = 0; + + /* Put the lease at the end of the list. */ + lease -> next = (struct client_lease *)0; + if (!ip -> client -> offered_leases) + ip -> client -> offered_leases = lease; + else { + for (lp = ip -> client -> offered_leases; lp -> next; + lp = lp -> next) + ; + lp -> next = lease; + } + } + + /* If we're supposed to stop selecting before we've had time + to wait for the ARPREPLY, add some delay to wait for + the ARPREPLY. */ + if (stop_selecting - cur_time < arp_timeout_needed) + stop_selecting = cur_time + arp_timeout_needed; + + /* If the selecting interval has expired, go immediately to + state_selecting(). Otherwise, time out into + state_selecting at the select interval. */ + if (stop_selecting <= 0) + state_selecting (ip); + else { + add_timeout (stop_selecting, state_selecting, ip); + cancel_timeout (send_discover, ip); + } +} + +/* Allocate a client_lease structure and initialize it from the parameters + in the specified packet. */ + +struct client_lease *packet_to_lease (packet) + struct packet *packet; +{ + struct client_lease *lease; + int i; + + lease = (struct client_lease *)malloc (sizeof (struct client_lease)); + + if (!lease) { + warn ("dhcpoffer: no memory to record lease.\n"); + return (struct client_lease *)0; + } + + memset (lease, 0, sizeof *lease); + + /* Copy the lease options. */ + for (i = 0; i < 256; i++) { + if (packet -> options [i].len) { + lease -> options [i].data = + (unsigned char *) + malloc (packet -> options [i].len + 1); + if (!lease -> options [i].data) { + warn ("dhcpoffer: no memory for option %d\n", + i); + free_client_lease (lease); + return (struct client_lease *)0; + } else { + memcpy (lease -> options [i].data, + packet -> options [i].data, + packet -> options [i].len); + lease -> options [i].len = + packet -> options [i].len; + lease -> options [i].data + [lease -> options [i].len] = 0; + } + } + } + + lease -> address.len = sizeof (packet -> raw -> yiaddr); + memcpy (lease -> address.iabuf, &packet -> raw -> yiaddr, + lease -> address.len); + + /* If the server name was filled out, copy it. */ + if ((!packet -> options [DHO_DHCP_OPTION_OVERLOAD].len || + !(packet -> options [DHO_DHCP_OPTION_OVERLOAD].data [0] & 2)) && + packet -> raw -> sname [0]) { + int len; + /* Don't count on the NUL terminator. */ + for (len = 0; len < 64; len++) + if (!packet -> raw -> sname [len]) + break; + lease -> server_name = malloc (len + 1); + if (!lease -> server_name) { + warn ("dhcpoffer: no memory for filename.\n"); + free_client_lease (lease); + return (struct client_lease *)0; + } else { + memcpy (lease -> server_name, + packet -> raw -> sname, len); + lease -> server_name [len] = 0; + } + } + + /* Ditto for the filename. */ + if ((!packet -> options [DHO_DHCP_OPTION_OVERLOAD].len || + !(packet -> options [DHO_DHCP_OPTION_OVERLOAD].data [0] & 1)) && + packet -> raw -> file [0]) { + int len; + /* Don't count on the NUL terminator. */ + for (len = 0; len < 64; len++) + if (!packet -> raw -> file [len]) + break; + lease -> filename = malloc (len + 1); + if (!lease -> filename) { + warn ("dhcpoffer: no memory for filename.\n"); + free_client_lease (lease); + return (struct client_lease *)0; + } else { + memcpy (lease -> filename, + packet -> raw -> file, len); + lease -> filename [len] = 0; + } + } + return lease; +} + +void dhcpnak (packet) + struct packet *packet; +{ + struct interface_info *ip = packet -> interface; + + /* If we're not receptive to an offer right now, or if the offer + has an unrecognizable transaction id, then just drop it. */ + if (packet -> interface -> client -> xid != packet -> raw -> xid || + (packet -> interface -> hw_address.hlen != + packet -> raw -> hlen) || + (memcmp (packet -> interface -> hw_address.haddr, + packet -> raw -> chaddr, packet -> raw -> hlen))) { + debug ("DHCPNAK in wrong transaction."); + return; + } + + if (ip -> client -> state != S_REBOOTING && + ip -> client -> state != S_REQUESTING && + ip -> client -> state != S_RENEWING && + ip -> client -> state != S_REBINDING) { + debug ("DHCPNAK in wrong state."); + return; + } + + note ("DHCPNAK from %s", piaddr (packet -> client_addr)); + + if (!ip -> client -> active) { + note ("DHCPNAK with no active lease.\n"); + return; + } + + free_client_lease (ip -> client -> active); + ip -> client -> active = (struct client_lease *)0; + + /* Stop sending DHCPREQUEST packets... */ + cancel_timeout (send_request, ip); + + ip -> client -> state = S_INIT; + state_init (ip); +} + +/* Send out a DHCPDISCOVER packet, and set a timeout to send out another + one after the right interval has expired. If we don't get an offer by + the time we reach the panic interval, call the panic function. */ + +void send_discover (ipp) + void *ipp; +{ + struct interface_info *ip = ipp; + + int result; + int interval; + int increase = 1; + + /* Figure out how long it's been since we started transmitting. */ + interval = cur_time - ip -> client -> first_sending; + + /* If we're past the panic timeout, call the script and tell it + we haven't found anything for this interface yet. */ + if (interval > ip -> client -> config -> timeout) { + state_panic (ip); + return; + } + + /* If we're selecting media, try the whole list before doing + the exponential backoff, but if we've already received an + offer, stop looping, because we obviously have it right. */ + if (!ip -> client -> offered_leases && + ip -> client -> config -> media) { + int fail = 0; + again: + if (ip -> client -> medium) { + ip -> client -> medium = + ip -> client -> medium -> next; + increase = 0; + } + if (!ip -> client -> medium) { + if (fail) + error ("No valid media types for %s!", + ip -> name); + ip -> client -> medium = + ip -> client -> config -> media; + increase = 1; + } + + note ("Trying medium \"%s\" %d", + ip -> client -> medium -> string, increase); + script_init (ip, "MEDIUM", ip -> client -> medium); + if (script_go (ip)) { + goto again; + } + } + + /* If we're supposed to increase the interval, do so. If it's + currently zero (i.e., we haven't sent any packets yet), set + it to one; otherwise, add to it a random number between + zero and two times itself. On average, this means that it + will double with every transmission. */ + if (increase) { + if (!ip -> client -> interval) + ip -> client -> interval = + ip -> client -> config -> initial_interval; + else { + ip -> client -> interval += + ((random () >> 2) % + (2 * ip -> client -> interval)); + } + + /* Don't backoff past cutoff. */ + if (ip -> client -> interval > + ip -> client -> config -> backoff_cutoff) + ip -> client -> interval = + ((ip -> client -> config -> backoff_cutoff / 2) + + ((random () >> 2) % + ip -> client -> config -> backoff_cutoff)); + } else if (!ip -> client -> interval) + ip -> client -> interval = + ip -> client -> config -> initial_interval; + + /* If the backoff would take us to the panic timeout, just use that + as the interval. */ + if (cur_time + ip -> client -> interval > + ip -> client -> first_sending + ip -> client -> config -> timeout) + ip -> client -> interval = + (ip -> client -> first_sending + + ip -> client -> config -> timeout) - cur_time + 1; + + /* Record the number of seconds since we started sending. */ + if (interval < 255) + ip -> client -> packet.secs = interval; + else + ip -> client -> packet.secs = 255; + + note ("DHCPDISCOVER on %s to %s port %d interval %ld", + ip -> name, + inet_ntoa (sockaddr_broadcast.sin_addr), + ntohs (sockaddr_broadcast.sin_port), ip -> client -> interval); + + /* Send out a packet. */ + result = send_packet (ip, (struct packet *)0, + &ip -> client -> packet, + ip -> client -> packet_length, + inaddr_any, &sockaddr_broadcast, + (struct hardware *)0); + if (result < 0) + warn ("send_packet: %m"); + + add_timeout (cur_time + ip -> client -> interval, send_discover, ip); +} + +/* state_panic gets called if we haven't received any offers in a preset + amount of time. When this happens, we try to use existing leases that + haven't yet expired, and failing that, we call the client script and + hope it can do something. */ + +void state_panic (ipp) + void *ipp; +{ + struct interface_info *ip = ipp; + + struct client_lease *loop = ip -> client -> active; + struct client_lease *lp; + + note ("No DHCPOFFERS received."); + + /* We may not have an active lease, but we may have some + predefined leases that we can try. */ + if (!ip -> client -> active && ip -> client -> leases) + goto activate_next; + + /* Run through the list of leases and see if one can be used. */ + while (ip -> client -> active) { + if (ip -> client -> active -> expiry > cur_time) { + note ("Trying recorded lease %s", + piaddr (ip -> client -> active -> address)); + /* Run the client script with the existing + parameters. */ + script_init (ip, "TIMEOUT", + ip -> client -> active -> medium); + script_write_params (ip, "new_", + ip -> client -> active); + if (ip -> client -> alias) + script_write_params (ip, "alias_", + ip -> client -> alias); + + /* If the old lease is still good and doesn't + yet need renewal, go into BOUND state and + timeout at the renewal time. */ + if (!script_go (ip)) { + if (cur_time < + ip -> client -> active -> renewal) { + ip -> client -> state = S_BOUND; + note ("bound: renewal in %d seconds.", + ip -> client -> active -> renewal + - cur_time); + add_timeout ((ip -> client -> + active -> renewal), + state_bound, ip); + } else { + ip -> client -> state = S_BOUND; + note ("bound: immediate renewal."); + state_bound (ip); + } + reinitialize_interfaces (); + go_daemon (); + return; + } + } + + /* If there are no other leases, give up. */ + if (!ip -> client -> leases) { + ip -> client -> leases = ip -> client -> active; + ip -> client -> active = (struct client_lease *)0; + break; + } + + activate_next: + /* Otherwise, put the active lease at the end of the + lease list, and try another lease.. */ + for (lp = ip -> client -> leases; lp -> next; lp = lp -> next) + ; + lp -> next = ip -> client -> active; + if (lp -> next) { + lp -> next -> next = (struct client_lease *)0; + } + ip -> client -> active = ip -> client -> leases; + ip -> client -> leases = ip -> client -> leases -> next; + + /* If we already tried this lease, we've exhausted the + set of leases, so we might as well give up for + now. */ + if (ip -> client -> active == loop) + break; + else if (!loop) + loop = ip -> client -> active; + } + + /* No leases were available, or what was available didn't work, so + tell the shell script that we failed to allocate an address, + and try again later. */ + if (onetry) { + exit(1); + note ("Unable to obtain a lease on first try - exiting.\n"); + } + note ("No working leases in persistent database - sleeping.\n"); + script_init (ip, "FAIL", (struct string_list *)0); + if (ip -> client -> alias) + script_write_params (ip, "alias_", ip -> client -> alias); + script_go (ip); + ip -> client -> state = S_INIT; + add_timeout (cur_time + ip -> client -> config -> retry_interval, + state_init, ip); + go_daemon (); +} + +void send_request (ipp) + void *ipp; +{ + struct interface_info *ip = ipp; + + int result; + int interval; + struct sockaddr_in destination; + struct in_addr from; + + /* Figure out how long it's been since we started transmitting. */ + interval = cur_time - ip -> client -> first_sending; + + /* If we're in the INIT-REBOOT or REQUESTING state and we're + past the reboot timeout, go to INIT and see if we can + DISCOVER an address... */ + /* XXX In the INIT-REBOOT state, if we don't get an ACK, it + means either that we're on a network with no DHCP server, + or that our server is down. In the latter case, assuming + that there is a backup DHCP server, DHCPDISCOVER will get + us a new address, but we could also have successfully + reused our old address. In the former case, we're hosed + anyway. This is not a win-prone situation. */ + if ((ip -> client -> state == S_REBOOTING || + ip -> client -> state == S_REQUESTING) && + interval > ip -> client -> config -> reboot_timeout) { + cancel: + ip -> client -> state = S_INIT; + cancel_timeout (send_request, ip); + state_init (ip); + return; + } + + /* If we're in the reboot state, make sure the media is set up + correctly. */ + if (ip -> client -> state == S_REBOOTING && + !ip -> client -> medium && + ip -> client -> active -> medium ) { + script_init (ip, "MEDIUM", ip -> client -> active -> medium); + + /* If the medium we chose won't fly, go to INIT state. */ + if (script_go (ip)) + goto cancel; + + /* Record the medium. */ + ip -> client -> medium = ip -> client -> active -> medium; + } + + /* If the lease has expired, relinquish the address and go back + to the INIT state. */ + if (ip -> client -> state != S_REQUESTING && + cur_time > ip -> client -> active -> expiry) { + /* Run the client script with the new parameters. */ + script_init (ip, "EXPIRE", (struct string_list *)0); + script_write_params (ip, "old_", ip -> client -> active); + if (ip -> client -> alias) + script_write_params (ip, "alias_", + ip -> client -> alias); + script_go (ip); + + /* Now do a preinit on the interface so that we can + discover a new address. */ + script_init (ip, "PREINIT", (struct string_list *)0); + if (ip -> client -> alias) + script_write_params (ip, "alias_", + ip -> client -> alias); + script_go (ip); + + ip -> client -> state = S_INIT; + state_init (ip); + return; + } + + /* Do the exponential backoff... */ + if (!ip -> client -> interval) + ip -> client -> interval = + ip -> client -> config -> initial_interval; + else { + ip -> client -> interval += + ((random () >> 2) % + (2 * ip -> client -> interval)); + } + + /* Don't backoff past cutoff. */ + if (ip -> client -> interval > + ip -> client -> config -> backoff_cutoff) + ip -> client -> interval = + ((ip -> client -> config -> backoff_cutoff / 2) + + ((random () >> 2) + % ip -> client -> interval)); + + /* If the backoff would take us to the expiry time, just set the + timeout to the expiry time. */ + if (ip -> client -> state != S_REQUESTING && + cur_time + ip -> client -> interval > + ip -> client -> active -> expiry) + ip -> client -> interval = + ip -> client -> active -> expiry - cur_time + 1; + + /* If the lease T2 time has elapsed, or if we're not yet bound, + broadcast the DHCPREQUEST rather than unicasting. */ + if (ip -> client -> state == S_REQUESTING || + ip -> client -> state == S_REBOOTING || + cur_time > ip -> client -> active -> rebind) + destination.sin_addr.s_addr = INADDR_BROADCAST; + else + memcpy (&destination.sin_addr.s_addr, + ip -> client -> destination.iabuf, + sizeof destination.sin_addr.s_addr); + destination.sin_port = remote_port; + destination.sin_family = AF_INET; +#ifdef HAVE_SA_LEN + destination.sin_len = sizeof destination; +#endif + + if (ip -> client -> state != S_REQUESTING) + memcpy (&from, ip -> client -> active -> address.iabuf, + sizeof from); + else + from.s_addr = INADDR_ANY; + + /* Record the number of seconds since we started sending. */ + if (interval < 255) + ip -> client -> packet.secs = interval; + else + ip -> client -> packet.secs = 255; + + note ("DHCPREQUEST on %s to %s port %d", ip -> name, + inet_ntoa (destination.sin_addr), + ntohs (destination.sin_port)); + + if (destination.sin_addr.s_addr != INADDR_BROADCAST && + fallback_interface) + result = send_packet (fallback_interface, + (struct packet *)0, + &ip -> client -> packet, + ip -> client -> packet_length, + from, &destination, + (struct hardware *)0); + else + /* Send out a packet. */ + result = send_packet (ip, (struct packet *)0, + &ip -> client -> packet, + ip -> client -> packet_length, + from, &destination, + (struct hardware *)0); + + if (result < 0) + warn ("send_packet: %m"); + + add_timeout (cur_time + ip -> client -> interval, + send_request, ip); +} + +void send_decline (ipp) + void *ipp; +{ + struct interface_info *ip = ipp; + + int result; + + note ("DHCPDECLINE on %s to %s port %d", ip -> name, + inet_ntoa (sockaddr_broadcast.sin_addr), + ntohs (sockaddr_broadcast.sin_port)); + + /* Send out a packet. */ + result = send_packet (ip, (struct packet *)0, + &ip -> client -> packet, + ip -> client -> packet_length, + inaddr_any, &sockaddr_broadcast, + (struct hardware *)0); + if (result < 0) + warn ("send_packet: %m"); +} + +void send_release (ipp) + void *ipp; +{ + struct interface_info *ip = ipp; + + int result; + + note ("DHCPRELEASE on %s to %s port %d", ip -> name, + inet_ntoa (sockaddr_broadcast.sin_addr), + ntohs (sockaddr_broadcast.sin_port)); + + /* Send out a packet. */ + result = send_packet (ip, (struct packet *)0, + &ip -> client -> packet, + ip -> client -> packet_length, + inaddr_any, &sockaddr_broadcast, + (struct hardware *)0); + if (result < 0) + warn ("send_packet: %m"); +} + +void make_discover (ip, lease) + struct interface_info *ip; + struct client_lease *lease; +{ + struct dhcp_packet *raw; + unsigned char discover = DHCPDISCOVER; + int i; + + struct tree_cache *options [256]; + struct tree_cache option_elements [256]; + + memset (option_elements, 0, sizeof option_elements); + memset (options, 0, sizeof options); + memset (&ip -> client -> packet, 0, sizeof (ip -> client -> packet)); + + /* Set DHCP_MESSAGE_TYPE to DHCPDISCOVER */ + i = DHO_DHCP_MESSAGE_TYPE; + options [i] = &option_elements [i]; + options [i] -> value = &discover; + options [i] -> len = sizeof discover; + options [i] -> buf_size = sizeof discover; + options [i] -> timeout = 0xFFFFFFFF; + options [i] -> tree = (struct tree *)0; + + /* Request the options we want */ + i = DHO_DHCP_PARAMETER_REQUEST_LIST; + options [i] = &option_elements [i]; + options [i] -> value = ip -> client -> config -> requested_options; + options [i] -> len = ip -> client -> config -> requested_option_count; + options [i] -> buf_size = + ip -> client -> config -> requested_option_count; + options [i] -> timeout = 0xFFFFFFFF; + options [i] -> tree = (struct tree *)0; + + /* If we had an address, try to get it again. */ + if (lease) { + ip -> client -> requested_address = lease -> address; + i = DHO_DHCP_REQUESTED_ADDRESS; + options [i] = &option_elements [i]; + options [i] -> value = lease -> address.iabuf; + options [i] -> len = lease -> address.len; + options [i] -> buf_size = lease -> address.len; + options [i] -> timeout = 0xFFFFFFFF; + options [i] -> tree = (struct tree *)0; + } else { + ip -> client -> requested_address.len = 0; + } + + /* Send any options requested in the config file. */ + for (i = 0; i < 256; i++) { + if (!options [i] && + ip -> client -> config -> send_options [i].data) { + options [i] = &option_elements [i]; + options [i] -> value = ip -> client -> config -> + send_options [i].data; + options [i] -> len = ip -> client -> config -> + send_options [i].len; + options [i] -> buf_size = ip -> client -> config -> + send_options [i].len; + options [i] -> timeout = 0xFFFFFFFF; + options [i] -> tree = (struct tree *)0; + } + } + + /* Set up the option buffer... */ + ip -> client -> packet_length = + cons_options ((struct packet *)0, &ip -> client -> packet, + options, 0, 0, 0); + if (ip -> client -> packet_length < BOOTP_MIN_LEN) + ip -> client -> packet_length = BOOTP_MIN_LEN; + + ip -> client -> packet.op = BOOTREQUEST; + ip -> client -> packet.htype = ip -> hw_address.htype; + ip -> client -> packet.hlen = ip -> hw_address.hlen; + ip -> client -> packet.hops = 0; + ip -> client -> packet.xid = random (); + ip -> client -> packet.secs = 0; /* filled in by send_discover. */ + ip -> client -> packet.flags = htons (BOOTP_BROADCAST); /* XXX */ + memset (&(ip -> client -> packet.ciaddr), + 0, sizeof ip -> client -> packet.ciaddr); + memset (&(ip -> client -> packet.yiaddr), + 0, sizeof ip -> client -> packet.yiaddr); + memset (&(ip -> client -> packet.siaddr), + 0, sizeof ip -> client -> packet.siaddr); + memset (&(ip -> client -> packet.giaddr), + 0, sizeof ip -> client -> packet.giaddr); + memcpy (ip -> client -> packet.chaddr, + ip -> hw_address.haddr, ip -> hw_address.hlen); + +#ifdef DEBUG_PACKET + dump_packet (sendpkt); + dump_raw ((unsigned char *)ip -> client -> packet, + sendpkt->packet_length); +#endif +} + + +void make_request (ip, lease) + struct interface_info *ip; + struct client_lease *lease; +{ + unsigned char request = DHCPREQUEST; + int i; + + struct tree_cache *options [256]; + struct tree_cache option_elements [256]; + + memset (options, 0, sizeof options); + memset (&ip -> client -> packet, 0, sizeof (ip -> client -> packet)); + + /* Set DHCP_MESSAGE_TYPE to DHCPREQUEST */ + i = DHO_DHCP_MESSAGE_TYPE; + options [i] = &option_elements [i]; + options [i] -> value = &request; + options [i] -> len = sizeof request; + options [i] -> buf_size = sizeof request; + options [i] -> timeout = 0xFFFFFFFF; + options [i] -> tree = (struct tree *)0; + + /* Request the options we want */ + i = DHO_DHCP_PARAMETER_REQUEST_LIST; + options [i] = &option_elements [i]; + options [i] -> value = ip -> client -> config -> requested_options; + options [i] -> len = ip -> client -> config -> requested_option_count; + options [i] -> buf_size = + ip -> client -> config -> requested_option_count; + options [i] -> timeout = 0xFFFFFFFF; + options [i] -> tree = (struct tree *)0; + + /* If we are requesting an address that hasn't yet been assigned + to us, use the DHCP Requested Address option. */ + if (ip -> client -> state == S_REQUESTING) { + /* Send back the server identifier... */ + i = DHO_DHCP_SERVER_IDENTIFIER; + options [i] = &option_elements [i]; + options [i] -> value = lease -> options [i].data; + options [i] -> len = lease -> options [i].len; + options [i] -> buf_size = lease -> options [i].len; + options [i] -> timeout = 0xFFFFFFFF; + options [i] -> tree = (struct tree *)0; + } + if (ip -> client -> state == S_REQUESTING || + ip -> client -> state == S_REBOOTING) { + ip -> client -> requested_address = lease -> address; + i = DHO_DHCP_REQUESTED_ADDRESS; + options [i] = &option_elements [i]; + options [i] -> value = lease -> address.iabuf; + options [i] -> len = lease -> address.len; + options [i] -> buf_size = lease -> address.len; + options [i] -> timeout = 0xFFFFFFFF; + options [i] -> tree = (struct tree *)0; + } else { + ip -> client -> requested_address.len = 0; + } + + /* Send any options requested in the config file. */ + for (i = 0; i < 256; i++) { + if (!options [i] && + ip -> client -> config -> send_options [i].data) { + options [i] = &option_elements [i]; + options [i] -> value = ip -> client -> config -> + send_options [i].data; + options [i] -> len = ip -> client -> config -> + send_options [i].len; + options [i] -> buf_size = ip -> client -> config -> + send_options [i].len; + options [i] -> timeout = 0xFFFFFFFF; + options [i] -> tree = (struct tree *)0; + } + } + + /* Set up the option buffer... */ + ip -> client -> packet_length = + cons_options ((struct packet *)0, &ip -> client -> packet, + options, 0, 0, 0); + if (ip -> client -> packet_length < BOOTP_MIN_LEN) + ip -> client -> packet_length = BOOTP_MIN_LEN; + + ip -> client -> packet.op = BOOTREQUEST; + ip -> client -> packet.htype = ip -> hw_address.htype; + ip -> client -> packet.hlen = ip -> hw_address.hlen; + ip -> client -> packet.hops = 0; + ip -> client -> packet.xid = ip -> client -> xid; + ip -> client -> packet.secs = 0; /* Filled in by send_request. */ + + /* If we own the address we're requesting, put it in ciaddr; + otherwise set ciaddr to zero. */ + if (ip -> client -> state == S_BOUND || + ip -> client -> state == S_RENEWING || + ip -> client -> state == S_REBINDING) { + memcpy (&ip -> client -> packet.ciaddr, + lease -> address.iabuf, lease -> address.len); + ip -> client -> packet.flags = 0; + } else { + memset (&ip -> client -> packet.ciaddr, 0, + sizeof ip -> client -> packet.ciaddr); + ip -> client -> packet.flags = htons (BOOTP_BROADCAST); + } + + memset (&ip -> client -> packet.yiaddr, 0, + sizeof ip -> client -> packet.yiaddr); + memset (&ip -> client -> packet.siaddr, 0, + sizeof ip -> client -> packet.siaddr); + memset (&ip -> client -> packet.giaddr, 0, + sizeof ip -> client -> packet.giaddr); + memcpy (ip -> client -> packet.chaddr, + ip -> hw_address.haddr, ip -> hw_address.hlen); + +#ifdef DEBUG_PACKET + dump_packet (sendpkt); + dump_raw ((unsigned char *)ip -> client -> packet, sendpkt->packet_length); +#endif +} + +void make_decline (ip, lease) + struct interface_info *ip; + struct client_lease *lease; +{ + unsigned char decline = DHCPDECLINE; + int i; + + struct tree_cache *options [256]; + struct tree_cache message_type_tree; + struct tree_cache requested_address_tree; + struct tree_cache server_id_tree; + struct tree_cache client_id_tree; + + memset (options, 0, sizeof options); + memset (&ip -> client -> packet, 0, sizeof (ip -> client -> packet)); + + /* Set DHCP_MESSAGE_TYPE to DHCPDECLINE */ + i = DHO_DHCP_MESSAGE_TYPE; + options [i] = &message_type_tree; + options [i] -> value = &decline; + options [i] -> len = sizeof decline; + options [i] -> buf_size = sizeof decline; + options [i] -> timeout = 0xFFFFFFFF; + options [i] -> tree = (struct tree *)0; + + /* Send back the server identifier... */ + i = DHO_DHCP_SERVER_IDENTIFIER; + options [i] = &server_id_tree; + options [i] -> value = lease -> options [i].data; + options [i] -> len = lease -> options [i].len; + options [i] -> buf_size = lease -> options [i].len; + options [i] -> timeout = 0xFFFFFFFF; + options [i] -> tree = (struct tree *)0; + + /* Send back the address we're declining. */ + i = DHO_DHCP_REQUESTED_ADDRESS; + options [i] = &requested_address_tree; + options [i] -> value = lease -> address.iabuf; + options [i] -> len = lease -> address.len; + options [i] -> buf_size = lease -> address.len; + options [i] -> timeout = 0xFFFFFFFF; + options [i] -> tree = (struct tree *)0; + + /* Send the uid if the user supplied one. */ + i = DHO_DHCP_CLIENT_IDENTIFIER; + if (ip -> client -> config -> send_options [i].len) { + options [i] = &client_id_tree; + options [i] -> value = ip -> client -> config -> + send_options [i].data; + options [i] -> len = ip -> client -> config -> + send_options [i].len; + options [i] -> buf_size = ip -> client -> config -> + send_options [i].len; + options [i] -> timeout = 0xFFFFFFFF; + options [i] -> tree = (struct tree *)0; + } + + + /* Set up the option buffer... */ + ip -> client -> packet_length = + cons_options ((struct packet *)0, &ip -> client -> packet, + options, 0, 0, 0); + if (ip -> client -> packet_length < BOOTP_MIN_LEN) + ip -> client -> packet_length = BOOTP_MIN_LEN; + + ip -> client -> packet.op = BOOTREQUEST; + ip -> client -> packet.htype = ip -> hw_address.htype; + ip -> client -> packet.hlen = ip -> hw_address.hlen; + ip -> client -> packet.hops = 0; + ip -> client -> packet.xid = ip -> client -> xid; + ip -> client -> packet.secs = 0; /* Filled in by send_request. */ + ip -> client -> packet.flags = htons (BOOTP_BROADCAST); + + /* ciaddr must always be zero. */ + memset (&ip -> client -> packet.ciaddr, 0, + sizeof ip -> client -> packet.ciaddr); + memset (&ip -> client -> packet.yiaddr, 0, + sizeof ip -> client -> packet.yiaddr); + memset (&ip -> client -> packet.siaddr, 0, + sizeof ip -> client -> packet.siaddr); + memset (&ip -> client -> packet.giaddr, 0, + sizeof ip -> client -> packet.giaddr); + memcpy (ip -> client -> packet.chaddr, + ip -> hw_address.haddr, ip -> hw_address.hlen); + +#ifdef DEBUG_PACKET + dump_packet (sendpkt); + dump_raw ((unsigned char *)ip -> client -> packet, sendpkt->packet_length); +#endif +} + +void make_release (ip, lease) + struct interface_info *ip; + struct client_lease *lease; +{ + unsigned char request = DHCPRELEASE; + int i; + + struct tree_cache *options [256]; + struct tree_cache message_type_tree; + struct tree_cache requested_address_tree; + struct tree_cache server_id_tree; + + memset (options, 0, sizeof options); + memset (&ip -> client -> packet, 0, sizeof (ip -> client -> packet)); + + /* Set DHCP_MESSAGE_TYPE to DHCPRELEASE */ + i = DHO_DHCP_MESSAGE_TYPE; + options [i] = &message_type_tree; + options [i] -> value = &request; + options [i] -> len = sizeof request; + options [i] -> buf_size = sizeof request; + options [i] -> timeout = 0xFFFFFFFF; + options [i] -> tree = (struct tree *)0; + + /* Send back the server identifier... */ + i = DHO_DHCP_SERVER_IDENTIFIER; + options [i] = &server_id_tree; + options [i] -> value = lease -> options [i].data; + options [i] -> len = lease -> options [i].len; + options [i] -> buf_size = lease -> options [i].len; + options [i] -> timeout = 0xFFFFFFFF; + options [i] -> tree = (struct tree *)0; + + /* Set up the option buffer... */ + ip -> client -> packet_length = + cons_options ((struct packet *)0, &ip -> client -> packet, + options, 0, 0, 0); + if (ip -> client -> packet_length < BOOTP_MIN_LEN) + ip -> client -> packet_length = BOOTP_MIN_LEN; + + ip -> client -> packet.op = BOOTREQUEST; + ip -> client -> packet.htype = ip -> hw_address.htype; + ip -> client -> packet.hlen = ip -> hw_address.hlen; + ip -> client -> packet.hops = 0; + ip -> client -> packet.xid = ip -> client -> xid; + ip -> client -> packet.secs = 0; + ip -> client -> packet.flags = 0; + memcpy (&ip -> client -> packet.ciaddr, + lease -> address.iabuf, lease -> address.len); + memset (&ip -> client -> packet.yiaddr, 0, + sizeof ip -> client -> packet.yiaddr); + memset (&ip -> client -> packet.siaddr, 0, + sizeof ip -> client -> packet.siaddr); + memset (&ip -> client -> packet.giaddr, 0, + sizeof ip -> client -> packet.giaddr); + memcpy (ip -> client -> packet.chaddr, + ip -> hw_address.haddr, ip -> hw_address.hlen); + +#ifdef DEBUG_PACKET + dump_packet (sendpkt); + dump_raw ((unsigned char *)ip -> client -> packet, + ip -> client -> packet_length); +#endif +} + +void free_client_lease (lease) + struct client_lease *lease; +{ + int i; + + if (lease -> server_name) + free (lease -> server_name); + if (lease -> filename) + free (lease -> filename); + for (i = 0; i < 256; i++) { + if (lease -> options [i].len) + free (lease -> options [i].data); + } + free (lease); +} + +FILE *leaseFile; + +void rewrite_client_leases () +{ + struct interface_info *ip; + struct client_lease *lp; + + if (leaseFile) + fclose (leaseFile); + leaseFile = fopen (path_dhclient_db, "w"); + if (!leaseFile) + error ("can't create %s: %m", path_dhclient_db); + + /* Write out all the leases attached to configured interfaces that + we know about. */ + for (ip = interfaces; ip; ip = ip -> next) { + for (lp = ip -> client -> leases; lp; lp = lp -> next) { + write_client_lease (ip, lp, 1); + } + if (ip -> client -> active) + write_client_lease (ip, ip -> client -> active, 1); + } + + /* Write out any leases that are attached to interfaces that aren't + currently configured. */ + for (ip = dummy_interfaces; ip; ip = ip -> next) { + for (lp = ip -> client -> leases; lp; lp = lp -> next) { + write_client_lease (ip, lp, 1); + } + if (ip -> client -> active) + write_client_lease (ip, ip -> client -> active, 1); + } + fflush (leaseFile); +} + +void write_client_lease (ip, lease, rewrite) + struct interface_info *ip; + struct client_lease *lease; + int rewrite; +{ + int i; + struct tm *t; + static int leases_written; + + if (!rewrite) { + if (leases_written++ > 20) { + rewrite_client_leases (); + leases_written = 0; + } + } + + /* If the lease came from the config file, we don't need to stash + a copy in the lease database. */ + if (lease -> is_static) + return; + + if (!leaseFile) { /* XXX */ + leaseFile = fopen (path_dhclient_db, "w"); + if (!leaseFile) + error ("can't create %s: %m", path_dhclient_db); + } + + fprintf (leaseFile, "lease {\n"); + if (lease -> is_bootp) + fprintf (leaseFile, " bootp;\n"); + fprintf (leaseFile, " interface \"%s\";\n", ip -> name); + fprintf (leaseFile, " fixed-address %s;\n", + piaddr (lease -> address)); + if (lease -> filename) + fprintf (leaseFile, " filename \"%s\";\n", + lease -> filename); + if (lease -> server_name) + fprintf (leaseFile, " server-name \"%s\";\n", + lease -> filename); + if (lease -> medium) + fprintf (leaseFile, " medium \"%s\";\n", + lease -> medium -> string); + for (i = 0; i < 256; i++) { + if (lease -> options [i].len) { + fprintf (leaseFile, + " option %s %s;\n", + dhcp_options [i].name, + pretty_print_option + (i, lease -> options [i].data, + lease -> options [i].len, 1, 1)); + } + } + + /* Note: the following is not a Y2K bug - it's a Y1.9K bug. Until + somebody invents a time machine, I think we can safely disregard + it. */ + t = gmtime (&lease -> renewal); + fprintf (leaseFile, + " renew %d %d/%d/%d %02d:%02d:%02d;\n", + t -> tm_wday, t -> tm_year + 1900, + t -> tm_mon + 1, t -> tm_mday, + t -> tm_hour, t -> tm_min, t -> tm_sec); + t = gmtime (&lease -> rebind); + fprintf (leaseFile, + " rebind %d %d/%d/%d %02d:%02d:%02d;\n", + t -> tm_wday, t -> tm_year + 1900, + t -> tm_mon + 1, t -> tm_mday, + t -> tm_hour, t -> tm_min, t -> tm_sec); + t = gmtime (&lease -> expiry); + fprintf (leaseFile, + " expire %d %d/%d/%d %02d:%02d:%02d;\n", + t -> tm_wday, t -> tm_year + 1900, + t -> tm_mon + 1, t -> tm_mday, + t -> tm_hour, t -> tm_min, t -> tm_sec); + fprintf (leaseFile, "}\n"); + fflush (leaseFile); +} + +/* Variables holding name of script and file pointer for writing to + script. Needless to say, this is not reentrant - only one script + can be invoked at a time. */ +char scriptName [256]; +FILE *scriptFile; + +void script_init (ip, reason, medium) + struct interface_info *ip; + char *reason; + struct string_list *medium; +{ + int fd; +#ifndef HAVE_MKSTEMP + + do { +#endif + strcpy (scriptName, "/tmp/dcsXXXXXX"); +#ifdef HAVE_MKSTEMP + fd = mkstemp (scriptName); +#else + if (!mktemp (scriptName)) + error ("can't create temporary client script %s: %m", + scriptName); + fd = creat (scriptName, 0600); + } while (fd < 0); +#endif + + scriptFile = fdopen (fd, "w"); + if (!scriptFile) + error ("can't write script file: %m"); + fprintf (scriptFile, "#!/bin/sh\n\n"); + if (ip) { + fprintf (scriptFile, "interface=\"%s\"\n", ip -> name); + fprintf (scriptFile, "export interface\n"); + } + if (medium) { + fprintf (scriptFile, "medium=\"%s\"\n", medium -> string); + fprintf (scriptFile, "export medium\n"); + } + fprintf (scriptFile, "reason=\"%s\"\n", reason); + fprintf (scriptFile, "export reason\n"); +} + +void script_write_params (ip, prefix, lease) + struct interface_info *ip; + char *prefix; + struct client_lease *lease; +{ + int i; + u_int8_t dbuf [1500]; + int len; + + fprintf (scriptFile, "%sip_address=\"%s\"\n", + prefix, piaddr (lease -> address)); + fprintf (scriptFile, "export %sip_address\n", prefix); + + /* For the benefit of Linux (and operating systems which may + have similar needs), compute the network address based on + the supplied ip address and netmask, if provided. Also + compute the broadcast address (the host address all ones + broadcast address, not the host address all zeroes + broadcast address). */ + + if (lease -> options [DHO_SUBNET_MASK].len && + (lease -> options [DHO_SUBNET_MASK].len < + sizeof lease -> address.iabuf)) { + struct iaddr netmask, subnet, broadcast; + + memcpy (netmask.iabuf, + lease -> options [DHO_SUBNET_MASK].data, + lease -> options [DHO_SUBNET_MASK].len); + netmask.len = lease -> options [DHO_SUBNET_MASK].len; + + subnet = subnet_number (lease -> address, netmask); + if (subnet.len) { + fprintf (scriptFile, "%snetwork_number=\"%s\";\n", + prefix, piaddr (subnet)); + fprintf (scriptFile, "export %snetwork_number\n", + prefix); + + if (!lease -> options [DHO_BROADCAST_ADDRESS].len) { + broadcast = broadcast_addr (subnet, netmask); + if (broadcast.len) { + fprintf (scriptFile, + "%s%s=\"%s\";\n", prefix, + "broadcast_address", + piaddr (broadcast)); + fprintf (scriptFile, + "export %s%s\n", prefix, + "broadcast_address"); + } + } + } + } + + if (lease -> filename) { + fprintf (scriptFile, "%sfilename=\"%s\";\n", + prefix, lease -> filename); + fprintf (scriptFile, "export %sfilename\n", prefix); + } + if (lease -> server_name) { + fprintf (scriptFile, "%sserver_name=\"%s\";\n", + prefix, lease -> server_name); + fprintf (scriptFile, "export %sserver_name\n", prefix); + } + for (i = 0; i < 256; i++) { + u_int8_t *dp; + + if (ip -> client -> config -> defaults [i].len) { + if (lease -> options [i].len) { + switch (ip -> client -> + config -> default_actions [i]) { + case ACTION_DEFAULT: + dp = lease -> options [i].data; + len = lease -> options [i].len; + break; + case ACTION_SUPERSEDE: + supersede: + dp = ip -> client -> + config -> defaults [i].data; + len = ip -> client -> + config -> defaults [i].len; + break; + case ACTION_PREPEND: + len = (ip -> client -> + config -> defaults [i].len + + lease -> options [i].len); + if (len > sizeof dbuf) { + warn ("no space to %s %s", + "prepend option", + dhcp_options [i].name); + goto supersede; + } + dp = dbuf; + memcpy (dp, + ip -> client -> + config -> defaults [i].data, + ip -> client -> + config -> defaults [i].len); + memcpy (dp + ip -> client -> + config -> defaults [i].len, + lease -> options [i].data, + lease -> options [i].len); + break; + case ACTION_APPEND: + len = (ip -> client -> + config -> defaults [i].len + + lease -> options [i].len); + if (len > sizeof dbuf) { + warn ("no space to %s %s", + "prepend option", + dhcp_options [i].name); + goto supersede; + } + dp = dbuf; + memcpy (dp, + ip -> client -> + config -> defaults [i].data, + ip -> client -> + config -> defaults [i].len); + memcpy (dp + ip -> client -> + config -> defaults [i].len, + lease -> options [i].data, + lease -> options [i].len); + } + } else { + dp = ip -> client -> + config -> defaults [i].data; + len = ip -> client -> + config -> defaults [i].len; + } + } else if (lease -> options [i].len) { + len = lease -> options [i].len; + dp = lease -> options [i].data; + } else { + len = 0; + } + if (len) { + char *s = dhcp_option_ev_name (&dhcp_options [i]); + + fprintf (scriptFile, "%s%s=\"%s\"\n", prefix, s, + pretty_print_option (i, dp, len, 0, 0)); + fprintf (scriptFile, "export %s%s\n", prefix, s); + } + } + fprintf (scriptFile, "%sexpiry=\"%d\"\n", + prefix, (int)lease -> expiry); /* XXX */ + fprintf (scriptFile, "export %sexpiry\n", prefix); +} + +int script_go (ip) + struct interface_info *ip; +{ + int rval; + + if (ip) + fprintf (scriptFile, "%s\n", + ip -> client -> config -> script_name); + else + fprintf (scriptFile, "%s\n", + top_level_config.script_name); + fprintf (scriptFile, "exit $?\n"); + fclose (scriptFile); + chmod (scriptName, 0700); + rval = system (scriptName); + if (!save_scripts) + unlink (scriptName); + return rval; +} + +char *dhcp_option_ev_name (option) + struct option *option; +{ + static char evbuf [256]; + int i; + + if (strlen (option -> name) + 1 > sizeof evbuf) + error ("option %s name is larger than static buffer."); + for (i = 0; option -> name [i]; i++) { + if (option -> name [i] == '-') + evbuf [i] = '_'; + else + evbuf [i] = option -> name [i]; + } + + evbuf [i] = 0; + return evbuf; +} + +void go_daemon () +{ + static int state = 0; + int pid; + + /* Don't become a daemon if the user requested otherwise. */ + if (no_daemon) { + write_client_pid_file (); + return; + } + + /* Only do it once. */ + if (state) + return; + state = 1; + + /* Stop logging to stderr... */ + log_perror = 0; + + /* Become a daemon... */ + if ((pid = fork ()) < 0) + error ("Can't fork daemon: %m"); + else if (pid) + exit (0); + /* Become session leader and get pid... */ + pid = setsid (); + + write_client_pid_file (); +} + +void write_client_pid_file () +{ + FILE *pf; + int pfdesc; + + pfdesc = open (path_dhclient_pid, O_CREAT | O_TRUNC | O_WRONLY, 0644); + + if (pfdesc < 0) { + warn ("Can't create %s: %m", path_dhclient_pid); + return; + } + + pf = fdopen (pfdesc, "w"); + if (!pf) + warn ("Can't fdopen %s: %m", path_dhclient_pid); + else { + fprintf (pf, "%ld\n", (long)getpid ()); + fclose (pf); + } +} diff --git a/contrib/isc-dhcp/client/dhclient.conf.5 b/contrib/isc-dhcp/client/dhclient.conf.5 new file mode 100644 index 000000000000..cc16966eb948 --- /dev/null +++ b/contrib/isc-dhcp/client/dhclient.conf.5 @@ -0,0 +1,543 @@ +.\" dhclient.conf.5 +.\" +.\" Copyright (c) 1997 The Internet Software Consortium. +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" 3. Neither the name of The Internet Software Consortium nor the names +.\" of its contributors may be used to endorse or promote products derived +.\" from this software without specific prior written permission. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND +.\" CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, +.\" INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +.\" MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +.\" DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR +.\" CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +.\" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +.\" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF +.\" USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +.\" ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +.\" OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT +.\" OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" This software has been written for the Internet Software Consortium +.\" by Ted Lemon <mellon@fugue.com> in cooperation with Vixie +.\" Enterprises. To learn more about the Internet Software Consortium, +.\" see ``http://www.isc.org/isc''. To learn more about Vixie +.\" Enterprises, see ``http://www.vix.com''. +.TH dhclient.conf 5 +.SH NAME +dhclient.conf - DHCP client configuration file +.SH DESCRIPTION +The dhclient.conf file contains configuration information for +.IR dhclient, +the Internet Software Consortium DHCP Client. +.PP +The dhclient.conf file is a free-form ASCII text file. It is parsed by +the recursive-descent parser built into dhclient. The file may contain +extra tabs and newlines for formatting purposes. Keywords in the file +are case-insensitive. Comments may be placed anywhere within the +file (except within quotes). Comments begin with the # character and +end at the end of the line. +.PP +The dhclient.conf file can be used to configure the behaviour of the +client in a wide variety of ways: protocol timing, information +requested from the server, information required of the server, +defaults to use if the server does not provide certain information, +values with which to override information provided by the server, or +values to prepend or append to information provided by the server. +The configuration file can also be preinitialized with addresses to +use on networks that don't have DHCP servers. +.SH PROTOCOL TIMING +The timing behaviour of the client need not be configured by the user. +If no timing configuration is provided by the user, a fairly +reasonable timing behaviour will be used by default - one which +results in fairly timely updates without placing an inordinate load on +the server. +.PP +The following statements can be used to adjust the timing behaviour of +the DHCP client if required, however: +.PP +.I The +.B timeout +.I statement +.PP +.B timeout +.I time +.B ; +.PP +The +.I timeout +statement determines the amount of time that must pass between the +time that the client begins to try to determine its address and the +time that it decides that it's not going to be able to contact a +server. By default, this timeout is sixty seconds. After the +timeout has passed, if there are any static leases defined in the +configuration file, or any leases remaining in the lease database that +have not yet expired, the client will loop through these leases +attempting to validate them, and if it finds one that appears to be +valid, it will use that lease's address. If there are no valid +static leases or unexpired leases in the lease database, the client +will restart the protocol after the defined retry interval. +.PP +.I The +.B retry +.I statement +.PP + \fBretry \fItime\fR\fB;\fR +.PP +The +.I retry +statement determines the time that must pass after the client has +determined that there is no DHCP server present before it tries again +to contact a DHCP server. By default, this is five minutes. +.PP +.I The +.B select-timeout +.I statement +.PP + \fBselect-timeout \fItime\fR\fB;\fR +.PP +It is possible (some might say desirable) for there to be more than +one DHCP server serving any given network. In this case, it is +possible that a client may be sent more than one offer in response to +its initial lease discovery message. It may be that one of these +offers is preferable to the other (e.g., one offer may have the +address the client previously used, and the other may not). +.PP +The +.I select-timeout +is the time after the client sends its first lease discovery request +at which it stops waiting for offers from servers, assuming that it +has received at least one such offer. If no offers have been +received by the time the +.I select-timeout +has expired, the client will accept the first offer that arrives. +.PP +By default, the select-timeout is zero seconds - that is, the client +will take the first offer it sees. +.PP +.I The +.B reboot +.I statement +.PP + \fBreboot \fItime\fR\fB;\fR +.PP +When the client is restarted, it first tries to reacquire the last +address it had. This is called the INIT-REBOOT state. If it is +still attached to the same network it was attached to when it last +ran, this is the quickest way to get started. The +.I reboot +statement sets the time that must elapse after the client first tries +to reacquire its old address before it gives up and tries to discover +a new address. By default, the reboot timeout is ten seconds. +.PP +.I The +.B backoff-cutoff +.I statement +.PP + \fBbackoff-cutoff \fItime\fR\fB;\fR +.PP +The client uses an exponential backoff algorithm with some randomness, +so that if many clients try to configure themselves at the same time, +they will not make their requests in lockstep. The +.I backoff-cutoff +statement determines the maximum amount of time that the client is +allowed to back off. It defaults to two minutes. +.PP +.I The +.B initial-interval +.I statement +.PP + \fBinitial-interval \fItime\fR\fB;\fR +.PP +The +.I initial-interval +statement sets the amount of time between the first attempt to reach a +server and the second attempt to reach a server. Each time a message +is sent, the interval between messages is incremented by twice the +current interval multiplied by a random number between zero and one. +If it is greater than the backoff-cutoff amount, it is set to that +amount. It defaults to ten seconds. +.SH LEASE REQUIREMENTS AND REQUESTS +The DHCP protocol allows the client to request that the server send it +specific information, and not send it other information that it is not +prepared to accept. The protocol also allows the client to reject +offers from servers if they don't contain information the client +needs, or if the information provided is not satisfactory. +.PP +There is a variety of data contained in offers that DHCP servers send +to DHCP clients. The data that can be specifically requested is what +are called \fIDHCP Options\fR. DHCP Options are defined in + \fBdhcp-options(5)\fR. +.PP +.I The +.B request +.I statement +.PP + \fBrequest [ \fIoption\fR ] [\fB,\fI ... \fIoption\fR ]\fB;\fR +.PP +The request statement causes the client to request that any server +responding to the client send the client its values for the specified +options. Only the option names should be specified in the request +statement - not option parameters. +.PP +.I The +.B require +.I statement +.PP + \fBrequire [ \fIoption\fR ] [\fB,\fI ... \fIoption ]\fB;\fR +.PP +The require statement lists options that must be sent in order for an +offer to be accepted. Offers that do not contain all the listed +options will be ignored. +.PP +.I The +.B send +.I statement +.PP + \fBsend { [ \fIoption declaration\fR ] +[\fB,\fI ... \fIoption declaration\fR ]\fB}\fR +.PP +The send statement causes the client to send the specified options to +the server with the specified values. These are full option +declarations as described in \fBdhcp-options(5)\fR. Options that are +always sent in the DHCP protocol should not be specified here, except +that the client can specify a \fBrequested-lease-time\fR option other +than the default requested lease time, which is two hours. The other +obvious use for this statement is to send information to the server +that will allow it to differentiate between this client and other +clients or kinds of clients. +.SH OPTION MODIFIERS +In some cases, a client may receive option data from the server which +is not really appropriate for that client, or may not receive +information that it needs, and for which a useful default value +exists. It may also receive information which is useful, but which +needs to be supplemented with local information. To handle these +needs, several option modifiers are available. +.PP +.I The +.B default +.I statement +.PP + \fBdefault { [ \fIoption declaration\fR ] +[\fB,\fI ... \fIoption declaration\fR ]\fB}\fR +.PP +If for some set of options the client should use the value supplied by +the server, but needs to use some default value if no value was supplied +by the server, these values can be defined in the +.B default +statement. +.PP +.I The +.B supersede +.I statement +.PP + \fBsupersede { [ \fIoption declaration\fR ] +[\fB,\fI ... \fIoption declaration\fR ]\fB}\fR +.PP +If for some set of options the client should always use its own value +rather than any value supplied by the server, these values can be +defined in the +.B supersede +statement. +.PP +.I The +.B prepend +.I statement +.PP + \fBprepend { [ \fIoption declaration\fR ] +[\fB,\fI ... \fIoption declaration\fR ]\fB}\fR +.PP +If for some set of options the client should first a value it +supplies, and then use the values supplied by +the server, if any, these values can be defined in the +.B prepend +statement. The +.B prepend +statement can only be used for options which +allow more than one value to be given. +.PP +.I The +.B append +.I statement +.PP + \fBappend { [ \fIoption declaration\fR ] +[\fB,\fI ... \fIoption declaration\fR ]\fB}\fR +.PP +If for some set of options the client should first a value it +supplies, and then use the values supplied by +the server, if any, these values can be defined in the +.B append +statement. The +.B append +statement can only be used for options which +allow more than one value to be given. +.SH LEASE DECLARATIONS +.PP +.I The +.B lease +.I declaration +.PP + \fBlease {\fR \fIlease-declaration\fR [ ... \fIlease-declaration ] \fB}\fR +.PP +The DHCP client may decide after some period of time (see \fBPROTOCOL +TIMING\fR) decide that it is not going to succeed in contacting a +server. At that time, it consults its own database of old leases and +tests each one that has not yet timed out by pinging the listed router +for that lease to see if that lease could work. It is possible to +define one or more \fIfixed\fR leases in the client configuration file +for networks where there is no DHCP or BOOTP service, so that the +client can still automatically configure its address. This is done +with the +.B lease +statement. +.PP +NOTE: the lease statement is also used in the dhclient.leases file in +order to record leases that have been received from DHCP servers. +Some of the syntax for leases as described below is only needed in the +dhclient.leases file. Such syntax is documented here for +completeness. +.PP +A lease statement consists of the lease keyword, followed by a left +curly brace, followed by one or more lease declaration statements, +followed by a right curly brace. The following lease declarations +are possible: +.PP + \fBbootp;\fR +.PP +The +.B bootp +statement is used to indicate that the lease was acquired using the +BOOTP protocol rather than the DHCP protocol. It is never necessary +to specify this in the client configuration file. The client uses +this syntax in its lease database file. +.PP + \fBinterface\fR \fB"\fR\fIstring\fR\fB";\fR +.PP +The +.B interface +lease statement is used to indicate the interface on which the lease +is valid. If set, this lease will only be tried on a particular +interface. When the client receives a lease from a server, it always +records the interface number on which it received that lease. +If predefined leases are specified in the dhclient.conf file, the +interface should also be specified, although this is not required. +.PP + \fBfixed-address\fR \fIip-address\fR\fB;\fR +.PP +The +.B fixed-address +statement is used to set the ip address of a particular lease. This +is required for all lease statements. The IP address must be +specified as a dotted quad (e.g., 12.34.56.78). +.PP + \fBfilename "\fR\fIstring\fR\fB";\fR +.PP +The +.B filename +statement specifies the name of the boot filename to use. This is +not used by the standard client configuration script, but is included +for completeness. +.PP + \fBserver-name "\fR\fIstring\fR\fB";\fR +.PP +The +.B server-name +statement specifies the name of the boot server name to use. This is +also not used by the standard client configuration script. +.PP + \fBoption\fR \fIoption-declaration\fR\fB;\fR +.PP +The +.B option +statement is used to specify the value of an option supplied by the +server, or, in the case of predefined leases declared in +dhclient.conf, the value that the user wishes the client configuration +script to use if the predefined lease is used. +.PP + \fBscript "\fIscript-name\fB";\fR +.PP +The +.B script +statement is used to specify the pathname of the dhcp client +configuration script. This script is used by the dhcp client to set +each interface's initial configuration prior to requesting an address, +to test the address once it has been offered, and to set the +interface's final configuration once a lease has been acquired. If +no lease is acquired, the script is used to test predefined leases, if +any, and also called once if no valid lease can be identified. For +more information, see +.B dhclient-lease(8). +.PP + \fBmedium "\fImedia setup\fB";\fR +.PP +The +.B medium +statement can be used on systems where network interfaces cannot +automatically determine the type of network to which they are +connected. The media setup string is a system-dependent parameter +which is passed to the dhcp client configuration script when +initializing the interface. On Unix and Unix-like systems, the +argument is passed on the ifconfig command line when configuring te +interface. +.PP +The dhcp client automatically declares this parameter if it used a +media type (see the +.B media +statement) when configuring the interface in order to obtain a lease. +This statement should be used in predefined leases only if the network +interface requires media type configuration. +.PP + \fBrenew\fR \fIdate\fB;\fR +.PP + \fBrebind\fR \fIdate\fB;\fR +.PP + \fBexpire\fR \fIdate\fB;\fR +.PP +The \fBrenew\fR statement defines the time at which the dhcp client +should begin trying to contact its server to renew a lease that it is +using. The \fBrebind\fR statement defines the time at which the dhcp +client should begin to try to contact \fIany\fR dhcp server in order +to renew its lease. The \fBexpire\fR statement defines the time at +which the dhcp client must stop using a lease if it has not been able +to contact a server in order to renew it. +.PP +These declarations are automatically set in leases acquired by the +DHCP client, but must also be configured in predefined leases - a +predefined lease whose expiry time has passed will not be used by the +DHCP client. +.PP +Dates are specified as follows: +.PP + \fI<weekday> <year>\fB/\fI<month>\fB/\fI<day> +<hour>\fB:\fI<minute>\fB:\fI<second>\fR +.PP +The weekday is present to make it easy for a human to tell when a +lease expires - it's specified as a number from zero to six, with zero +being Sunday. When declaring a predefined lease, it can always be +specified as zero. The year is specified with the century, so it +should generally be four digits except for really long leases. The +month is specified as a number starting with 1 for January. The day +of the month is likewise specified starting with 1. The hour is a +number between 0 and 23, the minute a number between 0 and 69, and the +second also a number between 0 and 69. +.SH ALIAS DECLARATIONS + \fBalias { \fI declarations ... \fB}\fR +.PP +Some DHCP clients running TCP/IP roaming protocols may require that in +addition to the lease they may acquire via DHCP, their interface also +be configured with a predefined IP alias so that they can have a +permanent IP address even while roaming. The Internet Software +Consortium DHCP client doesn't support roaming with fixed addresses +directly, but in order to facilitate such experimentation, the dhcp +client can be set up to configure an IP alias using the +.B alias +declaration. +.PP +The alias declaration resembles a lease declaration, except that +options other than the subnet-mask option are ignored by the standard +client configuration script, and expiry times are ignored. A typical +alias declaration includes an interface declaration, a fixed-address +declaration for the IP alias address, and a subnet-mask option +declaration. A medium statement should never be included in an alias +declaration. +.SH OTHER DECLARATIONS + \fBreject \fIip-address\fB;\fR +.PP +The reject statement causes the DHCP client to reject offers from +servers who use the specified address as a server identifier. This +can be used to avoid being configured by rogue or misconfigured dhcp +servers, although it should be a last resort - better to track down +the bad DHCP server and fix it. +.PP + \fBinterface "\fIname\fB" { \fIdeclarations ... \fB } +.PP +A client with more than one network interface may require different +behaviour depending on which interface is being configured. All +timing parameters and declarations other than lease and alias +declarations can be enclosed in an interface declaration, and those +parameters will then be used only for the interface that matches the +specified name. Interfaces for which there is no interface +declaration will use the parameters declared outside of any interface +declaration, or the default settings. +.PP + \fBmedia "\fImedia setup\fB"\fI [ \fB, "\fImedia setup\fB", \fI... ]\fB;\fR +.PP +The +.B media +statement defines one or more media configuration parameters which may +be tried while attempting to acquire an IP address. The dhcp client +will cycle through each media setup string on the list, configuring +the interface using that setup and attempting to boot, and then trying +the next one. This can be used for network interfaces which aren't +capable of sensing the media type unaided - whichever media type +succeeds in getting a request to the server and hearing the reply is +probably right (no guarantees). +.PP +The media setup is only used for the initial phase of address +acquisition (the DHCPDISCOVER and DHCPOFFER packtes). Once an +address has been acquired, the dhcp client will record it in its lease +database and will record the media type used to acquire the address. +Whenever the client tries to renew the lease, it will use that same +media type. The lease must expire before the client will go back to +cycling through media types. +.SH SAMPLE +The following configuration file is used on a laptop running NetBSD +1.3. The laptop has an IP alias of 192.5.5.213, and has one +interface, ep0 (a 3com 3C589C). Booting intervals have been +shortened somewhat from the default, because the client is known to +spend most of its time on networks with little DHCP activity. The +laptop does roam to multiple networks. + +.nf + +timeout 60; +retry 60; +reboot 10; +select-timeout 5; +initial-interval 2; +reject 192.33.137.209; + +interface "ep0" { + send host-name "andare.fugue.com"; + send dhcp-client-identifier 1:0:a0:24:ab:fb:9c; + send dhcp-lease-time 3600; + supersede domain-name "fugue.com rc.vix.com home.vix.com"; + prepend domain-name-servers 127.0.0.1; + request subnet-mask, broadcast-address, time-offset, routers, + domain-name, domain-name-servers, host-name; + require subnet-mask, domain-name-servers; + script "/sbin/dhclient-script"; + media "media 10baseT/UTP", "media 10base2/BNC"; +} + +alias { + interface "ep0"; + fixed-address 192.5.5.213; + option subnet-mask 255.255.255.255; +} +.fi +This is a very complicated dhclient.conf file - in general, yours +should be much simpler. In many cases, it's sufficient to just +create an empty dhclient.conf file - the defaults are usually fine. +.SH SEE ALSO +dhcp-options(5), dhclient.leases(5), dhclient(8), RFC2132, +RFC2131 +.SH AUTHOR +.B dhclient(8) +was written by Ted Lemon <mellon@vix.com> +under a contract with Vixie Labs. Funding +for this project was provided by the Internet Software Corporation. +Information about the Internet Software Consortium can be found at +.B http://www.isc.org/isc. diff --git a/contrib/isc-dhcp/client/dhclient.leases.5 b/contrib/isc-dhcp/client/dhclient.leases.5 new file mode 100644 index 000000000000..32ef380824af --- /dev/null +++ b/contrib/isc-dhcp/client/dhclient.leases.5 @@ -0,0 +1,62 @@ +.\" dhclient.conf.5 +.\" +.\" Copyright (c) 1997 The Internet Software Consortium. +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" 3. Neither the name of The Internet Software Consortium nor the names +.\" of its contributors may be used to endorse or promote products derived +.\" from this software without specific prior written permission. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND +.\" CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, +.\" INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +.\" MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +.\" DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR +.\" CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +.\" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +.\" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF +.\" USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +.\" ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +.\" OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT +.\" OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" This software has been written for the Internet Software Consortium +.\" by Ted Lemon <mellon@fugue.com> in cooperation with Vixie +.\" Enterprises. To learn more about the Internet Software Consortium, +.\" see ``http://www.isc.org/isc''. To learn more about Vixie +.\" Enterprises, see ``http://www.vix.com''. +.TH dhclient.leases 5 +.SH NAME +dhclient.leases - DHCP client lease database +.SH DESCRIPTION +The Internet Software Consortium DHCP client keeps a persistent +database of leases that it has acquired that are still valid. The +database is a free-form ASCII file containing one valid declaration +per lease. If more than one declaration appears for a given lease, +the last one in the file is used. The file is written as a log, so +this is not an unusual occurrance. +.PP +The format of the lease declarations is described in +.B dhclient.conf(5). +.SH FILES +.B /var/db/dhclient.leases +.SH SEE ALSO +dhcp-options(5), dhclient.conf(5), dhclient(8), +RFC2132, RFC2131 +.SH AUTHOR +.B dhclient(8) +was written by Ted Lemon <mellon@vix.com> +under a contract with Vixie Labs. Funding +for this project was provided by the Internet Software Corporation. +Information about the Internet Software Consortium can be found at +.B http://www.isc.org/isc. diff --git a/contrib/isc-dhcp/client/scripts/freebsd b/contrib/isc-dhcp/client/scripts/freebsd new file mode 100755 index 000000000000..77fdc5c9f26e --- /dev/null +++ b/contrib/isc-dhcp/client/scripts/freebsd @@ -0,0 +1,175 @@ +#!/bin/sh + +if [ x$new_network_number != x ]; then + echo New Network Number: $new_network_number +fi + +if [ x$new_broadcast_address != x ]; then + echo New Broadcast Address: $new_broadcast_address + new_broadcast_arg="broadcast $new_broadcast_address" +fi +if [ x$old_broadcast_address != x ]; then + old_broadcast_arg="broadcast $old_broadcast_address" +fi +if [ x$new_subnet_mask != x ]; then + new_netmask_arg="netmask $new_subnet_mask" +fi +if [ x$old_subnet_mask != x ]; then + old_netmask_arg="netmask $old_subnet_mask" +fi +if [ x$alias_subnet_mask != x ]; then + alias_subnet_arg="netmask $alias_subnet_mask" +fi + +if [ x$reason = xMEDIUM ]; then + ifconfig $interface $medium + ifconfig $interface inet -alias 0.0.0.0 $medium >/dev/null 2>&1 + sleep 1 + exit 0 +fi + +if [ x$reason = xPREINIT ]; then + if [ x$alias_ip_address != x ]; then + ifconfig $interface inet -alias $alias_ip_address > /dev/null 2>&1 + route delete $alias_ip_address 127.0.0.1 > /dev/null 2>&1 + fi + ifconfig $interface inet 0.0.0.0 netmask 0.0.0.0 \ + broadcast 255.255.255.255 up + exit 0 +fi + +if [ x$reason = xARPCHECK ] || [ x$reason = xARPSEND ]; then + exit 0; +fi + +if [ x$reason = xBOUND ] || [ x$reason = xRENEW ] || \ + [ x$reason = xREBIND ] || [ x$reason = xREBOOT ]; then + if [ x$old_ip_address != x ] && [ x$alias_ip_address != x ] && \ + [ x$alias_ip_address != x$old_ip_address ]; then + ifconfig $interface inet -alias $alias_ip_address > /dev/null 2>&1 + route delete $alias_ip_address 127.0.0.1 > /dev/null 2>&1 + fi + if [ x$old_ip_address != x ] && [ x$old_ip_address != x$new_ip_address ]; then + ifconfig $interface inet -alias $old_ip_address $medium + route delete $old_ip_address 127.1 >/dev/null 2>&1 + for router in $old_routers; do + route delete default $router >/dev/null 2>&1 + done + if [ "$old_static_routes" != "" ]; then + set $old_static_routes + while [ $# -gt 1 ]; do + route delete $1 $2 + shift; shift + done + fi + arp -n -a | sed -n -e 's/^.*(\(.*\)) at .*$/arp -n -d \1/p' |sh + fi + if [ x$old_ip_address = x ] || [ x$old_ip_address != x$new_ip_address ] || \ + [ x$reason = xBOUND ] || [ x$reason = xREBOOT ]; then + ifconfig $interface inet $new_ip_address $new_netmask_arg \ + $new_broadcast_arg $medium + route add $new_ip_address 127.1 >/dev/null 2>&1 + for router in $new_routers; do + route add default $router >/dev/null 2>&1 + done + if [ "$new_static_routes" != "" ]; then + set $new_static_routes + while [ $# -gt 1 ]; do + route add $1 $2 + shift; shift + done + fi + fi + if [ x$new_ip_address != x$alias_ip_address ] && [ x$alias_ip_address != x ]; + then + ifconfig $interface inet alias $alias_ip_address $alias_subnet_arg + route add $alias_ip_address 127.0.0.1 + fi + echo search $new_domain_name >/etc/resolv.conf + for nameserver in $new_domain_name_servers; do + echo nameserver $nameserver >>/etc/resolv.conf + done + exit 0 +fi + +if [ x$reason = xEXPIRE ] || [ x$reason = xFAIL ]; then + if [ x$alias_ip_address != x ]; then + ifconfig $interface inet -alias $alias_ip_address > /dev/null 2>&1 + route delete $alias_ip_address 127.0.0.1 > /dev/null 2>&1 + fi + if [ x$old_ip_address != x ]; then + ifconfig $interface inet -alias $old_ip_address $medium + route delete $old_ip_address 127.1 >/dev/null 2>&1 + for router in $old_routers; do + route delete default $router >/dev/null 2>&1 + done + if [ "$old_static_routes" != "" ]; then + set $old_static_routes + while [ $# -gt 1 ]; do + route delete $1 $2 + shift; shift + done + fi + arp -n -a | sed -n -e 's/^.*(\(.*\)) at .*$/arp -n -d \1/p' \ + |sh >/dev/null 2>&1 + fi + if [ x$alias_ip_address != x ]; then + ifconfig $interface inet alias $alias_ip_address $alias_subnet_arg + route add $alias_ip_address 127.0.0.1 + fi + exit 0 +fi + +if [ x$reason = xTIMEOUT ]; then + if [ x$alias_ip_address != x ]; then + ifconfig $interface inet -alias $alias_ip_address > /dev/null 2>&1 + route delete $alias_ip_address 127.0.0.1 > /dev/null 2>&1 + fi + ifconfig $interface inet $new_ip_address $new_netmask_arg \ + $new_broadcast_arg $medium + sleep 1 + if [ "$new_routers" != "" ]; then + set $new_routers + if ping -q -c 1 -w 1 $1; then + if [ x$new_ip_address != x$alias_ip_address ] && \ + [ x$alias_ip_address != x ]; then + ifconfig $interface inet alias $alias_ip_address $alias_subnet_arg + route add $alias_ip_address 127.0.0.1 + fi + route add $new_ip_address 127.1 >/dev/null 2>&1 + for router in $new_routers; do + route add default $router >/dev/null 2>&1 + done + set $new_static_routes + while [ $# -gt 1 ]; do + route add $0 $1 + shift; shift + done + echo search $new_domain_name >/etc/resolv.conf.std + for nameserver in $new_domain_name_servers; do + echo nameserver $nameserver >>/etc/resolv.conf.std + done + if [ -f /etc/resolv.conf ]; then + rm -f /etc/resolv.conf + fi + mv /etc/resolv.conf.std /etc/resolv.conf + exit 0 + fi + fi + ifconfig $interface inet -alias $new_ip_address $medium + for router in $old_routers; do + route delete default $router >/dev/null 2>&1 + done + if [ "$old_static_routes" != "" ]; then + set $old_static_routes + while [ $# -gt 1 ]; do + route delete $1 $2 + shift; shift + done + fi + arp -n -a | sed -n -e 's/^.*(\(.*\)) at .*$/arp -n -d \1/p' \ + |sh >/dev/null 2>&1 + exit 1 +fi + +exit 0 diff --git a/contrib/isc-dhcp/common/alloc.c b/contrib/isc-dhcp/common/alloc.c new file mode 100644 index 000000000000..a9584622a6ba --- /dev/null +++ b/contrib/isc-dhcp/common/alloc.c @@ -0,0 +1,330 @@ +/* alloc.c + + Memory allocation... */ + +/* + * Copyright (c) 1995, 1996, 1998 The Internet Software Consortium. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of The Internet Software Consortium nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND + * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This software has been written for the Internet Software Consortium + * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie + * Enterprises. To learn more about the Internet Software Consortium, + * see ``http://www.vix.com/isc''. To learn more about Vixie + * Enterprises, see ``http://www.vix.com''. + */ + +#ifndef lint +static char copyright[] = +"$Id: alloc.c,v 1.13.2.1 1998/11/24 22:17:15 mellon Exp $ Copyright (c) 1995, 1996 The Internet Software Consortium. All rights reserved.\n"; +#endif /* not lint */ + +#include "dhcpd.h" + +struct dhcp_packet *dhcp_free_list; +struct packet *packet_free_list; + +VOIDPTR dmalloc (size, name) + int size; + char *name; +{ + VOIDPTR foo = (VOIDPTR)malloc (size); + if (!foo) + warn ("No memory for %s.", name); + else + memset (foo, 0, size); + return foo; +} + +void dfree (ptr, name) + VOIDPTR ptr; + char *name; +{ + if (!ptr) { + warn ("dfree %s: free on null pointer.", name); + return; + } + free (ptr); +} + +struct packet *new_packet (name) + char *name; +{ + struct packet *rval; + rval = (struct packet *)dmalloc (sizeof (struct packet), name); + return rval; +} + +struct dhcp_packet *new_dhcp_packet (name) + char *name; +{ + struct dhcp_packet *rval; + rval = (struct dhcp_packet *)dmalloc (sizeof (struct dhcp_packet), + name); + return rval; +} + +struct tree *new_tree (name) + char *name; +{ + struct tree *rval = dmalloc (sizeof (struct tree), name); + return rval; +} + +struct tree_cache *free_tree_caches; + +struct tree_cache *new_tree_cache (name) + char *name; +{ + struct tree_cache *rval; + + if (free_tree_caches) { + rval = free_tree_caches; + free_tree_caches = + (struct tree_cache *)(rval -> value); + } else { + rval = dmalloc (sizeof (struct tree_cache), name); + if (!rval) + error ("unable to allocate tree cache for %s.", name); + } + return rval; +} + +struct hash_table *new_hash_table (count, name) + int count; + char *name; +{ + struct hash_table *rval = dmalloc (sizeof (struct hash_table) + - (DEFAULT_HASH_SIZE + * sizeof (struct hash_bucket *)) + + (count + * sizeof (struct hash_bucket *)), + name); + rval -> hash_count = count; + return rval; +} + +struct hash_bucket *new_hash_bucket (name) + char *name; +{ + struct hash_bucket *rval = dmalloc (sizeof (struct hash_bucket), name); + return rval; +} + +struct lease *new_leases (n, name) + int n; + char *name; +{ + struct lease *rval = dmalloc (n * sizeof (struct lease), name); + return rval; +} + +struct lease *new_lease (name) + char *name; +{ + struct lease *rval = dmalloc (sizeof (struct lease), name); + return rval; +} + +struct subnet *new_subnet (name) + char *name; +{ + struct subnet *rval = dmalloc (sizeof (struct subnet), name); + return rval; +} + +struct class *new_class (name) + char *name; +{ + struct class *rval = dmalloc (sizeof (struct class), name); + return rval; +} + +struct shared_network *new_shared_network (name) + char *name; +{ + struct shared_network *rval = + dmalloc (sizeof (struct shared_network), name); + return rval; +} + +struct group *new_group (name) + char *name; +{ + struct group *rval = + dmalloc (sizeof (struct group), name); + return rval; +} + +struct protocol *new_protocol (name) + char *name; +{ + struct protocol *rval = dmalloc (sizeof (struct protocol), name); + return rval; +} + +struct lease_state *free_lease_states; + +struct lease_state *new_lease_state (name) + char *name; +{ + struct lease_state *rval; + + if (free_lease_states) { + rval = free_lease_states; + free_lease_states = + (struct lease_state *)(free_lease_states -> next); + } else { + rval = dmalloc (sizeof (struct lease_state), name); + } + return rval; +} + +struct domain_search_list *new_domain_search_list (name) + char *name; +{ + struct domain_search_list *rval = + dmalloc (sizeof (struct domain_search_list), name); + return rval; +} + +struct name_server *new_name_server (name) + char *name; +{ + struct name_server *rval = + dmalloc (sizeof (struct name_server), name); + return rval; +} + +void free_name_server (ptr, name) + struct name_server *ptr; + char *name; +{ + dfree ((VOIDPTR)ptr, name); +} + +void free_domain_search_list (ptr, name) + struct domain_search_list *ptr; + char *name; +{ + dfree ((VOIDPTR)ptr, name); +} + +void free_lease_state (ptr, name) + struct lease_state *ptr; + char *name; +{ + ptr -> next = free_lease_states; + free_lease_states = ptr; +} + +void free_protocol (ptr, name) + struct protocol *ptr; + char *name; +{ + dfree ((VOIDPTR)ptr, name); +} + +void free_group (ptr, name) + struct group *ptr; + char *name; +{ + dfree ((VOIDPTR)ptr, name); +} + +void free_shared_network (ptr, name) + struct shared_network *ptr; + char *name; +{ + dfree ((VOIDPTR)ptr, name); +} + +void free_class (ptr, name) + struct class *ptr; + char *name; +{ + dfree ((VOIDPTR)ptr, name); +} + +void free_subnet (ptr, name) + struct subnet *ptr; + char *name; +{ + dfree ((VOIDPTR)ptr, name); +} + +void free_lease (ptr, name) + struct lease *ptr; + char *name; +{ + dfree ((VOIDPTR)ptr, name); +} + +void free_hash_bucket (ptr, name) + struct hash_bucket *ptr; + char *name; +{ + dfree ((VOIDPTR)ptr, name); +} + +void free_hash_table (ptr, name) + struct hash_table *ptr; + char *name; +{ + dfree ((VOIDPTR)ptr, name); +} + +void free_tree_cache (ptr, name) + struct tree_cache *ptr; + char *name; +{ + ptr -> value = (unsigned char *)free_tree_caches; + free_tree_caches = ptr; +} + +void free_packet (ptr, name) + struct packet *ptr; + char *name; +{ + dfree ((VOIDPTR)ptr, name); +} + +void free_dhcp_packet (ptr, name) + struct dhcp_packet *ptr; + char *name; +{ + dfree ((VOIDPTR)ptr, name); +} + +void free_tree (ptr, name) + struct tree *ptr; + char *name; +{ + dfree ((VOIDPTR)ptr, name); +} diff --git a/contrib/isc-dhcp/common/bpf.c b/contrib/isc-dhcp/common/bpf.c new file mode 100644 index 000000000000..ba42a43903cd --- /dev/null +++ b/contrib/isc-dhcp/common/bpf.c @@ -0,0 +1,425 @@ +/* bpf.c + + BPF socket interface code, originally contributed by Archie Cobbs. */ + +/* + * Copyright (c) 1995, 1996, 1998, 1999 + * The Internet Software Consortium. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of The Internet Software Consortium nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND + * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This software has been written for the Internet Software Consortium + * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie + * Enterprises. To learn more about the Internet Software Consortium, + * see ``http://www.vix.com/isc''. To learn more about Vixie + * Enterprises, see ``http://www.vix.com''. + */ + +#ifndef lint +static char copyright[] = +"$Id: bpf.c,v 1.19.2.6 1999/02/09 04:46:59 mellon Exp $ Copyright (c) 1995, 1996, 1998, 1999 The Internet Software Consortium. All rights reserved.\n"; +#endif /* not lint */ + +#include "dhcpd.h" +#if defined (USE_BPF_SEND) || defined (USE_BPF_RECEIVE) \ + || defined (USE_LPF_RECEIVE) +# if defined (USE_LPF_RECEIVE) +# include <asm/types.h> +# include <linux/filter.h> +# define bpf_insn sock_filter /* Linux: dare to be gratuitously different. */ +# else +# include <sys/ioctl.h> +# include <sys/uio.h> + +# include <net/bpf.h> +# if defined (NEED_OSF_PFILT_HACKS) +# include <net/pfilt.h> +# endif +# endif + +#include <netinet/in_systm.h> +#include "includes/netinet/ip.h" +#include "includes/netinet/udp.h" +#include "includes/netinet/if_ether.h" +#endif + +/* Reinitializes the specified interface after an address change. This + is not required for packet-filter APIs. */ + +#ifdef USE_BPF_SEND +void if_reinitialize_send (info) + struct interface_info *info; +{ +} +#endif + +#ifdef USE_BPF_RECEIVE +void if_reinitialize_receive (info) + struct interface_info *info; +{ +} +#endif + +/* Called by get_interface_list for each interface that's discovered. + Opens a packet filter for each interface and adds it to the select + mask. */ + +#if defined (USE_BPF_SEND) || defined (USE_BPF_RECEIVE) +int if_register_bpf (info) + struct interface_info *info; +{ + int sock; + char filename[50]; + int b; + + /* Open a BPF device */ + for (b = 0; 1; b++) { +#ifndef NO_SNPRINTF + snprintf(filename, sizeof(filename), BPF_FORMAT, b); +#else + sprintf(filename, BPF_FORMAT, b); +#endif + sock = open (filename, O_RDWR, 0); + if (sock < 0) { + if (errno == EBUSY) { + continue; + } else { + if (!b) + error ("No bpf devices.%s%s%s", + " Please read the README", + " section for your operating", + " system."); + error ("Can't find free bpf: %m"); + } + } else { + break; + } + } + + /* Set the BPF device to point at this interface. */ + if (ioctl (sock, BIOCSETIF, info -> ifp) < 0) + error ("Can't attach interface %s to bpf device %s: %m", + info -> name, filename); + + return sock; +} +#endif /* USE_BPF_SEND || USE_BPF_RECEIVE */ + +#ifdef USE_BPF_SEND +void if_register_send (info) + struct interface_info *info; +{ + /* If we're using the bpf API for sending and receiving, + we don't need to register this interface twice. */ +#ifndef USE_BPF_RECEIVE + info -> wfdesc = if_register_bpf (info, interface); +#else + info -> wfdesc = info -> rfdesc; +#endif + if (!quiet_interface_discovery) + note ("Sending on BPF/%s/%s/%s", + info -> name, + print_hw_addr (info -> hw_address.htype, + info -> hw_address.hlen, + info -> hw_address.haddr), + (info -> shared_network ? + info -> shared_network -> name : "unattached")); +} +#endif /* USE_BPF_SEND */ + +#if defined (USE_BPF_RECEIVE) || defined (USE_LPF_RECEIVE) +/* Packet filter program... + XXX Changes to the filter program may require changes to the constant + offsets used in if_register_send to patch the BPF program! XXX */ + +struct bpf_insn dhcp_bpf_filter [] = { + /* Make sure this is an IP packet... */ + BPF_STMT (BPF_LD + BPF_H + BPF_ABS, 12), + BPF_JUMP (BPF_JMP + BPF_JEQ + BPF_K, ETHERTYPE_IP, 0, 8), + + /* Make sure it's a UDP packet... */ + BPF_STMT (BPF_LD + BPF_B + BPF_ABS, 23), + BPF_JUMP (BPF_JMP + BPF_JEQ + BPF_K, IPPROTO_UDP, 0, 6), + + /* Make sure this isn't a fragment... */ + BPF_STMT(BPF_LD + BPF_H + BPF_ABS, 20), + BPF_JUMP(BPF_JMP + BPF_JSET + BPF_K, 0x1fff, 4, 0), + + /* Get the IP header length... */ + BPF_STMT (BPF_LDX + BPF_B + BPF_MSH, 14), + + /* Make sure it's to the right port... */ + BPF_STMT (BPF_LD + BPF_H + BPF_IND, 16), + BPF_JUMP (BPF_JMP + BPF_JEQ + BPF_K, 67, 0, 1), /* patch */ + + /* If we passed all the tests, ask for the whole packet. */ + BPF_STMT(BPF_RET+BPF_K, (u_int)-1), + + /* Otherwise, drop it. */ + BPF_STMT(BPF_RET+BPF_K, 0), +}; + +int dhcp_bpf_filter_len = sizeof dhcp_bpf_filter / sizeof (struct bpf_insn); +#endif + +#if defined (USE_BPF_RECEIVE) +void if_register_receive (info) + struct interface_info *info; +{ + int flag = 1; + struct bpf_version v; + u_int32_t addr; + struct bpf_program p; + u_int32_t bits; + + /* Open a BPF device and hang it on this interface... */ + info -> rfdesc = if_register_bpf (info); + + /* Make sure the BPF version is in range... */ + if (ioctl (info -> rfdesc, BIOCVERSION, &v) < 0) + error ("Can't get BPF version: %m"); + + if (v.bv_major != BPF_MAJOR_VERSION || + v.bv_minor < BPF_MINOR_VERSION) + error ("Kernel BPF version out of range - recompile dhcpd!"); + + /* Set immediate mode so that reads return as soon as a packet + comes in, rather than waiting for the input buffer to fill with + packets. */ + if (ioctl (info -> rfdesc, BIOCIMMEDIATE, &flag) < 0) + error ("Can't set immediate mode on bpf device: %m"); + +#ifdef NEED_OSF_PFILT_HACKS + /* Allow the copyall flag to be set... */ + if (ioctl(info -> rfdesc, EIOCALLOWCOPYALL, &flag) < 0) + error ("Can't set ALLOWCOPYALL: %m"); + + /* Clear all the packet filter mode bits first... */ + bits = 0; + if (ioctl (info -> rfdesc, EIOCMBIS, &bits) < 0) + error ("Can't clear pfilt bits: %m"); + + /* Set the ENBATCH, ENCOPYALL, ENBPFHDR bits... */ + bits = ENBATCH | ENCOPYALL | ENBPFHDR; + if (ioctl (info -> rfdesc, EIOCMBIS, &bits) < 0) + error ("Can't set ENBATCH|ENCOPYALL|ENBPFHDR: %m"); +#endif + /* Get the required BPF buffer length from the kernel. */ + if (ioctl (info -> rfdesc, BIOCGBLEN, &info -> rbuf_max) < 0) + error ("Can't get bpf buffer length: %m"); + info -> rbuf = malloc (info -> rbuf_max); + if (!info -> rbuf) + error ("Can't allocate %d bytes for bpf input buffer."); + info -> rbuf_offset = 0; + info -> rbuf_len = 0; + + /* Set up the bpf filter program structure. */ + p.bf_len = dhcp_bpf_filter_len; + p.bf_insns = dhcp_bpf_filter; + + /* Patch the server port into the BPF program... + XXX changes to filter program may require changes + to the insn number(s) used below! XXX */ + dhcp_bpf_filter [8].k = ntohs (local_port); + + if (ioctl (info -> rfdesc, BIOCSETF, &p) < 0) + error ("Can't install packet filter program: %m"); + if (!quiet_interface_discovery) + note ("Listening on BPF/%s/%s/%s", + info -> name, + print_hw_addr (info -> hw_address.htype, + info -> hw_address.hlen, + info -> hw_address.haddr), + (info -> shared_network ? + info -> shared_network -> name : "unattached")); +} +#endif /* USE_BPF_RECEIVE */ + +#ifdef USE_BPF_SEND +ssize_t send_packet (interface, packet, raw, len, from, to, hto) + struct interface_info *interface; + struct packet *packet; + struct dhcp_packet *raw; + size_t len; + struct in_addr from; + struct sockaddr_in *to; + struct hardware *hto; +{ + int bufp = 0; + unsigned char buf [256]; + struct iovec iov [2]; + + if (!strcmp (interface -> name, "fallback")) + return send_fallback (interface, packet, raw, + len, from, to, hto); + + /* Assemble the headers... */ + assemble_hw_header (interface, buf, &bufp, hto); + assemble_udp_ip_header (interface, buf, &bufp, from.s_addr, + to -> sin_addr.s_addr, to -> sin_port, + (unsigned char *)raw, len); + + /* Fire it off */ + iov [0].iov_base = (char *)buf; + iov [0].iov_len = bufp; + iov [1].iov_base = (char *)raw; + iov [1].iov_len = len; + + return writev(interface -> wfdesc, iov, 2); +} +#endif /* USE_BPF_SEND */ + +#ifdef USE_BPF_RECEIVE +ssize_t receive_packet (interface, buf, len, from, hfrom) + struct interface_info *interface; + unsigned char *buf; + size_t len; + struct sockaddr_in *from; + struct hardware *hfrom; +{ + int length = 0; + int offset = 0; + struct bpf_hdr hdr; + + /* All this complexity is because BPF doesn't guarantee + that only one packet will be returned at a time. We're + getting what we deserve, though - this is a terrible abuse + of the BPF interface. Sigh. */ + + /* Process packets until we get one we can return or until we've + done a read and gotten nothing we can return... */ + + do { + /* If the buffer is empty, fill it. */ + if (interface -> rbuf_offset == interface -> rbuf_len) { + length = read (interface -> rfdesc, + interface -> rbuf, + interface -> rbuf_max); + if (length <= 0) + return length; + interface -> rbuf_offset = 0; + interface -> rbuf_len = length; + } + + /* If there isn't room for a whole bpf header, something went + wrong, but we'll ignore it and hope it goes away... XXX */ + if (interface -> rbuf_len - + interface -> rbuf_offset < sizeof hdr) { + interface -> rbuf_offset = interface -> rbuf_len; + continue; + } + + /* Copy out a bpf header... */ + memcpy (&hdr, &interface -> rbuf [interface -> rbuf_offset], + sizeof hdr); + + /* If the bpf header plus data doesn't fit in what's left + of the buffer, stick head in sand yet again... */ + if (interface -> rbuf_offset + + hdr.bh_hdrlen + hdr.bh_caplen > interface -> rbuf_len) { + interface -> rbuf_offset = interface -> rbuf_len; + continue; + } + + /* If the captured data wasn't the whole packet, or if + the packet won't fit in the input buffer, all we + can do is drop it. */ + if (hdr.bh_caplen != hdr.bh_datalen) { + interface -> rbuf_offset += + hdr.bh_hdrlen = hdr.bh_caplen; + continue; + } + + /* Skip over the BPF header... */ + interface -> rbuf_offset += hdr.bh_hdrlen; + + /* Decode the physical header... */ + offset = decode_hw_header (interface, + interface -> rbuf, + interface -> rbuf_offset, + hfrom); + + /* If a physical layer checksum failed (dunno of any + physical layer that supports this, but WTH), skip this + packet. */ + if (offset < 0) { + interface -> rbuf_offset += hdr.bh_caplen; + continue; + } + interface -> rbuf_offset += offset; + hdr.bh_caplen -= offset; + + /* Decode the IP and UDP headers... */ + offset = decode_udp_ip_header (interface, + interface -> rbuf, + interface -> rbuf_offset, + from, + (unsigned char *)0, + hdr.bh_caplen); + + /* If the IP or UDP checksum was bad, skip the packet... */ + if (offset < 0) { + interface -> rbuf_offset += hdr.bh_caplen; + continue; + } + interface -> rbuf_offset += offset; + hdr.bh_caplen -= offset; + + /* If there's not enough room to stash the packet data, + we have to skip it (this shouldn't happen in real + life, though). */ + if (hdr.bh_caplen > len) { + interface -> rbuf_offset += hdr.bh_caplen; + continue; + } + + /* Copy out the data in the packet... */ + memcpy (buf, interface -> rbuf + interface -> rbuf_offset, + hdr.bh_caplen); + interface -> rbuf_offset += hdr.bh_caplen; + return hdr.bh_caplen; + } while (!length); + return 0; +} + +int can_unicast_without_arp () +{ + return 1; +} + +void maybe_setup_fallback () +{ + struct interface_info *fbi; + fbi = setup_fallback (); + if (fbi) { + if_register_fallback (fbi); + add_protocol ("fallback", fallback_interface -> wfdesc, + fallback_discard, fallback_interface); + } +} +#endif diff --git a/contrib/isc-dhcp/common/conflex.c b/contrib/isc-dhcp/common/conflex.c new file mode 100644 index 000000000000..c84daad6bcb8 --- /dev/null +++ b/contrib/isc-dhcp/common/conflex.c @@ -0,0 +1,560 @@ +/* conflex.c + + Lexical scanner for dhcpd config file... */ + +/* + * Copyright (c) 1995, 1996, 1997 The Internet Software Consortium. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of The Internet Software Consortium nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND + * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This software has been written for the Internet Software Consortium + * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie + * Enterprises. To learn more about the Internet Software Consortium, + * see ``http://www.vix.com/isc''. To learn more about Vixie + * Enterprises, see ``http://www.vix.com''. + */ + +#ifndef lint +static char copyright[] = +"$Id: conflex.c,v 1.29.2.3 1999/02/09 04:49:04 mellon Exp $ Copyright (c) 1995, 1996, 1997 The Internet Software Consortium. All rights reserved.\n"; +#endif /* not lint */ + +#include "dhcpd.h" +#include "dhctoken.h" +#include <ctype.h> + +int lexline; +int lexchar; +char *token_line; +char *prev_line; +char *cur_line; +char *tlname; +int eol_token; + +static char line1 [81]; +static char line2 [81]; +static int lpos; +static int line; +static int tlpos; +static int tline; +static int token; +static int ugflag; +static char *tval; +static char tokbuf [1500]; + +#ifdef OLD_LEXER +char comments [4096]; +int comment_index; +#endif + + +static int get_char PROTO ((FILE *)); +static int get_token PROTO ((FILE *)); +static void skip_to_eol PROTO ((FILE *)); +static int read_string PROTO ((FILE *)); +static int read_number PROTO ((int, FILE *)); +static int read_num_or_name PROTO ((int, FILE *)); +static int intern PROTO ((char *, int)); + +void new_parse (name) + char *name; +{ + tlname = name; + lpos = line = 1; + cur_line = line1; + prev_line = line2; + token_line = cur_line; + cur_line [0] = prev_line [0] = 0; + warnings_occurred = 0; +} + +static int get_char (cfile) + FILE *cfile; +{ + int c = getc (cfile); + if (!ugflag) { + if (c == EOL) { + if (cur_line == line1) { + cur_line = line2; + prev_line = line1; + } else { + cur_line = line2; + prev_line = line1; + } + line++; + lpos = 1; + cur_line [0] = 0; + } else if (c != EOF) { + if (lpos <= 81) { + cur_line [lpos - 1] = c; + cur_line [lpos] = 0; + } + lpos++; + } + } else + ugflag = 0; + return c; +} + +static int get_token (cfile) + FILE *cfile; +{ + int c; + int ttok; + static char tb [2]; + int l, p, u; + + do { + l = line; + p = lpos; + u = ugflag; + + c = get_char (cfile); +#ifdef OLD_LEXER + if (c == '\n' && p == 1 && !u + && comment_index < sizeof comments) + comments [comment_index++] = '\n'; +#endif + + if (!(c == '\n' && eol_token) && isascii (c) && isspace (c)) + continue; + if (c == '#') { +#ifdef OLD_LEXER + if (comment_index < sizeof comments) + comments [comment_index++] = '#'; +#endif + skip_to_eol (cfile); + continue; + } + if (c == '"') { + lexline = l; + lexchar = p; + ttok = read_string (cfile); + break; + } + if ((isascii (c) && isdigit (c)) || c == '-') { + lexline = l; + lexchar = p; + ttok = read_number (c, cfile); + break; + } else if (isascii (c) && isalpha (c)) { + lexline = l; + lexchar = p; + ttok = read_num_or_name (c, cfile); + break; + } else { + lexline = l; + lexchar = p; + tb [0] = c; + tb [1] = 0; + tval = tb; + ttok = c; + break; + } + } while (1); + return ttok; +} + +int next_token (rval, cfile) + char **rval; + FILE *cfile; +{ + int rv; + + if (token) { + if (lexline != tline) + token_line = cur_line; + lexchar = tlpos; + lexline = tline; + rv = token; + token = 0; + } else { + rv = get_token (cfile); + token_line = cur_line; + } + if (rval) + *rval = tval; +#ifdef DEBUG_TOKENS + fprintf (stderr, "%s:%d ", tval, rv); +#endif + return rv; +} + +int peek_token (rval, cfile) + char **rval; + FILE *cfile; +{ + int x; + + if (!token) { + tlpos = lexchar; + tline = lexline; + token = get_token (cfile); + if (lexline != tline) + token_line = prev_line; + x = lexchar; lexchar = tlpos; tlpos = x; + x = lexline; lexline = tline; tline = x; + } + if (rval) + *rval = tval; +#ifdef DEBUG_TOKENS + fprintf (stderr, "(%s:%d) ", tval, token); +#endif + return token; +} + +static void skip_to_eol (cfile) + FILE *cfile; +{ + int c; + do { + c = get_char (cfile); + if (c == EOF) + return; +#ifdef OLD_LEXER + if (comment_index < sizeof (comments)) + comments [comment_index++] = c; +#endif + if (c == EOL) { + return; + } + } while (1); +} + +static int read_string (cfile) + FILE *cfile; +{ + int i; + int bs = 0; + int c; + + for (i = 0; i < sizeof tokbuf; i++) { + c = get_char (cfile); + if (c == EOF) { + parse_warn ("eof in string constant"); + break; + } + if (bs) { + bs = 0; + tokbuf [i] = c; + } else if (c == '\\') + bs = 1; + else if (c == '"') + break; + else + tokbuf [i] = c; + } + /* Normally, I'd feel guilty about this, but we're talking about + strings that'll fit in a DHCP packet here... */ + if (i == sizeof tokbuf) { + parse_warn ("string constant larger than internal buffer"); + --i; + } + tokbuf [i] = 0; + tval = tokbuf; + return STRING; +} + +static int read_number (c, cfile) + int c; + FILE *cfile; +{ + int seenx = 0; + int i = 0; + int token = NUMBER; + + tokbuf [i++] = c; + for (; i < sizeof tokbuf; i++) { + c = get_char (cfile); + if (!seenx && c == 'x') { + seenx = 1; +#ifndef OLD_LEXER + } else if (isascii (c) && !isxdigit (c) && + (c == '-' || c == '_' || isalpha (c))) { + token = NAME; + } else if (isascii (c) && !isdigit (c) && isxdigit (c)) { + token = NUMBER_OR_NAME; +#endif + } else if (!isascii (c) || !isxdigit (c)) { + ungetc (c, cfile); + ugflag = 1; + break; + } + tokbuf [i] = c; + } + if (i == sizeof tokbuf) { + parse_warn ("numeric token larger than internal buffer"); + --i; + } + tokbuf [i] = 0; + tval = tokbuf; + return token; +} + +static int read_num_or_name (c, cfile) + int c; + FILE *cfile; +{ + int i = 0; + int rv = NUMBER_OR_NAME; + tokbuf [i++] = c; + for (; i < sizeof tokbuf; i++) { + c = get_char (cfile); + if (!isascii (c) || + (c != '-' && c != '_' && !isalnum (c))) { + ungetc (c, cfile); + ugflag = 1; + break; + } + if (!isxdigit (c)) + rv = NAME; + tokbuf [i] = c; + } + if (i == sizeof tokbuf) { + parse_warn ("token larger than internal buffer"); + --i; + } + tokbuf [i] = 0; + tval = tokbuf; + return intern (tval, rv); +} + +static int intern (atom, dfv) + char *atom; + int dfv; +{ + if (!isascii (atom [0])) + return dfv; + + switch (tolower (atom [0])) { + case 'a': + if (!strcasecmp (atom + 1, "ppend")) + return APPEND; + if (!strcasecmp (atom + 1, "llow")) + return ALLOW; + if (!strcasecmp (atom + 1, "lias")) + return ALIAS; + if (!strcasecmp (atom + 1, "bandoned")) + return ABANDONED; + if (!strcasecmp (atom + 1, "uthoritative")) + return AUTHORITATIVE; + break; + case 'b': + if (!strcasecmp (atom + 1, "ackoff-cutoff")) + return BACKOFF_CUTOFF; + if (!strcasecmp (atom + 1, "ootp")) + return BOOTP; + if (!strcasecmp (atom + 1, "ooting")) + return BOOTING; + if (!strcasecmp (atom + 1, "oot-unknown-clients")) + return BOOT_UNKNOWN_CLIENTS; + case 'c': + if (!strcasecmp (atom + 1, "lass")) + return CLASS; + if (!strcasecmp (atom + 1, "iaddr")) + return CIADDR; + if (!strcasecmp (atom + 1, "lient-identifier")) + return CLIENT_IDENTIFIER; + if (!strcasecmp (atom + 1, "lient-hostname")) + return CLIENT_HOSTNAME; + break; + case 'd': + if (!strcasecmp (atom + 1, "omain")) + return DOMAIN; + if (!strcasecmp (atom + 1, "eny")) + return DENY; + if (!strncasecmp (atom + 1, "efault", 6)) { + if (!atom [7]) + return DEFAULT; + if (!strcasecmp (atom + 7, "-lease-time")) + return DEFAULT_LEASE_TIME; + break; + } + if (!strncasecmp (atom + 1, "ynamic-bootp", 12)) { + if (!atom [13]) + return DYNAMIC_BOOTP; + if (!strcasecmp (atom + 13, "-lease-cutoff")) + return DYNAMIC_BOOTP_LEASE_CUTOFF; + if (!strcasecmp (atom + 13, "-lease-length")) + return DYNAMIC_BOOTP_LEASE_LENGTH; + break; + } + break; + case 'e': + if (!strcasecmp (atom + 1, "thernet")) + return ETHERNET; + if (!strcasecmp (atom + 1, "nds")) + return ENDS; + if (!strcasecmp (atom + 1, "xpire")) + return EXPIRE; + break; + case 'f': + if (!strcasecmp (atom + 1, "ilename")) + return FILENAME; + if (!strcasecmp (atom + 1, "ixed-address")) + return FIXED_ADDR; + if (!strcasecmp (atom + 1, "ddi")) + return FDDI; + break; + case 'g': + if (!strcasecmp (atom + 1, "iaddr")) + return GIADDR; + if (!strcasecmp (atom + 1, "roup")) + return GROUP; + if (!strcasecmp (atom + 1, "et-lease-hostnames")) + return GET_LEASE_HOSTNAMES; + break; + case 'h': + if (!strcasecmp (atom + 1, "ost")) + return HOST; + if (!strcasecmp (atom + 1, "ardware")) + return HARDWARE; + if (!strcasecmp (atom + 1, "ostname")) + return HOSTNAME; + break; + case 'i': + if (!strcasecmp (atom + 1, "nitial-interval")) + return INITIAL_INTERVAL; + if (!strcasecmp (atom + 1, "nterface")) + return INTERFACE; + break; + case 'l': + if (!strcasecmp (atom + 1, "ease")) + return LEASE; + break; + case 'm': + if (!strcasecmp (atom + 1, "ax-lease-time")) + return MAX_LEASE_TIME; + if (!strncasecmp (atom + 1, "edi", 3)) { + if (!strcasecmp (atom + 4, "a")) + return MEDIA; + if (!strcasecmp (atom + 4, "um")) + return MEDIUM; + break; + } + break; + case 'n': + if (!strcasecmp (atom + 1, "ameserver")) + return NAMESERVER; + if (!strcasecmp (atom + 1, "etmask")) + return NETMASK; + if (!strcasecmp (atom + 1, "ext-server")) + return NEXT_SERVER; + if (!strcasecmp (atom + 1, "ot")) + return TOKEN_NOT; + break; + case 'o': + if (!strcasecmp (atom + 1, "ption")) + return OPTION; + if (!strcasecmp (atom + 1, "ne-lease-per-client")) + return ONE_LEASE_PER_CLIENT; + break; + case 'p': + if (!strcasecmp (atom + 1, "repend")) + return PREPEND; + if (!strcasecmp (atom + 1, "acket")) + return PACKET; + break; + case 'r': + if (!strcasecmp (atom + 1, "ange")) + return RANGE; + if (!strcasecmp (atom + 1, "equest")) + return REQUEST; + if (!strcasecmp (atom + 1, "equire")) + return REQUIRE; + if (!strcasecmp (atom + 1, "etry")) + return RETRY; + if (!strcasecmp (atom + 1, "enew")) + return RENEW; + if (!strcasecmp (atom + 1, "ebind")) + return REBIND; + if (!strcasecmp (atom + 1, "eboot")) + return REBOOT; + if (!strcasecmp (atom + 1, "eject")) + return REJECT; + break; + case 's': + if (!strcasecmp (atom + 1, "earch")) + return SEARCH; + if (!strcasecmp (atom + 1, "tarts")) + return STARTS; + if (!strcasecmp (atom + 1, "iaddr")) + return SIADDR; + if (!strcasecmp (atom + 1, "ubnet")) + return SUBNET; + if (!strcasecmp (atom + 1, "hared-network")) + return SHARED_NETWORK; + if (!strcasecmp (atom + 1, "erver-name")) + return SERVER_NAME; + if (!strcasecmp (atom + 1, "erver-identifier")) + return SERVER_IDENTIFIER; + if (!strcasecmp (atom + 1, "elect-timeout")) + return SELECT_TIMEOUT; + if (!strcasecmp (atom + 1, "end")) + return SEND; + if (!strcasecmp (atom + 1, "cript")) + return SCRIPT; + if (!strcasecmp (atom + 1, "upersede")) + return SUPERSEDE; + break; + case 't': + if (!strcasecmp (atom + 1, "imestamp")) + return TIMESTAMP; + if (!strcasecmp (atom + 1, "imeout")) + return TIMEOUT; + if (!strcasecmp (atom + 1, "oken-ring")) + return TOKEN_RING; + break; + case 'u': + if (!strncasecmp (atom + 1, "se", 2)) { + if (!strcasecmp (atom + 3, "r-class")) + return USER_CLASS; + if (!strcasecmp (atom + 3, "-host-decl-names")) + return USE_HOST_DECL_NAMES; + if (!strcasecmp (atom + 3, + "-lease-addr-for-default-route")) + return USE_LEASE_ADDR_FOR_DEFAULT_ROUTE; + break; + } + if (!strcasecmp (atom + 1, "id")) + return UID; + if (!strcasecmp (atom + 1, "nknown-clients")) + return UNKNOWN_CLIENTS; + break; + case 'v': + if (!strcasecmp (atom + 1, "endor-class")) + return VENDOR_CLASS; + break; + case 'y': + if (!strcasecmp (atom + 1, "iaddr")) + return YIADDR; + break; + } + return dfv; +} diff --git a/contrib/isc-dhcp/common/dhcp-options.5 b/contrib/isc-dhcp/common/dhcp-options.5 new file mode 100644 index 000000000000..3375c507f14d --- /dev/null +++ b/contrib/isc-dhcp/common/dhcp-options.5 @@ -0,0 +1,581 @@ +.\" dhcp-options.5 +.\" +.\" Copyright (c) 1995, 1996, 1997, 1998 The Internet Software Consortium. +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" 3. Neither the name of The Internet Software Consortium nor the names +.\" of its contributors may be used to endorse or promote products derived +.\" from this software without specific prior written permission. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND +.\" CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, +.\" INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +.\" MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +.\" DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR +.\" CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +.\" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +.\" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF +.\" USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +.\" ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +.\" OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT +.\" OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" This software has been written for the Internet Software Consortium +.\" by Ted Lemon <mellon@fugue.com> in cooperation with Vixie +.\" Enterprises. To learn more about the Internet Software Consortium, +.\" see ``http://www.isc.org/isc''. To learn more about Vixie +.\" Enterprises, see ``http://www.vix.com''. +.TH dhcpd-options 5 +.SH NAME +dhcp-options - Dynamic Host Configuration Protocol options +.SH DESCRIPTION +The Dynamic Host Configuration protocol allows the client to receive +.B options +from the DHCP server describing the network configuration and various +services that are available on the network. When configuring +.B dhcpd(8) +or +.B dhclient(8) , +options must often be declared. The syntax for declaring options, +and the names and formats of the options that can be declared, are +documented here. +.SH REFERENCE: OPTION STATEMENTS +.PP +DHCP \fIoption\fR statements always start with the \fIoption\fR +keyword, followed by an option name, followed by option data. The +option names and data formats are described below. It is not +necessary to exhaustively specify all DHCP options - only those +options which are needed by clients must be specified. +.PP +Option data comes in a variety of formats, as defined below: +.PP +The +.B ip-address +data type can be entered either as an explicit IP +address (e.g., 239.254.197.10) or as a domain name (e.g., +haagen.isc.org). When entering a domain name, be sure that that +domain name resolves to a single IP address. +.PP +The +.B int32 +data type specifies a signed 32-bit integer. The +.B uint32 +data type specifies an unsigned 32-bit integer. The +.B int16 +and +.B uint16 +data types specify signed and unsigned 16-bit integers. The +.B int8 +and +.B uint8 +data types specify signed and unsigned 8-bit integers. +Unsigned 8-bit integers are also sometimes referred to as octets. +.PP +The +.B string +data type specifies an NVT ASCII string, which must be +enclosed in double quotes - for example, to specify a domain-name +option, the syntax would be +.nf +.sp 1 + option domain-name "isc.org"; +.fi +.PP +The +.B flag +data type specifies a boolean value. Booleans can be either true or +false (or on or off, if that makes more sense to you). +.PP +The +.B data-string +data type specifies either an NVT ASCII string +enclosed in double quotes, or a series of octets specified in +hexadecimal, seperated by colons. For example: +.nf +.sp 1 + option client-identifier "CLIENT-FOO"; +or + option client-identifier 43:4c:49:45:54:2d:46:4f:4f; +.fi +.PP +The documentation for the various options mentioned below is taken +from the latest IETF draft document on DHCP options. Options which +are not listed by name may be defined by the name option-\fInnn\fR, +where \fInnn\fI is the decimal number of the option code. These +options may be followed either by a string, enclosed in quotes, or by +a series of octets, expressed as two-digit hexadecimal numbers seperated +by colons. For example: +.PP +.nf + option option-133 "my-option-133-text"; + option option-129 1:54:c9:2b:47; +.fi +.PP +Because dhcpd does not know the format of these undefined option codes, +no checking is done to ensure the correctness of the entered data. +.PP +The standard options are: +.PP +.B option subnet-mask \fIip-address\fR\fB;\fR +.RS 0.25i +.PP +The subnet mask option specifies the client's subnet mask as per RFC +950. If no subnet mask option is provided anywhere in scope, as a +last resort dhcpd will use the subnet mask from the subnet declaration +for the network on which an address is being assigned. However, +.I any +subnet-mask option declaration that is in scope for the address being +assigned will override the subnet mask specified in the subnet +declaration. +.RE +.PP +.B option time-offset \fIint32\fR\fB;\fR +.RS 0.25i +.PP +The time-offset option specifies the offset of the client's subnet in +seconds from Coordinated Universal Time (UTC). +.RE +.PP +.B option routers \fIip-address\fR [\fB,\fR \fIip-address\fR... +]\fB;\fR +.RS 0.25i +.PP +The routers option specifies a list of IP addresses for routers on the +client's subnet. Routers should be listed in order of preference. +.RE +.PP +.B option time-servers \fIip-address\fR [, \fIip-address\fR... +]\fB;\fR +.RS 0.25i +.PP +The time-server option specifies a list of RFC 868 time servers +available to the client. Servers should be listed in order of +preference. +.RE +.PP +.B option \fBien116-name-servers\fR \fIip-address\fR [\fB,\fR \fIip-address\fR... +]; +.RS 0.25i +.PP +The ien116-name-servers option specifies a list of IEN 116 name servers +available to the client. Servers should be listed in order of +preference. +.RE +.PP +.B option \fBdomain-name-servers\fR \fIip-address\fR [\fB,\fR \fIip-address\fR... +]\fB;\fR +.RS 0.25i +.PP +The domain-name-servers option specifies a list of Domain Name System +(STD 13, RFC 1035) name servers available to the client. Servers +should be listed in order of preference. +.RE +.PP +.B option \fBlog-servers\fR \fIip-address\fR [\fB,\fR \fIip-address\fR... +]\fB;\fR +.RS 0.25i +.PP +The log-server option specifies a list of MIT-LCS UDP log servers +available to the client. Servers should be listed in order of +preference. +.RE +.PP +.B option \fBcookie-servers\fR \fIip-address\fR [\fB,\fR \fIip-address\fR... +]\fB;\fR +.RS 0.25i +.PP +The cookie server option specifies a list of RFC 865 cookie +servers available to the client. Servers should be listed in order +of preference. +.RE +.PP +.B option \fBlpr-servers\fR \fIip-address \fR [\fB,\fR \fIip-address\fR... +]\fB;\fR +.RS 0.25i +.PP +The LPR server option specifies a list of RFC 1179 line printer +servers available to the client. Servers should be listed in order +of preference. +.RE +.PP +.B option \fBimpress-servers\fR \fIip-address\fR [\fB,\fR \fIip-address\fR... +]\fB;\fR +.RS 0.25i +.PP +The impress-server option specifies a list of Imagen Impress servers +available to the client. Servers should be listed in order of +preference. +.RE +.PP +.B option \fBresource-location-servers\fR \fIip-address\fR [\fB,\fR \fIip-address\fR... +]\fB;\fR +.RS 0.25i +.PP +This option specifies a list of RFC 887 Resource Location +servers available to the client. Servers should be listed in order +of preference. +.RE +.PP +.B option \fBhost-name\fR \fIstring\fR\fB;\fR +.RS 0.25i +.PP +This option specifies the name of the client. The name may or may +not be qualified with the local domain name (it is preferable to use +the domain-name option to specify the domain name). See RFC 1035 for +character set restrictions. +.RE +.PP +.B option \fBboot-size\fR \fIuint16\fR\fB;\fR +.RS 0.25i +.PP +This option specifies the length in 512-octet blocks of the default +boot image for the client. +.RE +.PP +.B option \fBmerit-dump\fR \fIstring\fR\fB;\fR +.RS 0.25i +.PP +This option specifies the path-name of a file to which the client's +core image should be dumped in the event the client crashes. The +path is formatted as a character string consisting of characters from +the NVT ASCII character set. +.RE +.PP +.B option \fBdomain-name\fR \fIstring\fR\fB;\fR +.RS 0.25i +.PP +This option specifies the domain name that client should use when +resolving hostnames via the Domain Name System. +.RE +.PP +.B option \fBswap-server\fR \fIip-address\fR\fB;\fR +.RS 0.25i +.PP +This specifies the IP address of the client's swap server. +.RE +.PP +.B option \fBroot-path\fR \fIstring\fB;\fR\fR +.RS 0.25i +.PP +This option specifies the path-name that contains the client's root +disk. The path is formatted as a character string consisting of +characters from the NVT ASCII character set. +.RE +.PP +.B option \fBip-forwarding\fR \fIflag\fR\fB;\fR +.RS 0.25i +.PP +This option specifies whether the client should configure its IP +layer for packet forwarding. A value of 0 means disable IP +forwarding, and a value of 1 means enable IP forwarding. +.RE +.PP +.B option \fBnon-local-source-routing\fR \fIflag\fR\fB;\fR +.RS 0.25i +.PP +This option specifies whether the client should configure its IP +layer to allow forwarding of datagrams with non-local source routes +(see Section 3.3.5 of [4] for a discussion of this topic). A value +of 0 means disallow forwarding of such datagrams, and a value of 1 +means allow forwarding. +.RE +.PP +.B option \fBpolicy-filter\fR \fIip-address ip-address\fR [\fB,\fR \fIip-address ip-address\fR... +]\fB;\fR +.RS 0.25i +.PP +This option specifies policy filters for non-local source routing. +The filters consist of a list of IP addresses and masks which specify +destination/mask pairs with which to filter incoming source routes. +.PP +Any source routed datagram whose next-hop address does not match one +of the filters should be discarded by the client. +.PP +See STD 3 (RFC1122) for further information. +.RE +.PP +.B option \fBmax-dgram-reassembly\fR \fIuint16\fR\fB;\fR +.RS 0.25i +.PP +This option specifies the maximum size datagram that the client +should be prepared to reassemble. The minimum value legal value is +576. +.RE +.PP +.B option \fBdefault-ip-ttl\fR \fIuint8;\fR +.RS 0.25i +.PP +This option specifies the default time-to-live that the client should +use on outgoing datagrams. +.RE +.PP +.B option \fBpath-mtu-aging-timeout\fR \fIuint32\fR\fB;\fR +.RS 0.25i +.PP +This option specifies the timeout (in seconds) to use when aging Path +MTU values discovered by the mechanism defined in RFC 1191. +.RE +.PP +.B option \fBpath-mtu-plateau-table\fR \fIuint16\fR [\fB,\fR \fIuint16\fR... +]\fB;\fR +.RS 0.25i +.PP +This option specifies a table of MTU sizes to use when performing +Path MTU Discovery as defined in RFC 1191. The table is formatted as +a list of 16-bit unsigned integers, ordered from smallest to largest. +The minimum MTU value cannot be smaller than 68. +.RE +.PP +.B option \fBinterface-mtu\fR \fIuint16\fR\fB;\fR +.RS 0.25i +.PP +This option specifies the MTU to use on this interface. The minimum +legal value for the MTU is 68. +.RE +.PP +.B option \fBall-subnets-local\fR \fIflag\fR\fB;\fR +.RS 0.25i +.PP +This option specifies whether or not the client may assume that all +subnets of the IP network to which the client is connected use the +same MTU as the subnet of that network to which the client is +directly connected. A value of 1 indicates that all subnets share +the same MTU. A value of 0 means that the client should assume that +some subnets of the directly connected network may have smaller MTUs. +.RE +.PP +.B option \fBbroadcast-address\fR \fIip-address\fR\fB;\fR +.RS 0.25i +.PP +This option specifies the broadcast address in use on the client's +subnet. Legal values for broadcast addresses are specified in +section 3.2.1.3 of STD 3 (RFC1122). +.RE +.PP +.B option \fBperform-mask-discovery\fR \fIflag\fR\fB;\fR +.RS 0.25i +.PP +This option specifies whether or not the client should perform subnet +mask discovery using ICMP. A value of 0 indicates that the client +should not perform mask discovery. A value of 1 means that the +client should perform mask discovery. +.RE +.PP +.B option \fBmask-supplier\fR \fIflag\fR\fB;\fR +.RS 0.25i +.PP +This option specifies whether or not the client should respond to +subnet mask requests using ICMP. A value of 0 indicates that the +client should not respond. A value of 1 means that the client should +respond. +.RE +.PP +.B option \fBrouter-discovery\fR \fIflag\fR\fB;\fR +.RS 0.25i +.PP +This option specifies whether or not the client should solicit +routers using the Router Discovery mechanism defined in RFC 1256. +A value of 0 indicates that the client should not perform +router discovery. A value of 1 means that the client should perform +router discovery. +.RE +.PP +.B option \fBrouter-solicitation-address\fR \fIip-address\fR\fB;\fR +.RS 0.25i +.PP +This option specifies the address to which the client should transmit +router solicitation requests. +.RE +.PP +.B option \fBstatic-routes\fR \fIip-address ip-address\fR [\fB,\fR \fIip-address ip-address\fR... +]\fB;\fR +.RS 0.25i +.PP +This option specifies a list of static routes that the client should +install in its routing cache. If multiple routes to the same +destination are specified, they are listed in descending order of +priority. +.PP +The routes consist of a list of IP address pairs. The first address +is the destination address, and the second address is the router for +the destination. +.PP +The default route (0.0.0.0) is an illegal destination for a static +route. To specify the default route, use the +.B routers +option. +.RE +.PP +.B option \fBtrailer-encapsulation\fR \fIflag\fR\fB;\fR +.RS 0.25i +.PP +This option specifies whether or not the client should negotiate the +use of trailers (RFC 893 [14]) when using the ARP protocol. A value +of 0 indicates that the client should not attempt to use trailers. A +value of 1 means that the client should attempt to use trailers. +.RE +.PP +.B option \fBarp-cache-timeout\fR \fIuint32\fR\fB;\fR +.RS 0.25i +.PP +This option specifies the timeout in seconds for ARP cache entries. +.RE +.PP +.B option \fBieee802-3-encapsulation\fR \fIflag\fR\fB;\fR +.RS 0.25i +.PP +This option specifies whether or not the client should use Ethernet +Version 2 (RFC 894) or IEEE 802.3 (RFC 1042) encapsulation if the +interface is an Ethernet. A value of 0 indicates that the client +should use RFC 894 encapsulation. A value of 1 means that the client +should use RFC 1042 encapsulation. +.RE +.PP +.B option \fBdefault-tcp-ttl\fR \fIuint8\fR\fB;\fR +.RS 0.25i +.PP +This option specifies the default TTL that the client should use when +sending TCP segments. The minimum value is 1. +.RE +.PP +.B option \fBtcp-keepalive-interval\fR \fIuint32\fR\fB;\fR +.RS 0.25i +.PP +This option specifies the interval (in seconds) that the client TCP +should wait before sending a keepalive message on a TCP connection. +The time is specified as a 32-bit unsigned integer. A value of zero +indicates that the client should not generate keepalive messages on +connections unless specifically requested by an application. +.RE +.PP +.B option \fBtcp-keepalive-garbage\fR \fIflag\fR\fB;\fR +.RS 0.25i +.PP +This option specifies the whether or not the client should send TCP +keepalive messages with a octet of garbage for compatibility with +older implementations. A value of 0 indicates that a garbage octet +should not be sent. A value of 1 indicates that a garbage octet +should be sent. +.RE +.PP +.B option \fBnis-domain\fR \fIstring\fR\fB;\fR +.RS 0.25i +.PP +This option specifies the name of the client's NIS (Sun Network +Information Services) domain. The domain is formatted as a character +string consisting of characters from the NVT ASCII character set. +.RE +.PP +.B option \fBnis-servers\fR \fIip-address\fR [\fB,\fR \fIip-address\fR... +]\fB;\fR +.RS 0.25i +.PP +This option specifies a list of IP addresses indicating NIS servers +available to the client. Servers should be listed in order of +preference. +.RE +.PP +.B option \fBntp-servers\fR \fIip-address\fR [\fB,\fR \fIip-address\fR... +]\fB;\fR +.RS 0.25i +.PP +This option specifies a list of IP addresses indicating NTP (RFC 1035) +servers available to the client. Servers should be listed in order +of preference. +.RE +.PP +.B option \fBnetbios-name-servers\fR \fIip-address\fR [\fB,\fR \fIip-address\fR... +]\fB;\fR +.RS 0.25i +.PP +The NetBIOS name server (NBNS) option specifies a list of RFC +1001/1002 NBNS name servers listed in order of preference. NetBIOS +Name Service is currently more commonly referred to as WINS. WINS +servers can be specified using the netbios-name-servers option. +.RE +.PP +.B option \fBnetbios-dd-server\fR \fIip-address\fR [\fB,\fR \fIip-address\fR... +]\fB;\fR +.RS 0.25i +.PP +The NetBIOS datagram distribution server (NBDD) option specifies a +list of RFC 1001/1002 NBDD servers listed in order of preference. +.RE +.PP +.B option \fBnetbios-node-type\fR \fIuint8\fR\fB;\fR +.RS 0.25i +.PP +The NetBIOS node type option allows NetBIOS over TCP/IP clients which +are configurable to be configured as described in RFC 1001/1002. The +value is specified as a single octet which identifies the client type. +.PP +Possible node types are: +.PP +.TP 5 +.I 1 +B-node: Broadcast - no WINS +.TP +.I 2 +P-node: Peer - WINS only. +.TP +.I 4 +M-node: Mixed - broadcast, then WINS +.TP +.I 8 +H-node: Hybrid - WINS, then broadcast +.RE +.PP +.B option +.B netbios-scope +.I string\fB;\fR +.RS 0.25i +.PP +The NetBIOS scope option specifies the NetBIOS over TCP/IP scope +parameter for the client as specified in RFC 1001/1002. See RFC1001, +RFC1002, and RFC1035 for character-set restrictions. +.RE +.PP +.B option \fBfont-servers\fR \fIip-address\fR [\fB,\fR \fIip-address\fR... +]\fB;\fR +.RS 0.25i +.PP +This option specifies a list of X Window System Font servers available +to the client. Servers should be listed in order of preference. +.RE +.PP +.B option \fBx-display-manager\fR \fIip-address\fR [\fB,\fR \fIip-address\fR... +]\fB;\fR +.RS 0.25i +.PP +This option specifies a list of systems that are running the X Window +System Display Manager and are available to the client. Addresses +should be listed in order of preference. +.RE +.PP +.B option \fBdhcp-client-identifier\fR \fIdata-string\fR\fB;\fR +.RS 0.25i +.PP +This option can be used to specify the a DHCP client identifier in a +host declaration, so that dhcpd can find the host record by matching +against the client identifier. +.RE +.SH SEE ALSO +dhcpd.conf(5), dhcpd.leases(5), dhclient.conf(5), dhcpd(8), +dhclient(8), RFC2132, RFC2131. +.SH AUTHOR +.B dhcpd(8) +was written by Ted Lemon <mellon@vix.com> +under a contract with Vixie Labs. Funding +for this project was provided by the Internet Software Corporation. +Information about the Internet Software Consortium can be found at +.B http://www.isc.org/isc. diff --git a/contrib/isc-dhcp/common/dispatch.c b/contrib/isc-dhcp/common/dispatch.c new file mode 100644 index 000000000000..0a383a04d48c --- /dev/null +++ b/contrib/isc-dhcp/common/dispatch.c @@ -0,0 +1,847 @@ +/* dispatch.c + + Network input dispatcher... */ + +/* + * Copyright (c) 1995, 1996, 1997, 1998, 1999 The Internet Software Consortium. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of The Internet Software Consortium nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND + * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This software has been written for the Internet Software Consortium + * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie + * Enterprises. To learn more about the Internet Software Consortium, + * see ``http://www.vix.com/isc''. To learn more about Vixie + * Enterprises, see ``http://www.vix.com''. + */ + +#ifndef lint +static char copyright[] = +"$Id: dispatch.c,v 1.47.2.9 1999/02/05 20:23:50 mellon Exp $ Copyright (c) 1995, 1996, 1997, 1998, 1999 The Internet Software Consortium. All rights reserved.\n"; +#endif /* not lint */ + +#include "dhcpd.h" +#include <sys/ioctl.h> + +struct interface_info *interfaces, *dummy_interfaces, *fallback_interface; +struct protocol *protocols; +struct timeout *timeouts; +static struct timeout *free_timeouts; +static int interfaces_invalidated; +void (*bootp_packet_handler) PROTO ((struct interface_info *, + struct dhcp_packet *, int, unsigned int, + struct iaddr, struct hardware *)); + +int quiet_interface_discovery; + +/* Use the SIOCGIFCONF ioctl to get a list of all the attached interfaces. + For each interface that's of type INET and not the loopback interface, + register that interface with the network I/O software, figure out what + subnet it's on, and add it to the list of interfaces. */ + +void discover_interfaces (state) + int state; +{ + struct interface_info *tmp; + struct interface_info *last, *next; + char buf [8192]; + struct ifconf ic; + struct ifreq ifr; + int i; + int sock; + int address_count = 0; + struct subnet *subnet; + struct shared_network *share; + struct sockaddr_in foo; + int ir; +#ifdef ALIAS_NAMES_PERMUTED + char *s; +#endif + + /* Create an unbound datagram socket to do the SIOCGIFADDR ioctl on. */ + if ((sock = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) + error ("Can't create addrlist socket"); + + /* Get the interface configuration information... */ + ic.ifc_len = sizeof buf; + ic.ifc_ifcu.ifcu_buf = (caddr_t)buf; + i = ioctl(sock, SIOCGIFCONF, &ic); + + if (i < 0) + error ("ioctl: SIOCGIFCONF: %m"); + + /* If we already have a list of interfaces, and we're running as + a DHCP server, the interfaces were requested. */ + if (interfaces && (state == DISCOVER_SERVER || + state == DISCOVER_RELAY || + state == DISCOVER_REQUESTED)) + ir = 0; + else if (state == DISCOVER_UNCONFIGURED) + ir = INTERFACE_REQUESTED | INTERFACE_AUTOMATIC; + else + ir = INTERFACE_REQUESTED; + + /* Cycle through the list of interfaces looking for IP addresses. */ + for (i = 0; i < ic.ifc_len;) { + struct ifreq *ifp = (struct ifreq *)((caddr_t)ic.ifc_req + i); +#ifdef HAVE_SA_LEN + if (ifp -> ifr_addr.sa_len) + i += (sizeof ifp -> ifr_name) + ifp -> ifr_addr.sa_len; + else +#endif + i += sizeof *ifp; + +#ifdef ALIAS_NAMES_PERMUTED + if ((s = strrchr (ifp -> ifr_name, ':'))) { + *s = 0; + } +#endif + +#ifdef SKIP_DUMMY_INTERFACES + if (!strncmp (ifp -> ifr_name, "dummy", 5)) + continue; +#endif + + + /* See if this is the sort of interface we want to + deal with. */ + strcpy (ifr.ifr_name, ifp -> ifr_name); + if (ioctl (sock, SIOCGIFFLAGS, &ifr) < 0) + error ("Can't get interface flags for %s: %m", + ifr.ifr_name); + + /* Skip loopback, point-to-point and down interfaces, + except don't skip down interfaces if we're trying to + get a list of configurable interfaces. */ + if ((ifr.ifr_flags & IFF_LOOPBACK) || +#ifdef IFF_POINTOPOINT + (ifr.ifr_flags & IFF_POINTOPOINT) || +#endif + (!(ifr.ifr_flags & IFF_UP) && + state != DISCOVER_UNCONFIGURED)) + continue; + + /* See if we've seen an interface that matches this one. */ + for (tmp = interfaces; tmp; tmp = tmp -> next) + if (!strcmp (tmp -> name, ifp -> ifr_name)) + break; + + /* If there isn't already an interface by this name, + allocate one. */ + if (!tmp) { + tmp = ((struct interface_info *) + dmalloc (sizeof *tmp, "discover_interfaces")); + if (!tmp) + error ("Insufficient memory to %s %s", + "record interface", ifp -> ifr_name); + strcpy (tmp -> name, ifp -> ifr_name); + tmp -> next = interfaces; + tmp -> flags = ir; + interfaces = tmp; + } + + /* If we have the capability, extract link information + and record it in a linked list. */ +#ifdef AF_LINK + if (ifp -> ifr_addr.sa_family == AF_LINK) { + struct sockaddr_dl *foo = ((struct sockaddr_dl *) + (&ifp -> ifr_addr)); + tmp -> hw_address.hlen = foo -> sdl_alen; + tmp -> hw_address.htype = HTYPE_ETHER; /* XXX */ + memcpy (tmp -> hw_address.haddr, + LLADDR (foo), foo -> sdl_alen); + } else +#endif /* AF_LINK */ + + if (ifp -> ifr_addr.sa_family == AF_INET) { + struct iaddr addr; + + /* Get a pointer to the address... */ + memcpy (&foo, &ifp -> ifr_addr, + sizeof ifp -> ifr_addr); + + /* We don't want the loopback interface. */ + if (foo.sin_addr.s_addr == htonl (INADDR_LOOPBACK)) + continue; + + + /* If this is the first real IP address we've + found, keep a pointer to ifreq structure in + which we found it. */ + if (!tmp -> ifp) { + struct ifreq *tif; +#ifdef HAVE_SA_LEN + int len = ((sizeof ifp -> ifr_name) + + ifp -> ifr_addr.sa_len); +#else + int len = sizeof *ifp; +#endif + tif = (struct ifreq *)malloc (len); + if (!tif) + error ("no space to remember ifp."); + memcpy (tif, ifp, len); + tmp -> ifp = tif; + tmp -> primary_address = foo.sin_addr; + } + + /* Grab the address... */ + addr.len = 4; + memcpy (addr.iabuf, &foo.sin_addr.s_addr, + addr.len); + + /* If there's a registered subnet for this address, + connect it together... */ + if ((subnet = find_subnet (addr))) { + /* If this interface has multiple aliases + on the same subnet, ignore all but the + first we encounter. */ + if (!subnet -> interface) { + subnet -> interface = tmp; + subnet -> interface_address = addr; + } else if (subnet -> interface != tmp) { + warn ("Multiple %s %s: %s %s", + "interfaces match the", + "same subnet", + subnet -> interface -> name, + tmp -> name); + } + share = subnet -> shared_network; + if (tmp -> shared_network && + tmp -> shared_network != share) { + warn ("Interface %s matches %s", + tmp -> name, + "multiple shared networks"); + } else { + tmp -> shared_network = share; + } + + if (!share -> interface) { + share -> interface = tmp; + } else if (share -> interface != tmp) { + warn ("Multiple %s %s: %s %s", + "interfaces match the", + "same shared network", + share -> interface -> name, + tmp -> name); + } + } + } + } + +#if defined (LINUX_SLASHPROC_DISCOVERY) + /* On Linux, interfaces that don't have IP addresses don't show up + in the SIOCGIFCONF syscall. We got away with this prior to + Linux 2.1 because we would give each interface an IP address of + 0.0.0.0 before trying to boot, but that doesn't work after 2.1 + because we're using LPF, because we can't configure interfaces + with IP addresses of 0.0.0.0 anymore (grumble). This only + matters for the DHCP client, of course - the relay agent and + server should only care about interfaces that are configured + with IP addresses anyway. + + The PROCDEV_DEVICE (/proc/net/dev) is a kernel-supplied file + that, when read, prints a human readable network status. We + extract the names of the network devices by skipping the first + two lines (which are header) and then parsing off everything + up to the colon in each subsequent line - these lines start + with the interface name, then a colon, then a bunch of + statistics. Yes, Virgina, this is a kludge, but you work + with what you have. */ + + if (state == DISCOVER_UNCONFIGURED) { + FILE *proc_dev; + char buffer [256]; + struct ifreq *tif; + int skip = 2; + + proc_dev = fopen (PROCDEV_DEVICE, "r"); + if (!proc_dev) + error ("%s: %m", PROCDEV_DEVICE); + + while (fgets (buffer, sizeof buffer, proc_dev)) { + char *name = buffer; + char *sep; + + /* Skip the first two blocks, which are header + lines. */ + if (skip) { + --skip; + continue; + } + + sep = strrchr (buffer, ':'); + if (sep) + *sep = '\0'; + while (*name == ' ') + name++; + + /* See if we've seen an interface that matches + this one. */ + for (tmp = interfaces; tmp; tmp = tmp -> next) + if (!strcmp (tmp -> name, name)) + break; + + /* If we found one, and it already has an ifreq + structure, nothing more to do.. */ + if (tmp && tmp -> ifp) + continue; + + /* Make up an ifreq structure. */ + tif = (struct ifreq *)malloc (sizeof (struct ifreq)); + if (!tif) + error ("no space to remember ifp."); + memset (tif, 0, sizeof (struct ifreq)); + strcpy (tif -> ifr_name, name); + + /* Now, if we just needed the ifreq structure, hook + it in and move on. */ + if (tmp) { + tmp -> ifp = tif; + continue; + } + + /* Otherwise, allocate one. */ + tmp = ((struct interface_info *) + dmalloc (sizeof *tmp, "discover_interfaces")); + if (!tmp) + error ("Insufficient memory to %s %s", + "record interface", name); + memset (tmp, 0, sizeof *tmp); + strcpy (tmp -> name, name); + + tmp -> ifp = tif; + tmp -> flags = ir; + tmp -> next = interfaces; + interfaces = tmp; + } + fclose (proc_dev); + } +#endif + + /* Now cycle through all the interfaces we found, looking for + hardware addresses. */ +#if defined (SIOCGIFHWADDR) && !defined (AF_LINK) + for (tmp = interfaces; tmp; tmp = tmp -> next) { + struct ifreq ifr; + struct sockaddr sa; + int b, sk; + + /* Read the hardware address from this interface. */ + ifr = *tmp -> ifp; + if (ioctl (sock, SIOCGIFHWADDR, &ifr) < 0) + continue; + + sa = *(struct sockaddr *)&ifr.ifr_hwaddr; + + switch (sa.sa_family) { +#ifdef ARPHRD_LOOPBACK + case ARPHRD_LOOPBACK: + /* ignore loopback interface */ + break; +#endif + + case ARPHRD_ETHER: + tmp -> hw_address.hlen = 6; + tmp -> hw_address.htype = ARPHRD_ETHER; + memcpy (tmp -> hw_address.haddr, sa.sa_data, 6); + break; + +#ifndef ARPHRD_IEEE802 +# define ARPHRD_IEEE802 HTYPE_IEEE802 +#endif + case ARPHRD_IEEE802: + tmp -> hw_address.hlen = 6; + tmp -> hw_address.htype = ARPHRD_IEEE802; + memcpy (tmp -> hw_address.haddr, sa.sa_data, 6); + break; + +#ifndef ARPHRD_FDDI +# define ARPHRD_FDDI HTYPE_FDDI +#endif + case ARPHRD_FDDI: + tmp -> hw_address.hlen = 16; + tmp -> hw_address.htype = HTYPE_FDDI; /* XXX */ + memcpy (tmp -> hw_address.haddr, sa.sa_data, 16); + break; + +#ifdef ARPHRD_METRICOM + case ARPHRD_METRICOM: + tmp -> hw_address.hlen = 6; + tmp -> hw_address.htype = ARPHRD_METRICOM; + memcpy (tmp -> hw_address.haddr, sa.sa_data, 6); + break; +#endif + + default: + error ("%s: unknown hardware address type %d", + ifr.ifr_name, sa.sa_family); + } + } +#endif /* defined (SIOCGIFHWADDR) && !defined (AF_LINK) */ + + /* If we're just trying to get a list of interfaces that we might + be able to configure, we can quit now. */ + if (state == DISCOVER_UNCONFIGURED) + return; + + /* Weed out the interfaces that did not have IP addresses. */ + last = (struct interface_info *)0; + for (tmp = interfaces; tmp; tmp = next) { + next = tmp -> next; + if ((tmp -> flags & INTERFACE_AUTOMATIC) && + state == DISCOVER_REQUESTED) + tmp -> flags &= ~(INTERFACE_AUTOMATIC | + INTERFACE_REQUESTED); + if (!tmp -> ifp || !(tmp -> flags & INTERFACE_REQUESTED)) { + if ((tmp -> flags & INTERFACE_REQUESTED) != ir) + error ("%s: not found", tmp -> name); + if (!last) + interfaces = interfaces -> next; + else + last -> next = tmp -> next; + + /* Remember the interface in case we need to know + about it later. */ + tmp -> next = dummy_interfaces; + dummy_interfaces = tmp; + continue; + } + last = tmp; + + memcpy (&foo, &tmp -> ifp -> ifr_addr, + sizeof tmp -> ifp -> ifr_addr); + + /* We must have a subnet declaration for each interface. */ + if (!tmp -> shared_network && (state == DISCOVER_SERVER)) + error ("No subnet declaration for %s (%s).", + tmp -> name, inet_ntoa (foo.sin_addr)); + + /* Find subnets that don't have valid interface + addresses... */ + for (subnet = (tmp -> shared_network + ? tmp -> shared_network -> subnets + : (struct subnet *)0); + subnet; subnet = subnet -> next_sibling) { + if (!subnet -> interface_address.len) { + /* Set the interface address for this subnet + to the first address we found. */ + subnet -> interface_address.len = 4; + memcpy (subnet -> interface_address.iabuf, + &foo.sin_addr.s_addr, 4); + } + } + + /* Register the interface... */ + if_register_receive (tmp); + if_register_send (tmp); + } + + /* Now register all the remaining interfaces as protocols. */ + for (tmp = interfaces; tmp; tmp = tmp -> next) + add_protocol (tmp -> name, tmp -> rfdesc, got_one, tmp); + + close (sock); + + maybe_setup_fallback (); +} + +struct interface_info *setup_fallback () +{ + fallback_interface = + ((struct interface_info *) + dmalloc (sizeof *fallback_interface, "discover_interfaces")); + if (!fallback_interface) + error ("Insufficient memory to record fallback interface."); + memset (fallback_interface, 0, sizeof *fallback_interface); + strcpy (fallback_interface -> name, "fallback"); + fallback_interface -> shared_network = + new_shared_network ("parse_statement"); + if (!fallback_interface -> shared_network) + error ("No memory for shared subnet"); + memset (fallback_interface -> shared_network, 0, + sizeof (struct shared_network)); + fallback_interface -> shared_network -> name = "fallback-net"; + return fallback_interface; +} + +void reinitialize_interfaces () +{ + struct interface_info *ip; + + for (ip = interfaces; ip; ip = ip -> next) { + if_reinitialize_receive (ip); + if_reinitialize_send (ip); + } + + if (fallback_interface) + if_reinitialize_send (fallback_interface); + + interfaces_invalidated = 1; +} + +#ifdef USE_POLL +/* Wait for packets to come in using poll(). When a packet comes in, + call receive_packet to receive the packet and possibly strip hardware + addressing information from it, and then call through the + bootp_packet_handler hook to try to do something with it. */ + +void dispatch () +{ + struct protocol *l; + int nfds = 0; + struct pollfd *fds; + int count; + int i; + int to_msec; + + nfds = 0; + for (l = protocols; l; l = l -> next) { + ++nfds; + } + fds = (struct pollfd *)malloc ((nfds) * sizeof (struct pollfd)); + if (!fds) + error ("Can't allocate poll structures."); + + do { + /* Call any expired timeouts, and then if there's + still a timeout registered, time out the select + call then. */ + another: + if (timeouts) { + struct timeout *t; + if (timeouts -> when <= cur_time) { + t = timeouts; + timeouts = timeouts -> next; + (*(t -> func)) (t -> what); + t -> next = free_timeouts; + free_timeouts = t; + goto another; + } + /* Figure timeout in milliseconds, and check for + potential overflow. We assume that integers + are 32 bits, which is harmless if they're 64 + bits - we'll just get extra timeouts in that + case. Lease times would have to be quite + long in order for a 32-bit integer to overflow, + anyway. */ + to_msec = timeouts -> when - cur_time; + if (to_msec > 2147483) + to_msec = 2147483; + to_msec *= 1000; + } else + to_msec = -1; + + /* Set up the descriptors to be polled. */ + i = 0; + for (l = protocols; l; l = l -> next) { + fds [i].fd = l -> fd; + fds [i].events = POLLIN; + fds [i].revents = 0; + ++i; + } + + /* Wait for a packet or a timeout... XXX */ + count = poll (fds, nfds, to_msec); + + /* Get the current time... */ + GET_TIME (&cur_time); + + /* Not likely to be transitory... */ + if (count < 0) { + if (errno == EAGAIN || errno == EINTR) + continue; + else + error ("poll: %m"); + } + + i = 0; + for (l = protocols; l; l = l -> next) { + if ((fds [i].revents & POLLIN)) { + fds [i].revents = 0; + if (l -> handler) + (*(l -> handler)) (l); + if (interfaces_invalidated) + break; + } + ++i; + } + interfaces_invalidated = 0; + } while (1); +} +#else +/* Wait for packets to come in using select(). When one does, call + receive_packet to receive the packet and possibly strip hardware + addressing information from it, and then call through the + bootp_packet_handler hook to try to do something with it. */ + +void dispatch () +{ + fd_set r, w, x; + struct protocol *l; + int max = 0; + int count; + struct timeval tv, *tvp; + + FD_ZERO (&w); + FD_ZERO (&x); + + do { + /* Call any expired timeouts, and then if there's + still a timeout registered, time out the select + call then. */ + another: + if (timeouts) { + struct timeout *t; + if (timeouts -> when <= cur_time) { + t = timeouts; + timeouts = timeouts -> next; + (*(t -> func)) (t -> what); + t -> next = free_timeouts; + free_timeouts = t; + goto another; + } + tv.tv_sec = timeouts -> when - cur_time; + tv.tv_usec = 0; + tvp = &tv; + } else + tvp = (struct timeval *)0; + + /* Set up the read mask. */ + FD_ZERO (&r); + + for (l = protocols; l; l = l -> next) { + FD_SET (l -> fd, &r); + if (l -> fd > max) + max = l -> fd; + } + + /* Wait for a packet or a timeout... XXX */ + count = select (max + 1, &r, &w, &x, tvp); + + /* Get the current time... */ + GET_TIME (&cur_time); + + /* Not likely to be transitory... */ + if (count < 0) + error ("select: %m"); + + for (l = protocols; l; l = l -> next) { + if (!FD_ISSET (l -> fd, &r)) + continue; + if (l -> handler) + (*(l -> handler)) (l); + if (interfaces_invalidated) + break; + } + interfaces_invalidated = 0; + } while (1); +} +#endif /* USE_POLL */ + +void got_one (l) + struct protocol *l; +{ + struct sockaddr_in from; + struct hardware hfrom; + struct iaddr ifrom; + int result; + union { + unsigned char packbuf [4095]; /* Packet input buffer. + Must be as large as largest + possible MTU. */ + struct dhcp_packet packet; + } u; + struct interface_info *ip = l -> local; + + if ((result = + receive_packet (ip, u.packbuf, sizeof u, &from, &hfrom)) < 0) { + warn ("receive_packet failed on %s: %m", ip -> name); + return; + } + if (result == 0) + return; + + if (bootp_packet_handler) { + ifrom.len = 4; + memcpy (ifrom.iabuf, &from.sin_addr, ifrom.len); + + (*bootp_packet_handler) (ip, &u.packet, result, + from.sin_port, ifrom, &hfrom); + } +} + +int locate_network (packet) + struct packet *packet; +{ + struct iaddr ia; + + /* If this came through a gateway, find the corresponding subnet... */ + if (packet -> raw -> giaddr.s_addr) { + struct subnet *subnet; + ia.len = 4; + memcpy (ia.iabuf, &packet -> raw -> giaddr, 4); + subnet = find_subnet (ia); + if (subnet) + packet -> shared_network = subnet -> shared_network; + else + packet -> shared_network = (struct shared_network *)0; + } else { + packet -> shared_network = + packet -> interface -> shared_network; + } + if (packet -> shared_network) + return 1; + return 0; +} + +void add_timeout (when, where, what) + TIME when; + void (*where) PROTO ((void *)); + void *what; +{ + struct timeout *t, *q; + + /* See if this timeout supersedes an existing timeout. */ + t = (struct timeout *)0; + for (q = timeouts; q; q = q -> next) { + if (q -> func == where && q -> what == what) { + if (t) + t -> next = q -> next; + else + timeouts = q -> next; + break; + } + t = q; + } + + /* If we didn't supersede a timeout, allocate a timeout + structure now. */ + if (!q) { + if (free_timeouts) { + q = free_timeouts; + free_timeouts = q -> next; + q -> func = where; + q -> what = what; + } else { + q = (struct timeout *)malloc (sizeof (struct timeout)); + if (!q) + error ("Can't allocate timeout structure!"); + q -> func = where; + q -> what = what; + } + } + + q -> when = when; + + /* Now sort this timeout into the timeout list. */ + + /* Beginning of list? */ + if (!timeouts || timeouts -> when > q -> when) { + q -> next = timeouts; + timeouts = q; + return; + } + + /* Middle of list? */ + for (t = timeouts; t -> next; t = t -> next) { + if (t -> next -> when > q -> when) { + q -> next = t -> next; + t -> next = q; + return; + } + } + + /* End of list. */ + t -> next = q; + q -> next = (struct timeout *)0; +} + +void cancel_timeout (where, what) + void (*where) PROTO ((void *)); + void *what; +{ + struct timeout *t, *q; + + /* Look for this timeout on the list, and unlink it if we find it. */ + t = (struct timeout *)0; + for (q = timeouts; q; q = q -> next) { + if (q -> func == where && q -> what == what) { + if (t) + t -> next = q -> next; + else + timeouts = q -> next; + break; + } + t = q; + } + + /* If we found the timeout, put it on the free list. */ + if (q) { + q -> next = free_timeouts; + free_timeouts = q; + } +} + +/* Add a protocol to the list of protocols... */ +void add_protocol (name, fd, handler, local) + char *name; + int fd; + void (*handler) PROTO ((struct protocol *)); + void *local; +{ + struct protocol *p; + + p = (struct protocol *)malloc (sizeof *p); + if (!p) + error ("can't allocate protocol struct for %s", name); + + p -> fd = fd; + p -> handler = handler; + p -> local = local; + + p -> next = protocols; + protocols = p; +} + +void remove_protocol (proto) + struct protocol *proto; +{ + struct protocol *p, *next, *prev; + + prev = (struct protocol *)0; + for (p = protocols; p; p = next) { + next = p -> next; + if (p == proto) { + if (prev) + prev -> next = p -> next; + else + protocols = p -> next; + free (p); + } + } +} diff --git a/contrib/isc-dhcp/common/lpf.c b/contrib/isc-dhcp/common/lpf.c new file mode 100644 index 000000000000..7c6ff74d628e --- /dev/null +++ b/contrib/isc-dhcp/common/lpf.c @@ -0,0 +1,287 @@ +/* lpf.c + + Linux packet filter code, contributed by Brian Murrel at Interlinx + Support Services in Vancouver, B.C. */ + +/* + * Copyright (c) 1995, 1996, 1998, 1999 + * The Internet Software Consortium. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of The Internet Software Consortium nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND + * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This software has been written for the Internet Software Consortium + * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie + * Enterprises. To learn more about the Internet Software Consortium, + * see ``http://www.vix.com/isc''. To learn more about Vixie + * Enterprises, see ``http://www.vix.com''. + */ + +#ifndef lint +static char copyright[] = +"$Id: lpf.c,v 1.1.2.4 1999/02/09 04:51:05 mellon Exp $ Copyright (c) 1995, 1996, 1998, 1999 The Internet Software Consortium. All rights reserved.\n"; +#endif /* not lint */ + +#include "dhcpd.h" +#if defined (USE_LPF_SEND) || defined (USE_LPF_RECEIVE) +#include <sys/ioctl.h> +#include <sys/uio.h> + +#include <asm/types.h> +#include <linux/filter.h> +#include <linux/if_ether.h> +#include <netinet/in_systm.h> +#include "includes/netinet/ip.h" +#include "includes/netinet/udp.h" +#include "includes/netinet/if_ether.h" + +/* Reinitializes the specified interface after an address change. This + is not required for packet-filter APIs. */ + +#ifdef USE_LPF_SEND +void if_reinitialize_send (info) + struct interface_info *info; +{ +} +#endif + +#ifdef USE_LPF_RECEIVE +void if_reinitialize_receive (info) + struct interface_info *info; +{ +} +#endif + +/* Called by get_interface_list for each interface that's discovered. + Opens a packet filter for each interface and adds it to the select + mask. */ + +int if_register_lpf (info) + struct interface_info *info; +{ + int sock; + char filename[50]; + int b; + struct sockaddr sa; + + /* Make an LPF socket. */ + if ((sock = socket(PF_PACKET, SOCK_PACKET, htons(ETH_P_ALL))) < 0) { + if (errno == ENOPROTOOPT || errno == EPROTONOSUPPORT || + errno == ESOCKTNOSUPPORT || errno == EPFNOSUPPORT || + errno == EAFNOSUPPORT) + error ("socket: %m - make sure %s %s!", + "CONFIG_PACKET and CONFIG_FILTER are defined", + "in your kernel configuration"); + error("Open a socket for LPF: %m"); + } + + /* Bind to the interface name */ + memset (&sa, 0, sizeof sa); + sa.sa_family = AF_PACKET; + strncpy (sa.sa_data, (const char *)info -> ifp, sizeof sa.sa_data); + if (bind (sock, &sa, sizeof sa)) { + if (errno == ENOPROTOOPT || errno == EPROTONOSUPPORT || + errno == ESOCKTNOSUPPORT || errno == EPFNOSUPPORT || + errno == EAFNOSUPPORT) + error ("socket: %m - make sure %s %s!", + "CONFIG_PACKET and CONFIG_FILTER are defined", + "in your kernel configuration"); + error("Bind socket to interface: %m"); + } + + return sock; +} +#endif /* USE_LPF_SEND || USE_LPF_RECEIVE */ + +#ifdef USE_LPF_SEND +void if_register_send (info) + struct interface_info *info; +{ + /* If we're using the lpf API for sending and receiving, + we don't need to register this interface twice. */ +#ifndef USE_LPF_RECEIVE + info -> wfdesc = if_register_lpf (info, interface); +#else + info -> wfdesc = info -> rfdesc; +#endif + if (!quiet_interface_discovery) + note ("Sending on LPF/%s/%s/%s", + info -> name, + print_hw_addr (info -> hw_address.htype, + info -> hw_address.hlen, + info -> hw_address.haddr), + (info -> shared_network ? + info -> shared_network -> name : "unattached")); +} +#endif /* USE_LPF_SEND */ + +#ifdef USE_LPF_RECEIVE +/* Defined in bpf.c. We can't extern these in dhcpd.h without pulling + in bpf includes... */ +extern struct sock_filter dhcp_bpf_filter []; +extern int dhcp_bpf_filter_len; + +void if_register_receive (info) + struct interface_info *info; +{ + struct sock_fprog p; + + /* Open a LPF device and hang it on this interface... */ + info -> rfdesc = if_register_lpf (info); + + /* Set up the bpf filter program structure. This is defined in + bpf.c */ + p.len = dhcp_bpf_filter_len; + p.filter = dhcp_bpf_filter; + + /* Patch the server port into the LPF program... + XXX changes to filter program may require changes + to the insn number(s) used below! XXX */ + dhcp_bpf_filter [8].k = ntohs (local_port); + + if (setsockopt (info -> rfdesc, SOL_SOCKET, SO_ATTACH_FILTER, &p, + sizeof p) < 0) { + if (errno == ENOPROTOOPT || errno == EPROTONOSUPPORT || + errno == ESOCKTNOSUPPORT || errno == EPFNOSUPPORT || + errno == EAFNOSUPPORT) + error ("socket: %m - make sure %s %s!", + "CONFIG_PACKET and CONFIG_FILTER are defined", + "in your kernel configuration"); + error ("Can't install packet filter program: %m"); + } + if (!quiet_interface_discovery) + note ("Listening on LPF/%s/%s/%s", + info -> name, + print_hw_addr (info -> hw_address.htype, + info -> hw_address.hlen, + info -> hw_address.haddr), + (info -> shared_network ? + info -> shared_network -> name : "unattached")); +} +#endif /* USE_LPF_RECEIVE */ + +#ifdef USE_LPF_SEND +ssize_t send_packet (interface, packet, raw, len, from, to, hto) + struct interface_info *interface; + struct packet *packet; + struct dhcp_packet *raw; + size_t len; + struct in_addr from; + struct sockaddr_in *to; + struct hardware *hto; +{ + int bufp = 0; + unsigned char buf [1500]; + struct sockaddr sa; + + if (!strcmp (interface -> name, "fallback")) + return send_fallback (interface, packet, raw, + len, from, to, hto); + + /* Assemble the headers... */ + assemble_hw_header (interface, buf, &bufp, hto); + assemble_udp_ip_header (interface, buf, &bufp, from.s_addr, + to -> sin_addr.s_addr, to -> sin_port, + (unsigned char *)raw, len); + memcpy (buf + bufp, raw, len); + + /* For some reason, SOCK_PACKET sockets can't be connected, + so we have to do a sentdo every time. */ + memset (&sa, 0, sizeof sa); + sa.sa_family = AF_PACKET; + strncpy (sa.sa_data, + (const char *)interface -> ifp, sizeof sa.sa_data); + + return sendto (interface -> wfdesc, buf, bufp + len, 0, + &sa, sizeof sa); +} +#endif /* USE_LPF_SEND */ + +#ifdef USE_LPF_RECEIVE +ssize_t receive_packet (interface, buf, len, from, hfrom) + struct interface_info *interface; + unsigned char *buf; + size_t len; + struct sockaddr_in *from; + struct hardware *hfrom; +{ + int nread; + int length = 0; + int offset = 0; + unsigned char ibuf [1500]; + int bufix = 0; + + length = read (interface -> rfdesc, ibuf, sizeof ibuf); + if (length <= 0) + return length; + + bufix = 0; + /* Decode the physical header... */ + offset = decode_hw_header (interface, ibuf, bufix, hfrom); + + /* If a physical layer checksum failed (dunno of any + physical layer that supports this, but WTH), skip this + packet. */ + if (offset < 0) { + return 0; + } + + bufix += offset; + length -= offset; + + /* Decode the IP and UDP headers... */ + offset = decode_udp_ip_header (interface, ibuf, bufix, + from, (unsigned char *)0, length); + + /* If the IP or UDP checksum was bad, skip the packet... */ + if (offset < 0) + return 0; + + bufix += offset; + length -= offset; + + /* Copy out the data in the packet... */ + memcpy (buf, &ibuf [bufix], length); + return length; +} + +int can_unicast_without_arp () +{ + return 1; +} + +void maybe_setup_fallback () +{ + struct interface_info *fbi; + fbi = setup_fallback (); + if (fbi) { + if_register_fallback (fbi); + add_protocol ("fallback", fallback_interface -> wfdesc, + fallback_discard, fallback_interface); + } +} +#endif diff --git a/contrib/isc-dhcp/common/memory.c b/contrib/isc-dhcp/common/memory.c new file mode 100644 index 000000000000..871fe0772d4a --- /dev/null +++ b/contrib/isc-dhcp/common/memory.c @@ -0,0 +1,941 @@ +/* memory.c + + Memory-resident database... */ + +/* + * Copyright (c) 1995, 1996, 1997, 1998 The Internet Software Consortium. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of The Internet Software Consortium nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND + * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This software has been written for the Internet Software Consortium + * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie + * Enterprises. To learn more about the Internet Software Consortium, + * see ``http://www.vix.com/isc''. To learn more about Vixie + * Enterprises, see ``http://www.vix.com''. + */ + +#ifndef lint +static char copyright[] = +"$Id: memory.c,v 1.35.2.3 1998/11/24 22:32:43 mellon Exp $ Copyright (c) 1995, 1996, 1997, 1998 The Internet Software Consortium. All rights reserved.\n"; +#endif /* not lint */ + +#include "dhcpd.h" + +static struct subnet *subnets; +static struct shared_network *shared_networks; +static struct hash_table *host_hw_addr_hash; +static struct hash_table *host_uid_hash; +static struct hash_table *lease_uid_hash; +static struct hash_table *lease_ip_addr_hash; +static struct hash_table *lease_hw_addr_hash; +static struct lease *dangling_leases; + +static struct hash_table *vendor_class_hash; +static struct hash_table *user_class_hash; + +void enter_host (hd) + struct host_decl *hd; +{ + struct host_decl *hp = (struct host_decl *)0; + struct host_decl *np = (struct host_decl *)0; + + hd -> n_ipaddr = (struct host_decl *)0; + + if (hd -> interface.hlen) { + if (!host_hw_addr_hash) + host_hw_addr_hash = new_hash (); + else + hp = (struct host_decl *) + hash_lookup (host_hw_addr_hash, + hd -> interface.haddr, + hd -> interface.hlen); + + /* If there isn't already a host decl matching this + address, add it to the hash table. */ + if (!hp) + add_hash (host_hw_addr_hash, + hd -> interface.haddr, hd -> interface.hlen, + (unsigned char *)hd); + } + + /* If there was already a host declaration for this hardware + address, add this one to the end of the list. */ + + if (hp) { + for (np = hp; np -> n_ipaddr; np = np -> n_ipaddr) + ; + np -> n_ipaddr = hd; + } + + if (hd -> group -> options [DHO_DHCP_CLIENT_IDENTIFIER]) { + if (!tree_evaluate (hd -> group -> options + [DHO_DHCP_CLIENT_IDENTIFIER])) + return; + + /* If there's no uid hash, make one; otherwise, see if + there's already an entry in the hash for this host. */ + if (!host_uid_hash) { + host_uid_hash = new_hash (); + hp = (struct host_decl *)0; + } else + hp = (struct host_decl *) hash_lookup + (host_uid_hash, + hd -> group -> options + [DHO_DHCP_CLIENT_IDENTIFIER] -> value, + hd -> group -> options + [DHO_DHCP_CLIENT_IDENTIFIER] -> len); + + /* If there's already a host declaration for this + client identifier, add this one to the end of the + list. Otherwise, add it to the hash table. */ + if (hp) { + /* Don't link it in twice... */ + if (!np) { + for (np = hp; np -> n_ipaddr; + np = np -> n_ipaddr) + ; + np -> n_ipaddr = hd; + } + } else { + add_hash (host_uid_hash, + hd -> group -> options + [DHO_DHCP_CLIENT_IDENTIFIER] -> value, + hd -> group -> options + [DHO_DHCP_CLIENT_IDENTIFIER] -> len, + (unsigned char *)hd); + } + } +} + +struct host_decl *find_hosts_by_haddr (htype, haddr, hlen) + int htype; + unsigned char *haddr; + int hlen; +{ + struct host_decl *foo; + + foo = (struct host_decl *)hash_lookup (host_hw_addr_hash, + haddr, hlen); + return foo; +} + +struct host_decl *find_hosts_by_uid (data, len) + unsigned char *data; + int len; +{ + struct host_decl *foo; + + foo = (struct host_decl *)hash_lookup (host_uid_hash, data, len); + return foo; +} + +/* More than one host_decl can be returned by find_hosts_by_haddr or + find_hosts_by_uid, and each host_decl can have multiple addresses. + Loop through the list of hosts, and then for each host, through the + list of addresses, looking for an address that's in the same shared + network as the one specified. Store the matching address through + the addr pointer, update the host pointer to point at the host_decl + that matched, and return the subnet that matched. */ + +struct subnet *find_host_for_network (host, addr, share) + struct host_decl **host; + struct iaddr *addr; + struct shared_network *share; +{ + int i; + struct subnet *subnet; + struct iaddr ip_address; + struct host_decl *hp; + + for (hp = *host; hp; hp = hp -> n_ipaddr) { + if (!hp -> fixed_addr || !tree_evaluate (hp -> fixed_addr)) + continue; + for (i = 0; i < hp -> fixed_addr -> len; i += 4) { + ip_address.len = 4; + memcpy (ip_address.iabuf, + hp -> fixed_addr -> value + i, 4); + subnet = find_grouped_subnet (share, ip_address); + if (subnet) { + *addr = ip_address; + *host = hp; + return subnet; + } + } + } + return (struct subnet *)0; +} + +void new_address_range (low, high, subnet, dynamic) + struct iaddr low, high; + struct subnet *subnet; + int dynamic; +{ + struct lease *address_range, *lp, *plp; + struct iaddr net; + int min, max, i; + char lowbuf [16], highbuf [16], netbuf [16]; + struct shared_network *share = subnet -> shared_network; + struct hostent *h; + struct in_addr ia; + + /* All subnets should have attached shared network structures. */ + if (!share) { + strcpy (netbuf, piaddr (subnet -> net)); + error ("No shared network for network %s (%s)", + netbuf, piaddr (subnet -> netmask)); + } + + /* Initialize the hash table if it hasn't been done yet. */ + if (!lease_uid_hash) + lease_uid_hash = new_hash (); + if (!lease_ip_addr_hash) + lease_ip_addr_hash = new_hash (); + if (!lease_hw_addr_hash) + lease_hw_addr_hash = new_hash (); + + /* Make sure that high and low addresses are in same subnet. */ + net = subnet_number (low, subnet -> netmask); + if (!addr_eq (net, subnet_number (high, subnet -> netmask))) { + strcpy (lowbuf, piaddr (low)); + strcpy (highbuf, piaddr (high)); + strcpy (netbuf, piaddr (subnet -> netmask)); + error ("Address range %s to %s, netmask %s spans %s!", + lowbuf, highbuf, netbuf, "multiple subnets"); + } + + /* Make sure that the addresses are on the correct subnet. */ + if (!addr_eq (net, subnet -> net)) { + strcpy (lowbuf, piaddr (low)); + strcpy (highbuf, piaddr (high)); + strcpy (netbuf, piaddr (subnet -> netmask)); + error ("Address range %s to %s not on net %s/%s!", + lowbuf, highbuf, piaddr (subnet -> net), netbuf); + } + + /* Get the high and low host addresses... */ + max = host_addr (high, subnet -> netmask); + min = host_addr (low, subnet -> netmask); + + /* Allow range to be specified high-to-low as well as low-to-high. */ + if (min > max) { + max = min; + min = host_addr (high, subnet -> netmask); + } + + /* Get a lease structure for each address in the range. */ + address_range = new_leases (max - min + 1, "new_address_range"); + if (!address_range) { + strcpy (lowbuf, piaddr (low)); + strcpy (highbuf, piaddr (high)); + error ("No memory for address range %s-%s.", lowbuf, highbuf); + } + memset (address_range, 0, (sizeof *address_range) * (max - min + 1)); + + /* Fill in the last lease if it hasn't been already... */ + if (!share -> last_lease) { + share -> last_lease = &address_range [0]; + } + + /* Fill out the lease structures with some minimal information. */ + for (i = 0; i < max - min + 1; i++) { + address_range [i].ip_addr = + ip_addr (subnet -> net, subnet -> netmask, i + min); + address_range [i].starts = + address_range [i].timestamp = MIN_TIME; + address_range [i].ends = MIN_TIME; + address_range [i].subnet = subnet; + address_range [i].shared_network = share; + address_range [i].flags = dynamic ? DYNAMIC_BOOTP_OK : 0; + + memcpy (&ia, address_range [i].ip_addr.iabuf, 4); + + if (subnet -> group -> get_lease_hostnames) { + h = gethostbyaddr ((char *)&ia, sizeof ia, AF_INET); + if (!h) + warn ("No hostname for %s", inet_ntoa (ia)); + else { + address_range [i].hostname = + malloc (strlen (h -> h_name) + 1); + if (!address_range [i].hostname) + error ("no memory for hostname %s.", + h -> h_name); + strcpy (address_range [i].hostname, + h -> h_name); + } + } + + /* Link this entry into the list. */ + address_range [i].next = share -> leases; + address_range [i].prev = (struct lease *)0; + share -> leases = &address_range [i]; + if (address_range [i].next) + address_range [i].next -> prev = share -> leases; + add_hash (lease_ip_addr_hash, + address_range [i].ip_addr.iabuf, + address_range [i].ip_addr.len, + (unsigned char *)&address_range [i]); + } + + /* Find out if any dangling leases are in range... */ + plp = (struct lease *)0; + for (lp = dangling_leases; lp; lp = lp -> next) { + struct iaddr lnet; + int lhost; + + lnet = subnet_number (lp -> ip_addr, subnet -> netmask); + lhost = host_addr (lp -> ip_addr, subnet -> netmask); + + /* If it's in range, fill in the real lease structure with + the dangling lease's values, and remove the lease from + the list of dangling leases. */ + if (addr_eq (lnet, subnet -> net) && + lhost >= i && lhost <= max) { + if (plp) { + plp -> next = lp -> next; + } else { + dangling_leases = lp -> next; + } + lp -> next = (struct lease *)0; + address_range [lhost - i].hostname = lp -> hostname; + address_range [lhost - i].client_hostname = + lp -> client_hostname; + supersede_lease (&address_range [lhost - i], lp, 0); + free_lease (lp, "new_address_range"); + } else + plp = lp; + } +} + +struct subnet *find_subnet (addr) + struct iaddr addr; +{ + struct subnet *rv; + + for (rv = subnets; rv; rv = rv -> next_subnet) { + if (addr_eq (subnet_number (addr, rv -> netmask), rv -> net)) + return rv; + } + return (struct subnet *)0; +} + +struct subnet *find_grouped_subnet (share, addr) + struct shared_network *share; + struct iaddr addr; +{ + struct subnet *rv; + + for (rv = share -> subnets; rv; rv = rv -> next_sibling) { + if (addr_eq (subnet_number (addr, rv -> netmask), rv -> net)) + return rv; + } + return (struct subnet *)0; +} + +int subnet_inner_than (subnet, scan, warnp) + struct subnet *subnet, *scan; + int warnp; +{ + if (addr_eq (subnet_number (subnet -> net, scan -> netmask), + scan -> net) || + addr_eq (subnet_number (scan -> net, subnet -> netmask), + subnet -> net)) { + char n1buf [16]; + int i, j; + for (i = 0; i < 32; i++) + if (subnet -> netmask.iabuf [3 - (i >> 3)] + & (1 << (i & 7))) + break; + for (j = 0; j < 32; j++) + if (scan -> netmask.iabuf [3 - (j >> 3)] & + (1 << (j & 7))) + break; + strcpy (n1buf, piaddr (subnet -> net)); + if (warnp) + warn ("%ssubnet %s/%d conflicts with subnet %s/%d", + "Warning: ", n1buf, 32 - i, + piaddr (scan -> net), 32 - j); + if (i < j) + return 1; + } + return 0; +} + +/* Enter a new subnet into the subnet list. */ + +void enter_subnet (subnet) + struct subnet *subnet; +{ + struct subnet *scan, *prev = (struct subnet *)0; + + /* Check for duplicates... */ + for (scan = subnets; scan; scan = scan -> next_subnet) { + /* When we find a conflict, make sure that the + subnet with the narrowest subnet mask comes + first. */ + if (subnet_inner_than (subnet, scan, 1)) { + if (prev) { + prev -> next_subnet = subnet; + } else + subnets = subnet; + subnet -> next_subnet = scan; + return; + } + prev = scan; + } + + /* XXX use the BSD radix tree code instead of a linked list. */ + subnet -> next_subnet = subnets; + subnets = subnet; +} + +/* Enter a new shared network into the shared network list. */ + +void enter_shared_network (share) + struct shared_network *share; +{ + /* XXX Sort the nets into a balanced tree to make searching quicker. */ + share -> next = shared_networks; + shared_networks = share; +} + +/* Enter a lease into the system. This is called by the parser each + time it reads in a new lease. If the subnet for that lease has + already been read in (usually the case), just update that lease; + otherwise, allocate temporary storage for the lease and keep it around + until we're done reading in the config file. */ + +void enter_lease (lease) + struct lease *lease; +{ + struct lease *comp = find_lease_by_ip_addr (lease -> ip_addr); + + /* If we don't have a place for this lease yet, save it for + later. */ + if (!comp) { + comp = new_lease ("enter_lease"); + if (!comp) { + error ("No memory for lease %s\n", + piaddr (lease -> ip_addr)); + } + *comp = *lease; + comp -> next = dangling_leases; + comp -> prev = (struct lease *)0; + dangling_leases = comp; + } else { + /* Record the hostname information in the lease. */ + comp -> hostname = lease -> hostname; + comp -> client_hostname = lease -> client_hostname; + supersede_lease (comp, lease, 0); + } +} + +/* Replace the data in an existing lease with the data in a new lease; + adjust hash tables to suit, and insertion sort the lease into the + list of leases by expiry time so that we can always find the oldest + lease. */ + +int supersede_lease (comp, lease, commit) + struct lease *comp, *lease; + int commit; +{ + int enter_uid = 0; + int enter_hwaddr = 0; + struct lease *lp; + + /* Static leases are not currently kept in the database... */ + if (lease -> flags & STATIC_LEASE) + return 1; + + /* If the existing lease hasn't expired and has a different + unique identifier or, if it doesn't have a unique + identifier, a different hardware address, then the two + leases are in conflict. If the existing lease has a uid + and the new one doesn't, but they both have the same + hardware address, and dynamic bootp is allowed on this + lease, then we allow that, in case a dynamic BOOTP lease is + requested *after* a DHCP lease has been assigned. */ + + if (!(lease -> flags & ABANDONED_LEASE) && + comp -> ends > cur_time && + (((comp -> uid && lease -> uid) && + (comp -> uid_len != lease -> uid_len || + memcmp (comp -> uid, lease -> uid, comp -> uid_len))) || + (!comp -> uid && + ((comp -> hardware_addr.htype != + lease -> hardware_addr.htype) || + (comp -> hardware_addr.hlen != + lease -> hardware_addr.hlen) || + memcmp (comp -> hardware_addr.haddr, + lease -> hardware_addr.haddr, + comp -> hardware_addr.hlen))))) { + warn ("Lease conflict at %s", + piaddr (comp -> ip_addr)); + return 0; + } else { + /* If there's a Unique ID, dissociate it from the hash + table and free it if necessary. */ + if (comp -> uid) { + uid_hash_delete (comp); + enter_uid = 1; + if (comp -> uid != &comp -> uid_buf [0]) { + free (comp -> uid); + comp -> uid_max = 0; + comp -> uid_len = 0; + } + comp -> uid = (unsigned char *)0; + } else + enter_uid = 1; + + if (comp -> hardware_addr.htype && + ((comp -> hardware_addr.hlen != + lease -> hardware_addr.hlen) || + (comp -> hardware_addr.htype != + lease -> hardware_addr.htype) || + memcmp (comp -> hardware_addr.haddr, + lease -> hardware_addr.haddr, + comp -> hardware_addr.hlen))) { + hw_hash_delete (comp); + enter_hwaddr = 1; + } else if (!comp -> hardware_addr.htype) + enter_hwaddr = 1; + + /* Copy the data files, but not the linkages. */ + comp -> starts = lease -> starts; + comp -> timestamp = lease -> timestamp; + if (lease -> uid) { + if (lease -> uid_len < sizeof (lease -> uid_buf)) { + memcpy (comp -> uid_buf, + lease -> uid, lease -> uid_len); + comp -> uid = &comp -> uid_buf [0]; + comp -> uid_max = sizeof comp -> uid_buf; + } else if (lease -> uid != &lease -> uid_buf [0]) { + comp -> uid = lease -> uid; + comp -> uid_max = lease -> uid_max; + lease -> uid = (unsigned char *)0; + lease -> uid_max = 0; + } else { + error ("corrupt lease uid."); /* XXX */ + } + } else { + comp -> uid = (unsigned char *)0; + comp -> uid_max = 0; + } + comp -> uid_len = lease -> uid_len; + comp -> host = lease -> host; + comp -> hardware_addr = lease -> hardware_addr; + comp -> flags = ((lease -> flags & ~PERSISTENT_FLAGS) | + (comp -> flags & ~EPHEMERAL_FLAGS)); + + /* Record the lease in the uid hash if necessary. */ + if (enter_uid && lease -> uid) { + uid_hash_add (comp); + } + + /* Record it in the hardware address hash if necessary. */ + if (enter_hwaddr && lease -> hardware_addr.htype) { + hw_hash_add (comp); + } + + /* Remove the lease from its current place in the + timeout sequence. */ + if (comp -> prev) { + comp -> prev -> next = comp -> next; + } else { + comp -> shared_network -> leases = comp -> next; + } + if (comp -> next) { + comp -> next -> prev = comp -> prev; + } + if (comp -> shared_network -> last_lease == comp) { + comp -> shared_network -> last_lease = comp -> prev; + } + + /* Find the last insertion point... */ + if (comp == comp -> shared_network -> insertion_point || + !comp -> shared_network -> insertion_point) { + lp = comp -> shared_network -> leases; + } else { + lp = comp -> shared_network -> insertion_point; + } + + if (!lp) { + /* Nothing on the list yet? Just make comp the + head of the list. */ + comp -> shared_network -> leases = comp; + comp -> shared_network -> last_lease = comp; + } else if (lp -> ends > lease -> ends) { + /* Skip down the list until we run out of list + or find a place for comp. */ + while (lp -> next && lp -> ends > lease -> ends) { + lp = lp -> next; + } + if (lp -> ends > lease -> ends) { + /* If we ran out of list, put comp + at the end. */ + lp -> next = comp; + comp -> prev = lp; + comp -> next = (struct lease *)0; + comp -> shared_network -> last_lease = comp; + } else { + /* If we didn't, put it between lp and + the previous item on the list. */ + if ((comp -> prev = lp -> prev)) + comp -> prev -> next = comp; + comp -> next = lp; + lp -> prev = comp; + } + } else { + /* Skip up the list until we run out of list + or find a place for comp. */ + while (lp -> prev && lp -> ends < lease -> ends) { + lp = lp -> prev; + } + if (lp -> ends < lease -> ends) { + /* If we ran out of list, put comp + at the beginning. */ + lp -> prev = comp; + comp -> next = lp; + comp -> prev = (struct lease *)0; + comp -> shared_network -> leases = comp; + } else { + /* If we didn't, put it between lp and + the next item on the list. */ + if ((comp -> next = lp -> next)) + comp -> next -> prev = comp; + comp -> prev = lp; + lp -> next = comp; + } + } + comp -> shared_network -> insertion_point = comp; + comp -> ends = lease -> ends; + } + + /* Return zero if we didn't commit the lease to permanent storage; + nonzero if we did. */ + return commit && write_lease (comp) && commit_leases (); +} + +/* Release the specified lease and re-hash it as appropriate. */ + +void release_lease (lease) + struct lease *lease; +{ + struct lease lt; + + lt = *lease; + if (lt.ends > cur_time) { + lt.ends = cur_time; + supersede_lease (lease, <, 1); + } +} + +/* Abandon the specified lease (set its timeout to infinity and its + particulars to zero, and re-hash it as appropriate. */ + +void abandon_lease (lease, message) + struct lease *lease; + char *message; +{ + struct lease lt; + + lease -> flags |= ABANDONED_LEASE; + lt = *lease; + lt.ends = cur_time; + warn ("Abandoning IP address %s: %s", + piaddr (lease -> ip_addr), message); + lt.hardware_addr.htype = 0; + lt.hardware_addr.hlen = 0; + lt.uid = (unsigned char *)0; + lt.uid_len = 0; + supersede_lease (lease, <, 1); +} + +/* Locate the lease associated with a given IP address... */ + +struct lease *find_lease_by_ip_addr (addr) + struct iaddr addr; +{ + struct lease *lease = (struct lease *)hash_lookup (lease_ip_addr_hash, + addr.iabuf, + addr.len); + return lease; +} + +struct lease *find_lease_by_uid (uid, len) + unsigned char *uid; + int len; +{ + struct lease *lease = (struct lease *)hash_lookup (lease_uid_hash, + uid, len); + return lease; +} + +struct lease *find_lease_by_hw_addr (hwaddr, hwlen) + unsigned char *hwaddr; + int hwlen; +{ + struct lease *lease = (struct lease *)hash_lookup (lease_hw_addr_hash, + hwaddr, hwlen); + return lease; +} + +/* Add the specified lease to the uid hash. */ + +void uid_hash_add (lease) + struct lease *lease; +{ + struct lease *head = + find_lease_by_uid (lease -> uid, lease -> uid_len); + struct lease *scan; + +#ifdef DEBUG + if (lease -> n_uid) + abort (); +#endif + + /* If it's not in the hash, just add it. */ + if (!head) + add_hash (lease_uid_hash, lease -> uid, + lease -> uid_len, (unsigned char *)lease); + else { + /* Otherwise, attach it to the end of the list. */ + for (scan = head; scan -> n_uid; scan = scan -> n_uid) +#ifdef DEBUG + if (scan == lease) + abort () +#endif + ; + scan -> n_uid = lease; + } +} + +/* Delete the specified lease from the uid hash. */ + +void uid_hash_delete (lease) + struct lease *lease; +{ + struct lease *head = + find_lease_by_uid (lease -> uid, lease -> uid_len); + struct lease *scan; + + /* If it's not in the hash, we have no work to do. */ + if (!head) { + lease -> n_uid = (struct lease *)0; + return; + } + + /* If the lease we're freeing is at the head of the list, + remove the hash table entry and add a new one with the + next lease on the list (if there is one). */ + if (head == lease) { + delete_hash_entry (lease_uid_hash, + lease -> uid, lease -> uid_len); + if (lease -> n_uid) + add_hash (lease_uid_hash, + lease -> n_uid -> uid, + lease -> n_uid -> uid_len, + (unsigned char *)(lease -> n_uid)); + } else { + /* Otherwise, look for the lease in the list of leases + attached to the hash table entry, and remove it if + we find it. */ + for (scan = head; scan -> n_uid; scan = scan -> n_uid) { + if (scan -> n_uid == lease) { + scan -> n_uid = scan -> n_uid -> n_uid; + break; + } + } + } + lease -> n_uid = (struct lease *)0; +} + +/* Add the specified lease to the hardware address hash. */ + +void hw_hash_add (lease) + struct lease *lease; +{ + struct lease *head = + find_lease_by_hw_addr (lease -> hardware_addr.haddr, + lease -> hardware_addr.hlen); + struct lease *scan; + + /* If it's not in the hash, just add it. */ + if (!head) + add_hash (lease_hw_addr_hash, + lease -> hardware_addr.haddr, + lease -> hardware_addr.hlen, + (unsigned char *)lease); + else { + /* Otherwise, attach it to the end of the list. */ + for (scan = head; scan -> n_hw; scan = scan -> n_hw) + ; + scan -> n_hw = lease; + } +} + +/* Delete the specified lease from the hardware address hash. */ + +void hw_hash_delete (lease) + struct lease *lease; +{ + struct lease *head = + find_lease_by_hw_addr (lease -> hardware_addr.haddr, + lease -> hardware_addr.hlen); + struct lease *scan; + + /* If it's not in the hash, we have no work to do. */ + if (!head) { + lease -> n_hw = (struct lease *)0; + return; + } + + /* If the lease we're freeing is at the head of the list, + remove the hash table entry and add a new one with the + next lease on the list (if there is one). */ + if (head == lease) { + delete_hash_entry (lease_hw_addr_hash, + lease -> hardware_addr.haddr, + lease -> hardware_addr.hlen); + if (lease -> n_hw) + add_hash (lease_hw_addr_hash, + lease -> n_hw -> hardware_addr.haddr, + lease -> n_hw -> hardware_addr.hlen, + (unsigned char *)(lease -> n_hw)); + } else { + /* Otherwise, look for the lease in the list of leases + attached to the hash table entry, and remove it if + we find it. */ + for (scan = head; scan -> n_hw; scan = scan -> n_hw) { + if (scan -> n_hw == lease) { + scan -> n_hw = scan -> n_hw -> n_hw; + break; + } + } + } + lease -> n_hw = (struct lease *)0; +} + + +struct class *add_class (type, name) + int type; + char *name; +{ + struct class *class = new_class ("add_class"); + char *tname = (char *)malloc (strlen (name) + 1); + + if (!vendor_class_hash) + vendor_class_hash = new_hash (); + if (!user_class_hash) + user_class_hash = new_hash (); + + if (!tname || !class || !vendor_class_hash || !user_class_hash) + return (struct class *)0; + + memset (class, 0, sizeof *class); + strcpy (tname, name); + class -> name = tname; + + if (type) + add_hash (user_class_hash, + (unsigned char *)tname, strlen (tname), + (unsigned char *)class); + else + add_hash (vendor_class_hash, + (unsigned char *)tname, strlen (tname), + (unsigned char *)class); + return class; +} + +struct class *find_class (type, name, len) + int type; + unsigned char *name; + int len; +{ + struct class *class = + (struct class *)hash_lookup (type + ? user_class_hash + : vendor_class_hash, name, len); + return class; +} + +struct group *clone_group (group, caller) + struct group *group; + char *caller; +{ + struct group *g = new_group (caller); + if (!g) + error ("%s: can't allocate new group", caller); + *g = *group; + return g; +} + +/* Write all interesting leases to permanent storage. */ + +void write_leases () +{ + struct lease *l; + struct shared_network *s; + + for (s = shared_networks; s; s = s -> next) { + for (l = s -> leases; l; l = l -> next) { + if (l -> hardware_addr.hlen || + l -> uid_len || + (l -> flags & ABANDONED_LEASE)) + if (!write_lease (l)) + error ("Can't rewrite lease database"); + } + } + if (!commit_leases ()) + error ("Can't commit leases to new database: %m"); +} + +void dump_subnets () +{ + struct lease *l; + struct shared_network *s; + struct subnet *n; + + note ("Subnets:"); + for (n = subnets; n; n = n -> next_subnet) { + debug (" Subnet %s", piaddr (n -> net)); + debug (" netmask %s", + piaddr (n -> netmask)); + } + note ("Shared networks:"); + for (s = shared_networks; s; s = s -> next) { + note (" %s", s -> name); + for (l = s -> leases; l; l = l -> next) { + print_lease (l); + } + if (s -> last_lease) { + debug (" Last Lease:"); + print_lease (s -> last_lease); + } + } +} diff --git a/contrib/isc-dhcp/common/nit.c b/contrib/isc-dhcp/common/nit.c new file mode 100644 index 000000000000..1801bb9f3579 --- /dev/null +++ b/contrib/isc-dhcp/common/nit.c @@ -0,0 +1,367 @@ +/* nit.c + + Network Interface Tap (NIT) network interface code, by Ted Lemon + with one crucial tidbit of help from Stu Grossmen. */ + +/* + * Copyright (c) 1996 The Internet Software Consortium. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of The Internet Software Consortium nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND + * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This software has been written for the Internet Software Consortium + * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie + * Enterprises. To learn more about the Internet Software Consortium, + * see ``http://www.vix.com/isc''. To learn more about Vixie + * Enterprises, see ``http://www.vix.com''. */ + +#ifndef lint +static char copyright[] = +"$Id: nit.c,v 1.15.2.1 1998/12/20 18:27:44 mellon Exp $ Copyright (c) 1996 The Internet Software Consortium. All rights reserved.\n"; +#endif /* not lint */ + +#include "dhcpd.h" +#if defined (USE_NIT_SEND) || defined (USE_NIT_RECEIVE) +#include <sys/ioctl.h> +#include <sys/uio.h> + +#include <sys/time.h> +#include <net/nit.h> +#include <net/nit_if.h> +#include <net/nit_pf.h> +#include <net/nit_buf.h> +#include <sys/stropts.h> +#include <net/packetfilt.h> + +#include <netinet/in_systm.h> +#include "includes/netinet/ip.h" +#include "includes/netinet/udp.h" +#include "includes/netinet/if_ether.h" + +/* Reinitializes the specified interface after an address change. This + is not required for packet-filter APIs. */ + +#ifdef USE_NIT_SEND +void if_reinitialize_send (info) + struct interface_info *info; +{ +} +#endif + +#ifdef USE_NIT_RECEIVE +void if_reinitialize_receive (info) + struct interface_info *info; +{ +} +#endif + +/* Called by get_interface_list for each interface that's discovered. + Opens a packet filter for each interface and adds it to the select + mask. */ + +int if_register_nit (info) + struct interface_info *info; +{ + int sock; + char filename[50]; + struct ifreq ifr; + struct strioctl sio; + + /* Open a NIT device */ + sock = open ("/dev/nit", O_RDWR); + if (sock < 0) + error ("Can't open NIT device for %s: %m", info -> name); + + /* Set the NIT device to point at this interface. */ + sio.ic_cmd = NIOCBIND; + sio.ic_len = sizeof *(info -> ifp); + sio.ic_dp = (char *)(info -> ifp); + sio.ic_timout = INFTIM; + if (ioctl (sock, I_STR, &sio) < 0) + error ("Can't attach interface %s to nit device: %m", + info -> name); + + /* Get the low-level address... */ + sio.ic_cmd = SIOCGIFADDR; + sio.ic_len = sizeof ifr; + sio.ic_dp = (char *)𝔦 + sio.ic_timout = INFTIM; + if (ioctl (sock, I_STR, &sio) < 0) + error ("Can't get physical layer address for %s: %m", + info -> name); + + /* XXX code below assumes ethernet interface! */ + info -> hw_address.hlen = 6; + info -> hw_address.htype = ARPHRD_ETHER; + memcpy (info -> hw_address.haddr, ifr.ifr_ifru.ifru_addr.sa_data, 6); + + if (ioctl (sock, I_PUSH, "pf") < 0) + error ("Can't push packet filter onto NIT for %s: %m", + info -> name); + + return sock; +} +#endif /* USE_NIT_SEND || USE_NIT_RECEIVE */ + +#ifdef USE_NIT_SEND +void if_register_send (info) + struct interface_info *info; +{ + /* If we're using the nit API for sending and receiving, + we don't need to register this interface twice. */ +#ifndef USE_NIT_RECEIVE + struct packetfilt pf; + struct strioctl sio; + + info -> wfdesc = if_register_nit (info); + + pf.Pf_Priority = 0; + pf.Pf_FilterLen = 1; + pf.Pf_Filter [0] = ENF_PUSHZERO; + + /* Set up an NIT filter that rejects everything... */ + sio.ic_cmd = NIOCSETF; + sio.ic_len = sizeof pf; + sio.ic_dp = (char *)&pf; + sio.ic_timout = INFTIM; + if (ioctl (info -> wfdesc, I_STR, &sio) < 0) + error ("Can't set NIT filter: %m"); +#else + info -> wfdesc = info -> rfdesc; +#endif + if (!quiet_interface_discovery) + note ("Sending on NIT/%s/%s", + print_hw_addr (info -> hw_address.htype, + info -> hw_address.hlen, + info -> hw_address.haddr), + (info -> shared_network ? + info -> shared_network -> name : "unattached")); +} +#endif /* USE_NIT_SEND */ + +#ifdef USE_NIT_RECEIVE +/* Packet filter program... + XXX Changes to the filter program may require changes to the constant + offsets used in if_register_send to patch the NIT program! XXX */ + +void if_register_receive (info) + struct interface_info *info; +{ + int flag = 1; + u_int32_t x; + struct packetfilt pf; + struct strioctl sio; + u_int16_t addr [2]; + struct timeval t; + + /* Open a NIT device and hang it on this interface... */ + info -> rfdesc = if_register_nit (info); + + /* Set the snap length to 0, which means always take the whole + packet. */ + x = 0; + if (ioctl (info -> rfdesc, NIOCSSNAP, &x) < 0) + error ("Can't set NIT snap length on %s: %m", info -> name); + + /* Set the stream to byte stream mode */ + if (ioctl (info -> rfdesc, I_SRDOPT, RMSGN) != 0) + note ("I_SRDOPT failed on %s: %m", info -> name); + +#if 0 + /* Push on the chunker... */ + if (ioctl (info -> rfdesc, I_PUSH, "nbuf") < 0) + error ("Can't push chunker onto NIT STREAM: %m"); + + /* Set the timeout to zero. */ + t.tv_sec = 0; + t.tv_usec = 0; + if (ioctl (info -> rfdesc, NIOCSTIME, &t) < 0) + error ("Can't set chunk timeout: %m"); +#endif + + /* Ask for no header... */ + x = 0; + if (ioctl (info -> rfdesc, NIOCSFLAGS, &x) < 0) + error ("Can't set NIT flags on %s: %m", info -> name); + + /* Set up the NIT filter program. */ + /* XXX Unlike the BPF filter program, this one won't work if the + XXX IP packet is fragmented or if there are options on the IP + XXX header. */ + pf.Pf_Priority = 0; + pf.Pf_FilterLen = 0; + + pf.Pf_Filter [pf.Pf_FilterLen++] = ENF_PUSHWORD + 6; + pf.Pf_Filter [pf.Pf_FilterLen++] = ENF_PUSHLIT + ENF_CAND; + pf.Pf_Filter [pf.Pf_FilterLen++] = htons (ETHERTYPE_IP); + pf.Pf_Filter [pf.Pf_FilterLen++] = ENF_PUSHLIT; + pf.Pf_Filter [pf.Pf_FilterLen++] = htons (IPPROTO_UDP); + pf.Pf_Filter [pf.Pf_FilterLen++] = ENF_PUSHWORD + 11; + pf.Pf_Filter [pf.Pf_FilterLen++] = ENF_PUSHLIT + ENF_AND; + pf.Pf_Filter [pf.Pf_FilterLen++] = htons (0xFF); + pf.Pf_Filter [pf.Pf_FilterLen++] = ENF_CAND; + pf.Pf_Filter [pf.Pf_FilterLen++] = ENF_PUSHWORD + 18; + pf.Pf_Filter [pf.Pf_FilterLen++] = ENF_PUSHLIT + ENF_CAND; + pf.Pf_Filter [pf.Pf_FilterLen++] = local_port; + + /* Install the filter... */ + sio.ic_cmd = NIOCSETF; + sio.ic_len = sizeof pf; + sio.ic_dp = (char *)&pf; + sio.ic_timout = INFTIM; + if (ioctl (info -> rfdesc, I_STR, &sio) < 0) + error ("Can't set NIT filter on %s: %m", info -> name); + + if (!quiet_interface_discovery) + note ("Listening on NIT/%s/%s", + print_hw_addr (info -> hw_address.htype, + info -> hw_address.hlen, + info -> hw_address.haddr), + (info -> shared_network ? + info -> shared_network -> name : "unattached")); +} +#endif /* USE_NIT_RECEIVE */ + +#ifdef USE_NIT_SEND +ssize_t send_packet (interface, packet, raw, len, from, to, hto) + struct interface_info *interface; + struct packet *packet; + struct dhcp_packet *raw; + size_t len; + struct in_addr from; + struct sockaddr_in *to; + struct hardware *hto; +{ + int bufp; + unsigned char buf [1536 + sizeof (struct sockaddr)]; + struct sockaddr *junk; + struct strbuf ctl, data; + int hw_end; + struct sockaddr_in foo; + + if (!strcmp (interface -> name, "fallback")) + return send_fallback (interface, packet, raw, + len, from, to, hto); + + /* Start with the sockaddr struct... */ + junk = (struct sockaddr *)&buf [0]; + bufp = ((unsigned char *)&junk -> sa_data [0]) - &buf [0]; + + /* Assemble the headers... */ + assemble_hw_header (interface, buf, &bufp, hto); + hw_end = bufp; + assemble_udp_ip_header (interface, buf, &bufp, from.s_addr, + to -> sin_addr.s_addr, to -> sin_port, + raw, len); + + /* Copy the data into the buffer (yuk). */ + memcpy (buf + bufp, raw, len); + + /* Set up the sockaddr structure... */ +#if USE_SIN_LEN + junk -> sa_len = hw_end - 2; /* XXX */ +#endif + junk -> sa_family = AF_UNSPEC; + +#if 0 /* Already done. */ + memcpy (junk.sa_data, buf, hw_len); +#endif + + /* Set up the msg_buf structure... */ + ctl.buf = (char *)&buf [0]; + ctl.maxlen = ctl.len = hw_end; + data.buf = (char *)&buf [hw_end]; + data.maxlen = data.len = bufp + len - hw_end; + + return putmsg (interface -> wfdesc, &ctl, &data, 0); +} +#endif /* USE_NIT_SEND */ + +#ifdef USE_NIT_RECEIVE +ssize_t receive_packet (interface, buf, len, from, hfrom) + struct interface_info *interface; + unsigned char *buf; + size_t len; + struct sockaddr_in *from; + struct hardware *hfrom; +{ + int nread; + int length = 0; + int offset = 0; + unsigned char ibuf [1536]; + int bufix = 0; + + length = read (interface -> rfdesc, ibuf, sizeof ibuf); + if (length <= 0) + return length; + + /* Decode the physical header... */ + offset = decode_hw_header (interface, ibuf, bufix, hfrom); + + /* If a physical layer checksum failed (dunno of any + physical layer that supports this, but WTH), skip this + packet. */ + if (offset < 0) { + return 0; + } + + bufix += offset; + length -= offset; + + /* Decode the IP and UDP headers... */ + offset = decode_udp_ip_header (interface, ibuf, bufix, + from, (unsigned char *)0, length); + + /* If the IP or UDP checksum was bad, skip the packet... */ + if (offset < 0) + return 0; + + bufix += offset; + length -= offset; + + /* Copy out the data in the packet... */ + memcpy (buf, &ibuf [bufix], length); + return length; +} + +int can_unicast_without_arp () +{ + return 1; +} + +void maybe_setup_fallback () +{ + struct interface_info *fbi; + fbi = setup_fallback (); + if (fbi) { + if_register_fallback (fbi); + add_protocol ("fallback", fallback_interface -> wfdesc, + fallback_discard, fallback_interface); + } +} +#endif diff --git a/contrib/isc-dhcp/common/parse.c b/contrib/isc-dhcp/common/parse.c new file mode 100644 index 000000000000..d750ec53434d --- /dev/null +++ b/contrib/isc-dhcp/common/parse.c @@ -0,0 +1,649 @@ +/* parse.c + + Common parser code for dhcpd and dhclient. */ + +/* + * Copyright (c) 1995, 1996, 1997, 1998 The Internet Software Consortium. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of The Internet Software Consortium nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND + * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This software has been written for the Internet Software Consortium + * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie + * Enterprises. To learn more about the Internet Software Consortium, + * see ``http://www.vix.com/isc''. To learn more about Vixie + * Enterprises, see ``http://www.vix.com''. + */ + +#ifndef lint +static char copyright[] = +"$Id: parse.c,v 1.2.2.3 1998/12/22 22:43:22 mellon Exp $ Copyright (c) 1995, 1996, 1997, 1998 The Internet Software Consortium. All rights reserved.\n"; +#endif /* not lint */ + +#include "dhcpd.h" +#include "dhctoken.h" + +/* Skip to the semicolon ending the current statement. If we encounter + braces, the matching closing brace terminates the statement. If we + encounter a right brace but haven't encountered a left brace, return + leaving the brace in the token buffer for the caller. If we see a + semicolon and haven't seen a left brace, return. This lets us skip + over: + + statement; + statement foo bar { } + statement foo bar { statement { } } + statement} + + ...et cetera. */ + +void skip_to_semi (cfile) + FILE *cfile; +{ + int token; + char *val; + int brace_count = 0; + + do { + token = peek_token (&val, cfile); + if (token == RBRACE) { + if (brace_count) { + token = next_token (&val, cfile); + if (!--brace_count) + return; + } else + return; + } else if (token == LBRACE) { + brace_count++; + } else if (token == SEMI && !brace_count) { + token = next_token (&val, cfile); + return; + } else if (token == EOL) { + /* EOL only happens when parsing /etc/resolv.conf, + and we treat it like a semicolon because the + resolv.conf file is line-oriented. */ + token = next_token (&val, cfile); + return; + } + token = next_token (&val, cfile); + } while (token != EOF); +} + +int parse_semi (cfile) + FILE *cfile; +{ + int token; + char *val; + + token = next_token (&val, cfile); + if (token != SEMI) { + parse_warn ("semicolon expected."); + skip_to_semi (cfile); + return 0; + } + return 1; +} + +/* string-parameter :== STRING SEMI */ + +char *parse_string (cfile) + FILE *cfile; +{ + char *val; + int token; + char *s; + + token = next_token (&val, cfile); + if (token != STRING) { + parse_warn ("filename must be a string"); + skip_to_semi (cfile); + return (char *)0; + } + s = (char *)malloc (strlen (val) + 1); + if (!s) + error ("no memory for string %s.", val); + strcpy (s, val); + + if (!parse_semi (cfile)) + return (char *)0; + return s; +} + +/* hostname :== identifier | hostname DOT identifier */ + +char *parse_host_name (cfile) + FILE *cfile; +{ + char *val; + int token; + int len = 0; + char *s; + char *t; + pair c = (pair)0; + + /* Read a dotted hostname... */ + do { + /* Read a token, which should be an identifier. */ + token = next_token (&val, cfile); + if (!is_identifier (token) && token != NUMBER) { + parse_warn ("expecting an identifier in hostname"); + skip_to_semi (cfile); + return (char *)0; + } + /* Store this identifier... */ + if (!(s = (char *)malloc (strlen (val) + 1))) + error ("can't allocate temp space for hostname."); + strcpy (s, val); + c = cons ((caddr_t)s, c); + len += strlen (s) + 1; + /* Look for a dot; if it's there, keep going, otherwise + we're done. */ + token = peek_token (&val, cfile); + if (token == DOT) + token = next_token (&val, cfile); + } while (token == DOT); + + /* Assemble the hostname together into a string. */ + if (!(s = (char *)malloc (len))) + error ("can't allocate space for hostname."); + t = s + len; + *--t = 0; + while (c) { + pair cdr = c -> cdr; + int l = strlen ((char *)(c -> car)); + t -= l; + memcpy (t, (char *)(c -> car), l); + /* Free up temp space. */ + free (c -> car); + free (c); + c = cdr; + if (t != s) + *--t = '.'; + } + return s; +} + +int parse_ip_addr (cfile, addr) + FILE *cfile; + struct iaddr *addr; +{ + char *val; + int token; + + addr -> len = 4; + if (parse_numeric_aggregate (cfile, addr -> iabuf, + &addr -> len, DOT, 10, 8)) + return 1; + return 0; +} + +/* hardware-parameter :== HARDWARE ETHERNET csns SEMI + csns :== NUMBER | csns COLON NUMBER */ + +void parse_hardware_param (cfile, hardware) + FILE *cfile; + struct hardware *hardware; +{ + char *val; + int token; + int hlen; + unsigned char *t; + + token = next_token (&val, cfile); + switch (token) { + case ETHERNET: + hardware -> htype = HTYPE_ETHER; + break; + case TOKEN_RING: + hardware -> htype = HTYPE_IEEE802; + break; + case FDDI: + hardware -> htype = HTYPE_FDDI; + break; + default: + parse_warn ("expecting a network hardware type"); + skip_to_semi (cfile); + return; + } + + /* Parse the hardware address information. Technically, + it would make a lot of sense to restrict the length of the + data we'll accept here to the length of a particular hardware + address type. Unfortunately, there are some broken clients + out there that put bogus data in the chaddr buffer, and we accept + that data in the lease file rather than simply failing on such + clients. Yuck. */ + hlen = 0; + t = parse_numeric_aggregate (cfile, (unsigned char *)0, &hlen, + COLON, 16, 8); + if (!t) + return; + if (hlen > sizeof hardware -> haddr) { + free (t); + parse_warn ("hardware address too long"); + } else { + hardware -> hlen = hlen; + memcpy ((unsigned char *)&hardware -> haddr [0], + t, hardware -> hlen); + if (hlen < sizeof hardware -> haddr) + memset (&hardware -> haddr [hlen], 0, + (sizeof hardware -> haddr) - hlen); + free (t); + } + + token = next_token (&val, cfile); + if (token != SEMI) { + parse_warn ("expecting semicolon."); + skip_to_semi (cfile); + } +} + +/* lease-time :== NUMBER SEMI */ + +void parse_lease_time (cfile, timep) + FILE *cfile; + TIME *timep; +{ + char *val; + int token; + + token = next_token (&val, cfile); + if (token != NUMBER) { + parse_warn ("Expecting numeric lease time"); + skip_to_semi (cfile); + return; + } + convert_num ((unsigned char *)timep, val, 10, 32); + /* Unswap the number - convert_num returns stuff in NBO. */ + *timep = ntohl (*timep); /* XXX */ + + parse_semi (cfile); +} + +/* No BNF for numeric aggregates - that's defined by the caller. What + this function does is to parse a sequence of numbers seperated by + the token specified in seperator. If max is zero, any number of + numbers will be parsed; otherwise, exactly max numbers are + expected. Base and size tell us how to internalize the numbers + once they've been tokenized. */ + +unsigned char *parse_numeric_aggregate (cfile, buf, + max, seperator, base, size) + FILE *cfile; + unsigned char *buf; + int *max; + int seperator; + int base; + int size; +{ + char *val; + int token; + unsigned char *bufp = buf, *s; + char *t; + int count = 0; + pair c = (pair)0; + + if (!bufp && *max) { + bufp = (unsigned char *)malloc (*max * size / 8); + if (!bufp) + error ("can't allocate space for numeric aggregate"); + } else + s = bufp; + + do { + if (count) { + token = peek_token (&val, cfile); + if (token != seperator) { + if (!*max) + break; + if (token != RBRACE && token != LBRACE) + token = next_token (&val, cfile); + parse_warn ("too few numbers."); + if (token != SEMI) + skip_to_semi (cfile); + return (unsigned char *)0; + } + token = next_token (&val, cfile); + } + token = next_token (&val, cfile); + + if (token == EOF) { + parse_warn ("unexpected end of file"); + break; + } + + /* Allow NUMBER_OR_NAME if base is 16. */ + if (token != NUMBER && + (base != 16 || token != NUMBER_OR_NAME)) { + parse_warn ("expecting numeric value."); + skip_to_semi (cfile); + return (unsigned char *)0; + } + /* If we can, convert the number now; otherwise, build + a linked list of all the numbers. */ + if (s) { + convert_num (s, val, base, size); + s += size / 8; + } else { + t = (char *)malloc (strlen (val) + 1); + if (!t) + error ("no temp space for number."); + strcpy (t, val); + c = cons (t, c); + } + } while (++count != *max); + + /* If we had to cons up a list, convert it now. */ + if (c) { + bufp = (unsigned char *)malloc (count * size / 8); + if (!bufp) + error ("can't allocate space for numeric aggregate."); + s = bufp + count - size / 8; + *max = count; + } + while (c) { + pair cdr = c -> cdr; + convert_num (s, (char *)(c -> car), base, size); + s -= size / 8; + /* Free up temp space. */ + free (c -> car); + free (c); + c = cdr; + } + return bufp; +} + +void convert_num (buf, str, base, size) + unsigned char *buf; + char *str; + int base; + int size; +{ + char *ptr = str; + int negative = 0; + u_int32_t val = 0; + int tval; + int max; + + if (*ptr == '-') { + negative = 1; + ++ptr; + } + + /* If base wasn't specified, figure it out from the data. */ + if (!base) { + if (ptr [0] == '0') { + if (ptr [1] == 'x') { + base = 16; + ptr += 2; + } else if (isascii (ptr [1]) && isdigit (ptr [1])) { + base = 8; + ptr += 1; + } else { + base = 10; + } + } else { + base = 10; + } + } + + do { + tval = *ptr++; + /* XXX assumes ASCII... */ + if (tval >= 'a') + tval = tval - 'a' + 10; + else if (tval >= 'A') + tval = tval - 'A' + 10; + else if (tval >= '0') + tval -= '0'; + else { + warn ("Bogus number: %s.", str); + break; + } + if (tval >= base) { + warn ("Bogus number: %s: digit %d not in base %d\n", + str, tval, base); + break; + } + val = val * base + tval; + } while (*ptr); + + if (negative) + max = (1 << (size - 1)); + else + max = (1 << (size - 1)) + ((1 << (size - 1)) - 1); + if (val > max) { + switch (base) { + case 8: + warn ("value %s%o exceeds max (%d) for precision.", + negative ? "-" : "", val, max); + break; + case 16: + warn ("value %s%x exceeds max (%d) for precision.", + negative ? "-" : "", val, max); + break; + default: + warn ("value %s%u exceeds max (%d) for precision.", + negative ? "-" : "", val, max); + break; + } + } + + if (negative) { + switch (size) { + case 8: + *buf = -(unsigned long)val; + break; + case 16: + putShort (buf, -(unsigned long)val); + break; + case 32: + putLong (buf, -(unsigned long)val); + break; + default: + warn ("Unexpected integer size: %d\n", size); + break; + } + } else { + switch (size) { + case 8: + *buf = (u_int8_t)val; + break; + case 16: + putUShort (buf, (u_int16_t)val); + break; + case 32: + putULong (buf, val); + break; + default: + warn ("Unexpected integer size: %d\n", size); + break; + } + } +} + +/* date :== NUMBER NUMBER SLASH NUMBER SLASH NUMBER + NUMBER COLON NUMBER COLON NUMBER SEMI + + Dates are always in GMT; first number is day of week; next is + year/month/day; next is hours:minutes:seconds on a 24-hour + clock. */ + +TIME parse_date (cfile) + FILE *cfile; +{ + struct tm tm; + int guess; + char *val; + int token; + static int months [11] = { 31, 59, 90, 120, 151, 181, + 212, 243, 273, 304, 334 }; + + /* Day of week... */ + token = next_token (&val, cfile); + if (token != NUMBER) { + parse_warn ("numeric day of week expected."); + if (token != SEMI) + skip_to_semi (cfile); + return (TIME)0; + } + tm.tm_wday = atoi (val); + + /* Year... */ + token = next_token (&val, cfile); + if (token != NUMBER) { + parse_warn ("numeric year expected."); + if (token != SEMI) + skip_to_semi (cfile); + return (TIME)0; + } + tm.tm_year = atoi (val); + if (tm.tm_year > 1900) + tm.tm_year -= 1900; + + /* Slash seperating year from month... */ + token = next_token (&val, cfile); + if (token != SLASH) { + parse_warn ("expected slash seperating year from month."); + if (token != SEMI) + skip_to_semi (cfile); + return (TIME)0; + } + + /* Month... */ + token = next_token (&val, cfile); + if (token != NUMBER) { + parse_warn ("numeric month expected."); + if (token != SEMI) + skip_to_semi (cfile); + return (TIME)0; + } + tm.tm_mon = atoi (val) - 1; + + /* Slash seperating month from day... */ + token = next_token (&val, cfile); + if (token != SLASH) { + parse_warn ("expected slash seperating month from day."); + if (token != SEMI) + skip_to_semi (cfile); + return (TIME)0; + } + + /* Month... */ + token = next_token (&val, cfile); + if (token != NUMBER) { + parse_warn ("numeric day of month expected."); + if (token != SEMI) + skip_to_semi (cfile); + return (TIME)0; + } + tm.tm_mday = atoi (val); + + /* Hour... */ + token = next_token (&val, cfile); + if (token != NUMBER) { + parse_warn ("numeric hour expected."); + if (token != SEMI) + skip_to_semi (cfile); + return (TIME)0; + } + tm.tm_hour = atoi (val); + + /* Colon seperating hour from minute... */ + token = next_token (&val, cfile); + if (token != COLON) { + parse_warn ("expected colon seperating hour from minute."); + if (token != SEMI) + skip_to_semi (cfile); + return (TIME)0; + } + + /* Minute... */ + token = next_token (&val, cfile); + if (token != NUMBER) { + parse_warn ("numeric minute expected."); + if (token != SEMI) + skip_to_semi (cfile); + return (TIME)0; + } + tm.tm_min = atoi (val); + + /* Colon seperating minute from second... */ + token = next_token (&val, cfile); + if (token != COLON) { + parse_warn ("expected colon seperating hour from minute."); + if (token != SEMI) + skip_to_semi (cfile); + return (TIME)0; + } + + /* Minute... */ + token = next_token (&val, cfile); + if (token != NUMBER) { + parse_warn ("numeric minute expected."); + if (token != SEMI) + skip_to_semi (cfile); + return (TIME)0; + } + tm.tm_sec = atoi (val); + tm.tm_isdst = 0; + + /* XXX */ /* We assume that mktime does not use tm_yday. */ + tm.tm_yday = 0; + + /* Make sure the date ends in a semicolon... */ + token = next_token (&val, cfile); + if (token != SEMI) { + parse_warn ("semicolon expected."); + skip_to_semi (cfile); + return 0; + } + + /* Guess the time value... */ + guess = ((((((365 * (tm.tm_year - 70) + /* Days in years since '70 */ + (tm.tm_year - 69) / 4 + /* Leap days since '70 */ + (tm.tm_mon /* Days in months this year */ + ? months [tm.tm_mon - 1] + : 0) + + (tm.tm_mon > 1 && /* Leap day this year */ + !((tm.tm_year - 72) & 3)) + + tm.tm_mday - 1) * 24) + /* Day of month */ + tm.tm_hour) * 60) + + tm.tm_min) * 60) + tm.tm_sec; + + /* This guess could be wrong because of leap seconds or other + weirdness we don't know about that the system does. For + now, we're just going to accept the guess, but at some point + it might be nice to do a successive approximation here to + get an exact value. Even if the error is small, if the + server is restarted frequently (and thus the lease database + is reread), the error could accumulate into something + significant. */ + + return guess; +} diff --git a/contrib/isc-dhcp/common/print.c b/contrib/isc-dhcp/common/print.c new file mode 100644 index 000000000000..4a2b464862d6 --- /dev/null +++ b/contrib/isc-dhcp/common/print.c @@ -0,0 +1,184 @@ +/* print.c + + Turn data structures into printable text. */ + +/* + * Copyright (c) 1995, 1996, 1997, 1998 The Internet Software Consortium. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of The Internet Software Consortium nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND + * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This software has been written for the Internet Software Consortium + * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie + * Enterprises. To learn more about the Internet Software Consortium, + * see ``http://www.vix.com/isc''. To learn more about Vixie + * Enterprises, see ``http://www.vix.com''. + */ + +#ifndef lint +static char copyright[] = +"$Id: print.c,v 1.16.2.2 1998/11/24 22:39:35 mellon Exp $ Copyright (c) 1995, 1996, 1997, 1998 The Internet Software Consortium. All rights reserved.\n"; +#endif /* not lint */ + +#include "dhcpd.h" + +char *print_hw_addr (htype, hlen, data) + int htype; + int hlen; + unsigned char *data; +{ + static char habuf [49]; + char *s; + int i; + + if (htype == 0 || hlen == 0) { + strcpy (habuf, "<null>"); + } else { + s = habuf; + for (i = 0; i < hlen; i++) { + sprintf (s, "%02x", data [i]); + s += strlen (s); + *s++ = ':'; + } + *--s = 0; + } + return habuf; +} + +void print_lease (lease) + struct lease *lease; +{ + struct tm *t; + char tbuf [32]; + + debug (" Lease %s", + piaddr (lease -> ip_addr)); + + t = gmtime (&lease -> starts); + strftime (tbuf, sizeof tbuf, "%D %H:%M:%S", t); + debug (" start %s", tbuf); + + t = gmtime (&lease -> ends); + strftime (tbuf, sizeof tbuf, "%D %H:%M:%S", t); + debug (" end %s", tbuf); + + t = gmtime (&lease -> timestamp); + strftime (tbuf, sizeof tbuf, "%D %H:%M:%S", t); + debug (" stamp %s", tbuf); + + debug (" hardware addr = %s", + print_hw_addr (lease -> hardware_addr.htype, + lease -> hardware_addr.hlen, + lease -> hardware_addr.haddr)); + debug (" host %s ", + lease -> host ? lease -> host -> name : "<none>"); +} + +void dump_packet (tp) + struct packet *tp; +{ + struct dhcp_packet *tdp = tp -> raw; + + debug ("packet length %d", tp -> packet_length); + debug ("op = %d htype = %d hlen = %d hops = %d", + tdp -> op, tdp -> htype, tdp -> hlen, tdp -> hops); + debug ("xid = %x secs = %d flags = %x", + tdp -> xid, tdp -> secs, tdp -> flags); + debug ("ciaddr = %s", inet_ntoa (tdp -> ciaddr)); + debug ("yiaddr = %s", inet_ntoa (tdp -> yiaddr)); + debug ("siaddr = %s", inet_ntoa (tdp -> siaddr)); + debug ("giaddr = %s", inet_ntoa (tdp -> giaddr)); + debug ("chaddr = %02.2x:%02.2x:%02.2x:%02.2x:%02.2x:%02.2x", + ((unsigned char *)(tdp -> chaddr)) [0], + ((unsigned char *)(tdp -> chaddr)) [1], + ((unsigned char *)(tdp -> chaddr)) [2], + ((unsigned char *)(tdp -> chaddr)) [3], + ((unsigned char *)(tdp -> chaddr)) [4], + ((unsigned char *)(tdp -> chaddr)) [5]); + debug ("filename = %s", tdp -> file); + debug ("server_name = %s", tdp -> sname); + if (tp -> options_valid) { + int i; + + for (i = 0; i < 256; i++) { + if (tp -> options [i].data) + debug (" %s = %s", + dhcp_options [i].name, + pretty_print_option + (i, tp -> options [i].data, + tp -> options [i].len, 1, 1)); + } + } + debug (""); +} + +void dump_raw (buf, len) + unsigned char *buf; + int len; +{ + int i; + char lbuf [80]; + int lbix = 0; + + lbuf [0] = 0; + + for (i = 0; i < len; i++) { + if ((i & 15) == 0) { + if (lbix) + note (lbuf); + sprintf (lbuf, "%03x:", i); + lbix = 4; + } else if ((i & 7) == 0) + lbuf [lbix++] = ' '; + sprintf (&lbuf [lbix], " %02x", buf [i]); + lbix += 3; + } + note (lbuf); +} + +void hash_dump (table) + struct hash_table *table; +{ + int i; + struct hash_bucket *bp; + + if (!table) + return; + + for (i = 0; i < table -> hash_count; i++) { + if (!table -> buckets [i]) + continue; + note ("hash bucket %d:", i); + for (bp = table -> buckets [i]; bp; bp = bp -> next) { + if (bp -> len) + dump_raw (bp -> name, bp -> len); + else + note ((char *)bp -> name); + } + } +} diff --git a/contrib/isc-dhcp/common/socket.c b/contrib/isc-dhcp/common/socket.c new file mode 100644 index 000000000000..b2ae5b4cae97 --- /dev/null +++ b/contrib/isc-dhcp/common/socket.c @@ -0,0 +1,280 @@ +/* socket.c + + BSD socket interface code... */ + +/* + * Copyright (c) 1995, 1996, 1997, 1998, 1999 + * The Internet Software Consortium. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of The Internet Software Consortium nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND + * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This software has been written for the Internet Software Consortium + * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie + * Enterprises. To learn more about the Internet Software Consortium, + * see ``http://www.vix.com/isc''. To learn more about Vixie + * Enterprises, see ``http://www.vix.com''. + */ + +/* SO_BINDTODEVICE support added by Elliot Poger (poger@leland.stanford.edu). + * This sockopt allows a socket to be bound to a particular interface, + * thus enabling the use of DHCPD on a multihomed host. + * If SO_BINDTODEVICE is defined in your system header files, the use of + * this sockopt will be automatically enabled. + * I have implemented it under Linux; other systems should be doable also. + */ + +#ifndef lint +static char copyright[] = +"$Id: socket.c,v 1.26.2.6 1999/02/03 19:46:04 mellon Exp $ Copyright (c) 1995, 1996, 1997, 1998, 1999 The Internet Software Consortium. All rights reserved.\n"; +#endif /* not lint */ + +#include "dhcpd.h" + +#ifdef USE_SOCKET_FALLBACK +# define USE_SOCKET_SEND +# define if_register_send if_register_fallback +# define send_packet send_fallback +# define if_reinitialize_send if_reinitialize_fallback +#endif + +static int once = 0; + +/* Reinitializes the specified interface after an address change. This + is not required for packet-filter APIs. */ + +#ifdef USE_SOCKET_SEND +void if_reinitialize_send (info) + struct interface_info *info; +{ +#if 0 +#ifndef USE_SOCKET_RECEIVE + once = 0; + close (info -> wfdesc); +#endif + if_register_send (info); +#endif +} +#endif + +#ifdef USE_SOCKET_RECEIVE +void if_reinitialize_receive (info) + struct interface_info *info; +{ +#if 0 + once = 0; + close (info -> rfdesc); + if_register_receive (info); +#endif +} +#endif + +#if defined (USE_SOCKET_SEND) || defined (USE_SOCKET_RECEIVE) +/* Generic interface registration routine... */ +int if_register_socket (info) + struct interface_info *info; +{ + struct sockaddr_in name; + int sock; + int flag; + +#if !defined (SO_BINDTODEVICE) && !defined (USE_FALLBACK) + /* Make sure only one interface is registered. */ + if (once) + error ("The standard socket API can only support %s", + "hosts with a single network interface."); + once = 1; +#endif + + /* Set up the address we're going to bind to. */ + name.sin_family = AF_INET; + name.sin_port = local_port; + name.sin_addr.s_addr = INADDR_ANY; + memset (name.sin_zero, 0, sizeof (name.sin_zero)); + + /* Make a socket... */ + if ((sock = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) + error ("Can't create dhcp socket: %m"); + + /* Set the REUSEADDR option so that we don't fail to start if + we're being restarted. */ + flag = 1; + if (setsockopt (sock, SOL_SOCKET, SO_REUSEADDR, + (char *)&flag, sizeof flag) < 0) + error ("Can't set SO_REUSEADDR option on dhcp socket: %m"); + + /* Set the BROADCAST option so that we can broadcast DHCP responses. */ + if (setsockopt (sock, SOL_SOCKET, SO_BROADCAST, + (char *)&flag, sizeof flag) < 0) + error ("Can't set SO_BROADCAST option on dhcp socket: %m"); + + /* Bind the socket to this interface's IP address. */ + if (bind (sock, (struct sockaddr *)&name, sizeof name) < 0) + error ("Can't bind to dhcp address: %m"); + +#if defined (SO_BINDTODEVICE) + /* Bind this socket to this interface. */ + if (info -> ifp && + setsockopt (sock, SOL_SOCKET, SO_BINDTODEVICE, + (char *)(info -> ifp), sizeof *(info -> ifp)) < 0) { + error("setting SO_BINDTODEVICE"); + } +#endif + + return sock; +} +#endif /* USE_SOCKET_SEND || USE_SOCKET_RECEIVE */ + +#ifdef USE_SOCKET_SEND +void if_register_send (info) + struct interface_info *info; +{ +#ifndef USE_SOCKET_RECEIVE + info -> wfdesc = if_register_socket (info); +#else + info -> wfdesc = info -> rfdesc; +#endif + if (!quiet_interface_discovery) + note ("Sending on Socket/%s/%s", + info -> name, + (info -> shared_network ? + info -> shared_network -> name : "unattached")); + +} +#endif /* USE_SOCKET_SEND */ + +#ifdef USE_SOCKET_RECEIVE +void if_register_receive (info) + struct interface_info *info; +{ + /* If we're using the socket API for sending and receiving, + we don't need to register this interface twice. */ + info -> rfdesc = if_register_socket (info); + if (!quiet_interface_discovery) + note ("Listening on Socket/%s/%s", + info -> name, + (info -> shared_network ? + info -> shared_network -> name : "unattached")); +} +#endif /* USE_SOCKET_RECEIVE */ + +#ifdef USE_SOCKET_SEND +ssize_t send_packet (interface, packet, raw, len, from, to, hto) + struct interface_info *interface; + struct packet *packet; + struct dhcp_packet *raw; + size_t len; + struct in_addr from; + struct sockaddr_in *to; + struct hardware *hto; +{ + int result; +#ifdef IGNORE_HOSTUNREACH + int retry = 0; + do { +#endif + result = sendto (interface -> wfdesc, (char *)raw, len, 0, + (struct sockaddr *)to, sizeof *to); +#ifdef IGNORE_HOSTUNREACH + } while (to -> sin_addr.s_addr == htonl (INADDR_BROADCAST) && + result < 0 && + (errno == EHOSTUNREACH || + errno == ECONNREFUSED) && + retry++ < 10); +#endif + return result; +} +#endif /* USE_SOCKET_SEND */ + +#ifdef USE_SOCKET_RECEIVE +ssize_t receive_packet (interface, buf, len, from, hfrom) + struct interface_info *interface; + unsigned char *buf; + size_t len; + struct sockaddr_in *from; + struct hardware *hfrom; +{ + int flen = sizeof *from; + int result; + +#ifdef IGNORE_HOSTUNREACH + int retry = 0; + do { +#endif + result = recvfrom (interface -> rfdesc, (char *)buf, len, 0, + (struct sockaddr *)from, &flen); +#ifdef IGNORE_HOSTUNREACH + } while (result < 0 && + (errno == EHOSTUNREACH || + errno == ECONNREFUSED) && + retry++ < 10); +#endif + return result; +} +#endif /* USE_SOCKET_RECEIVE */ + +#ifdef USE_SOCKET_SEND +/* This just reads in a packet and silently discards it. */ + +void fallback_discard (protocol) + struct protocol *protocol; +{ + char buf [1540]; + struct sockaddr_in from; + int flen = sizeof from; + int status; + struct interface_info *interface = protocol -> local; + + status = recvfrom (interface -> wfdesc, buf, sizeof buf, 0, + (struct sockaddr *)&from, &flen); + if (status < 0) + warn ("fallback_discard: %m"); +} +#endif /* USE_SOCKET_SEND */ + +#if defined (USE_SOCKET_SEND) && !defined (USE_SOCKET_FALLBACK) +int can_unicast_without_arp () +{ + return 0; +} + +/* If we have SO_BINDTODEVICE, set up a fallback interface; otherwise, + do not. */ + +void maybe_setup_fallback () +{ +#if defined (SO_BINDTODEVICE) + struct interface_info *fbi; + fbi = setup_fallback (); + if (fbi) { + fbi -> wfdesc = if_register_socket (fbi); + add_protocol ("fallback", + fbi -> wfdesc, fallback_discard, fbi); + } +#endif +} +#endif /* USE_SOCKET_SEND && !USE_SOCKET_FALLBACK */ diff --git a/contrib/isc-dhcp/common/tables.c b/contrib/isc-dhcp/common/tables.c new file mode 100644 index 000000000000..abbff6f4cbe7 --- /dev/null +++ b/contrib/isc-dhcp/common/tables.c @@ -0,0 +1,692 @@ +/* tables.c + + Tables of information... */ + +/* + * Copyright (c) 1995, 1996 The Internet Software Consortium. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of The Internet Software Consortium nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND + * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This software has been written for the Internet Software Consortium + * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie + * Enterprises. To learn more about the Internet Software Consortium, + * see ``http://www.vix.com/isc''. To learn more about Vixie + * Enterprises, see ``http://www.vix.com''. + */ + +#ifndef lint +static char copyright[] = +"$Id: tables.c,v 1.13.2.3 1998/12/22 22:45:44 mellon Exp $ Copyright (c) 1995, 1996 The Internet Software Consortium. All rights reserved.\n"; +#endif /* not lint */ + +#include "dhcpd.h" + +/* DHCP Option names, formats and codes, from RFC1533. + + Format codes: + + e - end of data + I - IP address + l - 32-bit signed integer + L - 32-bit unsigned integer + s - 16-bit signed integer + S - 16-bit unsigned integer + b - 8-bit signed integer + B - 8-bit unsigned integer + t - ASCII text + f - flag (true or false) + A - array of whatever precedes (e.g., IA means array of IP addresses) +*/ + +struct universe dhcp_universe; +struct option dhcp_options [256] = { + { "pad", "", &dhcp_universe, 0 }, + { "subnet-mask", "I", &dhcp_universe, 1 }, + { "time-offset", "l", &dhcp_universe, 2 }, + { "routers", "IA", &dhcp_universe, 3 }, + { "time-servers", "IA", &dhcp_universe, 4 }, + { "ien116-name-servers", "IA", &dhcp_universe, 5 }, + { "domain-name-servers", "IA", &dhcp_universe, 6 }, + { "log-servers", "IA", &dhcp_universe, 7 }, + { "cookie-servers", "IA", &dhcp_universe, 8 }, + { "lpr-servers", "IA", &dhcp_universe, 9 }, + { "impress-servers", "IA", &dhcp_universe, 10 }, + { "resource-location-servers", "IA", &dhcp_universe, 11 }, + { "host-name", "X", &dhcp_universe, 12 }, + { "boot-size", "S", &dhcp_universe, 13 }, + { "merit-dump", "t", &dhcp_universe, 14 }, + { "domain-name", "t", &dhcp_universe, 15 }, + { "swap-server", "I", &dhcp_universe, 16 }, + { "root-path", "t", &dhcp_universe, 17 }, + { "extensions-path", "t", &dhcp_universe, 18 }, + { "ip-forwarding", "f", &dhcp_universe, 19 }, + { "non-local-source-routing", "f", &dhcp_universe, 20 }, + { "policy-filter", "IIA", &dhcp_universe, 21 }, + { "max-dgram-reassembly", "S", &dhcp_universe, 22 }, + { "default-ip-ttl", "B", &dhcp_universe, 23 }, + { "path-mtu-aging-timeout", "L", &dhcp_universe, 24 }, + { "path-mtu-plateau-table", "SA", &dhcp_universe, 25 }, + { "interface-mtu", "S", &dhcp_universe, 26 }, + { "all-subnets-local", "f", &dhcp_universe, 27 }, + { "broadcast-address", "I", &dhcp_universe, 28 }, + { "perform-mask-discovery", "f", &dhcp_universe, 29 }, + { "mask-supplier", "f", &dhcp_universe, 30 }, + { "router-discovery", "f", &dhcp_universe, 31 }, + { "router-solicitation-address", "I", &dhcp_universe, 32 }, + { "static-routes", "IIA", &dhcp_universe, 33 }, + { "trailer-encapsulation", "f", &dhcp_universe, 34 }, + { "arp-cache-timeout", "L", &dhcp_universe, 35 }, + { "ieee802-3-encapsulation", "f", &dhcp_universe, 36 }, + { "default-tcp-ttl", "B", &dhcp_universe, 37 }, + { "tcp-keepalive-interval", "L", &dhcp_universe, 38 }, + { "tcp-keepalive-garbage", "f", &dhcp_universe, 39 }, + { "nis-domain", "t", &dhcp_universe, 40 }, + { "nis-servers", "IA", &dhcp_universe, 41 }, + { "ntp-servers", "IA", &dhcp_universe, 42 }, + { "vendor-encapsulated-options", "X", &dhcp_universe, 43 }, + { "netbios-name-servers", "IA", &dhcp_universe, 44 }, + { "netbios-dd-server", "IA", &dhcp_universe, 45 }, + { "netbios-node-type", "B", &dhcp_universe, 46 }, + { "netbios-scope", "t", &dhcp_universe, 47 }, + { "font-servers", "IA", &dhcp_universe, 48 }, + { "x-display-manager", "IA", &dhcp_universe, 49 }, + { "dhcp-requested-address", "I", &dhcp_universe, 50 }, + { "dhcp-lease-time", "L", &dhcp_universe, 51 }, + { "dhcp-option-overload", "B", &dhcp_universe, 52 }, + { "dhcp-message-type", "B", &dhcp_universe, 53 }, + { "dhcp-server-identifier", "I", &dhcp_universe, 54 }, + { "dhcp-parameter-request-list", "BA", &dhcp_universe, 55 }, + { "dhcp-message", "t", &dhcp_universe, 56 }, + { "dhcp-max-message-size", "S", &dhcp_universe, 57 }, + { "dhcp-renewal-time", "L", &dhcp_universe, 58 }, + { "dhcp-rebinding-time", "L", &dhcp_universe, 59 }, + { "dhcp-class-identifier", "t", &dhcp_universe, 60 }, + { "dhcp-client-identifier", "X", &dhcp_universe, 61 }, + { "option-62", "X", &dhcp_universe, 62 }, + { "option-63", "X", &dhcp_universe, 63 }, + { "option-64", "X", &dhcp_universe, 64 }, + { "option-65", "X", &dhcp_universe, 65 }, + { "option-66", "X", &dhcp_universe, 66 }, + { "option-67", "X", &dhcp_universe, 67 }, + { "option-68", "X", &dhcp_universe, 68 }, + { "option-69", "X", &dhcp_universe, 69 }, + { "option-70", "X", &dhcp_universe, 70 }, + { "option-71", "X", &dhcp_universe, 71 }, + { "option-72", "X", &dhcp_universe, 72 }, + { "option-73", "X", &dhcp_universe, 73 }, + { "option-74", "X", &dhcp_universe, 74 }, + { "option-75", "X", &dhcp_universe, 75 }, + { "option-76", "X", &dhcp_universe, 76 }, + { "dhcp-user-class-identifier", "t", &dhcp_universe, 77 }, + { "option-78", "X", &dhcp_universe, 78 }, + { "option-79", "X", &dhcp_universe, 79 }, + { "option-80", "X", &dhcp_universe, 80 }, + { "option-81", "X", &dhcp_universe, 81 }, + { "option-82", "X", &dhcp_universe, 82 }, + { "option-83", "X", &dhcp_universe, 83 }, + { "option-84", "X", &dhcp_universe, 84 }, + { "nds-servers", "IA", &dhcp_universe, 85 }, + { "nds-tree-name", "X", &dhcp_universe, 86 }, + { "nds-context", "X", &dhcp_universe, 87 }, + { "option-88", "X", &dhcp_universe, 88 }, + { "option-89", "X", &dhcp_universe, 89 }, + { "option-90", "X", &dhcp_universe, 90 }, + { "option-91", "X", &dhcp_universe, 91 }, + { "option-92", "X", &dhcp_universe, 92 }, + { "option-93", "X", &dhcp_universe, 93 }, + { "option-94", "X", &dhcp_universe, 94 }, + { "option-95", "X", &dhcp_universe, 95 }, + { "option-96", "X", &dhcp_universe, 96 }, + { "option-97", "X", &dhcp_universe, 97 }, + { "option-98", "X", &dhcp_universe, 98 }, + { "option-99", "X", &dhcp_universe, 99 }, + { "option-100", "X", &dhcp_universe, 100 }, + { "option-101", "X", &dhcp_universe, 101 }, + { "option-102", "X", &dhcp_universe, 102 }, + { "option-103", "X", &dhcp_universe, 103 }, + { "option-104", "X", &dhcp_universe, 104 }, + { "option-105", "X", &dhcp_universe, 105 }, + { "option-106", "X", &dhcp_universe, 106 }, + { "option-107", "X", &dhcp_universe, 107 }, + { "option-108", "X", &dhcp_universe, 108 }, + { "option-109", "X", &dhcp_universe, 109 }, + { "option-110", "X", &dhcp_universe, 110 }, + { "option-111", "X", &dhcp_universe, 111 }, + { "option-112", "X", &dhcp_universe, 112 }, + { "option-113", "X", &dhcp_universe, 113 }, + { "option-114", "X", &dhcp_universe, 114 }, + { "option-115", "X", &dhcp_universe, 115 }, + { "option-116", "X", &dhcp_universe, 116 }, + { "option-117", "X", &dhcp_universe, 117 }, + { "option-118", "X", &dhcp_universe, 118 }, + { "option-119", "X", &dhcp_universe, 119 }, + { "option-120", "X", &dhcp_universe, 120 }, + { "option-121", "X", &dhcp_universe, 121 }, + { "option-122", "X", &dhcp_universe, 122 }, + { "option-123", "X", &dhcp_universe, 123 }, + { "option-124", "X", &dhcp_universe, 124 }, + { "option-125", "X", &dhcp_universe, 125 }, + { "option-126", "X", &dhcp_universe, 126 }, + { "option-127", "X", &dhcp_universe, 127 }, + { "option-128", "X", &dhcp_universe, 128 }, + { "option-129", "X", &dhcp_universe, 129 }, + { "option-130", "X", &dhcp_universe, 130 }, + { "option-131", "X", &dhcp_universe, 131 }, + { "option-132", "X", &dhcp_universe, 132 }, + { "option-133", "X", &dhcp_universe, 133 }, + { "option-134", "X", &dhcp_universe, 134 }, + { "option-135", "X", &dhcp_universe, 135 }, + { "option-136", "X", &dhcp_universe, 136 }, + { "option-137", "X", &dhcp_universe, 137 }, + { "option-138", "X", &dhcp_universe, 138 }, + { "option-139", "X", &dhcp_universe, 139 }, + { "option-140", "X", &dhcp_universe, 140 }, + { "option-141", "X", &dhcp_universe, 141 }, + { "option-142", "X", &dhcp_universe, 142 }, + { "option-143", "X", &dhcp_universe, 143 }, + { "option-144", "X", &dhcp_universe, 144 }, + { "option-145", "X", &dhcp_universe, 145 }, + { "option-146", "X", &dhcp_universe, 146 }, + { "option-147", "X", &dhcp_universe, 147 }, + { "option-148", "X", &dhcp_universe, 148 }, + { "option-149", "X", &dhcp_universe, 149 }, + { "option-150", "X", &dhcp_universe, 150 }, + { "option-151", "X", &dhcp_universe, 151 }, + { "option-152", "X", &dhcp_universe, 152 }, + { "option-153", "X", &dhcp_universe, 153 }, + { "option-154", "X", &dhcp_universe, 154 }, + { "option-155", "X", &dhcp_universe, 155 }, + { "option-156", "X", &dhcp_universe, 156 }, + { "option-157", "X", &dhcp_universe, 157 }, + { "option-158", "X", &dhcp_universe, 158 }, + { "option-159", "X", &dhcp_universe, 159 }, + { "option-160", "X", &dhcp_universe, 160 }, + { "option-161", "X", &dhcp_universe, 161 }, + { "option-162", "X", &dhcp_universe, 162 }, + { "option-163", "X", &dhcp_universe, 163 }, + { "option-164", "X", &dhcp_universe, 164 }, + { "option-165", "X", &dhcp_universe, 165 }, + { "option-166", "X", &dhcp_universe, 166 }, + { "option-167", "X", &dhcp_universe, 167 }, + { "option-168", "X", &dhcp_universe, 168 }, + { "option-169", "X", &dhcp_universe, 169 }, + { "option-170", "X", &dhcp_universe, 170 }, + { "option-171", "X", &dhcp_universe, 171 }, + { "option-172", "X", &dhcp_universe, 172 }, + { "option-173", "X", &dhcp_universe, 173 }, + { "option-174", "X", &dhcp_universe, 174 }, + { "option-175", "X", &dhcp_universe, 175 }, + { "option-176", "X", &dhcp_universe, 176 }, + { "option-177", "X", &dhcp_universe, 177 }, + { "option-178", "X", &dhcp_universe, 178 }, + { "option-179", "X", &dhcp_universe, 179 }, + { "option-180", "X", &dhcp_universe, 180 }, + { "option-181", "X", &dhcp_universe, 181 }, + { "option-182", "X", &dhcp_universe, 182 }, + { "option-183", "X", &dhcp_universe, 183 }, + { "option-184", "X", &dhcp_universe, 184 }, + { "option-185", "X", &dhcp_universe, 185 }, + { "option-186", "X", &dhcp_universe, 186 }, + { "option-187", "X", &dhcp_universe, 187 }, + { "option-188", "X", &dhcp_universe, 188 }, + { "option-189", "X", &dhcp_universe, 189 }, + { "option-190", "X", &dhcp_universe, 190 }, + { "option-191", "X", &dhcp_universe, 191 }, + { "option-192", "X", &dhcp_universe, 192 }, + { "option-193", "X", &dhcp_universe, 193 }, + { "option-194", "X", &dhcp_universe, 194 }, + { "option-195", "X", &dhcp_universe, 195 }, + { "option-196", "X", &dhcp_universe, 196 }, + { "option-197", "X", &dhcp_universe, 197 }, + { "option-198", "X", &dhcp_universe, 198 }, + { "option-199", "X", &dhcp_universe, 199 }, + { "option-200", "X", &dhcp_universe, 200 }, + { "option-201", "X", &dhcp_universe, 201 }, + { "option-202", "X", &dhcp_universe, 202 }, + { "option-203", "X", &dhcp_universe, 203 }, + { "option-204", "X", &dhcp_universe, 204 }, + { "option-205", "X", &dhcp_universe, 205 }, + { "option-206", "X", &dhcp_universe, 206 }, + { "option-207", "X", &dhcp_universe, 207 }, + { "option-208", "X", &dhcp_universe, 208 }, + { "option-209", "X", &dhcp_universe, 209 }, + { "option-210", "X", &dhcp_universe, 210 }, + { "option-211", "X", &dhcp_universe, 211 }, + { "option-212", "X", &dhcp_universe, 212 }, + { "option-213", "X", &dhcp_universe, 213 }, + { "option-214", "X", &dhcp_universe, 214 }, + { "option-215", "X", &dhcp_universe, 215 }, + { "option-216", "X", &dhcp_universe, 216 }, + { "option-217", "X", &dhcp_universe, 217 }, + { "option-218", "X", &dhcp_universe, 218 }, + { "option-219", "X", &dhcp_universe, 219 }, + { "option-220", "X", &dhcp_universe, 220 }, + { "option-221", "X", &dhcp_universe, 221 }, + { "option-222", "X", &dhcp_universe, 222 }, + { "option-223", "X", &dhcp_universe, 223 }, + { "option-224", "X", &dhcp_universe, 224 }, + { "option-225", "X", &dhcp_universe, 225 }, + { "option-226", "X", &dhcp_universe, 226 }, + { "option-227", "X", &dhcp_universe, 227 }, + { "option-228", "X", &dhcp_universe, 228 }, + { "option-229", "X", &dhcp_universe, 229 }, + { "option-230", "X", &dhcp_universe, 230 }, + { "option-231", "X", &dhcp_universe, 231 }, + { "option-232", "X", &dhcp_universe, 232 }, + { "option-233", "X", &dhcp_universe, 233 }, + { "option-234", "X", &dhcp_universe, 234 }, + { "option-235", "X", &dhcp_universe, 235 }, + { "option-236", "X", &dhcp_universe, 236 }, + { "option-237", "X", &dhcp_universe, 237 }, + { "option-238", "X", &dhcp_universe, 238 }, + { "option-239", "X", &dhcp_universe, 239 }, + { "option-240", "X", &dhcp_universe, 240 }, + { "option-241", "X", &dhcp_universe, 241 }, + { "option-242", "X", &dhcp_universe, 242 }, + { "option-243", "X", &dhcp_universe, 243 }, + { "option-244", "X", &dhcp_universe, 244 }, + { "option-245", "X", &dhcp_universe, 245 }, + { "option-246", "X", &dhcp_universe, 246 }, + { "option-247", "X", &dhcp_universe, 247 }, + { "option-248", "X", &dhcp_universe, 248 }, + { "option-249", "X", &dhcp_universe, 249 }, + { "option-250", "X", &dhcp_universe, 250 }, + { "option-251", "X", &dhcp_universe, 251 }, + { "option-252", "X", &dhcp_universe, 252 }, + { "option-253", "X", &dhcp_universe, 253 }, + { "option-254", "X", &dhcp_universe, 254 }, + { "option-end", "e", &dhcp_universe, 255 }, +}; + +/* Default dhcp option priority list (this is ad hoc and should not be + mistaken for a carefully crafted and optimized list). */ +unsigned char dhcp_option_default_priority_list [] = { + DHO_DHCP_REQUESTED_ADDRESS, + DHO_DHCP_OPTION_OVERLOAD, + DHO_DHCP_MAX_MESSAGE_SIZE, + DHO_DHCP_RENEWAL_TIME, + DHO_DHCP_REBINDING_TIME, + DHO_DHCP_CLASS_IDENTIFIER, + DHO_DHCP_CLIENT_IDENTIFIER, + DHO_SUBNET_MASK, + DHO_TIME_OFFSET, + DHO_ROUTERS, + DHO_TIME_SERVERS, + DHO_NAME_SERVERS, + DHO_DOMAIN_NAME_SERVERS, + DHO_HOST_NAME, + DHO_LOG_SERVERS, + DHO_COOKIE_SERVERS, + DHO_LPR_SERVERS, + DHO_IMPRESS_SERVERS, + DHO_RESOURCE_LOCATION_SERVERS, + DHO_HOST_NAME, + DHO_BOOT_SIZE, + DHO_MERIT_DUMP, + DHO_DOMAIN_NAME, + DHO_SWAP_SERVER, + DHO_ROOT_PATH, + DHO_EXTENSIONS_PATH, + DHO_IP_FORWARDING, + DHO_NON_LOCAL_SOURCE_ROUTING, + DHO_POLICY_FILTER, + DHO_MAX_DGRAM_REASSEMBLY, + DHO_DEFAULT_IP_TTL, + DHO_PATH_MTU_AGING_TIMEOUT, + DHO_PATH_MTU_PLATEAU_TABLE, + DHO_INTERFACE_MTU, + DHO_ALL_SUBNETS_LOCAL, + DHO_BROADCAST_ADDRESS, + DHO_PERFORM_MASK_DISCOVERY, + DHO_MASK_SUPPLIER, + DHO_ROUTER_DISCOVERY, + DHO_ROUTER_SOLICITATION_ADDRESS, + DHO_STATIC_ROUTES, + DHO_TRAILER_ENCAPSULATION, + DHO_ARP_CACHE_TIMEOUT, + DHO_IEEE802_3_ENCAPSULATION, + DHO_DEFAULT_TCP_TTL, + DHO_TCP_KEEPALIVE_INTERVAL, + DHO_TCP_KEEPALIVE_GARBAGE, + DHO_NIS_DOMAIN, + DHO_NIS_SERVERS, + DHO_NTP_SERVERS, + DHO_VENDOR_ENCAPSULATED_OPTIONS, + DHO_NETBIOS_NAME_SERVERS, + DHO_NETBIOS_DD_SERVER, + DHO_NETBIOS_NODE_TYPE, + DHO_NETBIOS_SCOPE, + DHO_FONT_SERVERS, + DHO_X_DISPLAY_MANAGER, + DHO_DHCP_PARAMETER_REQUEST_LIST, + + /* Presently-undefined options... */ + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, + 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, + 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, + 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, +}; + +int sizeof_dhcp_option_default_priority_list = + sizeof dhcp_option_default_priority_list; + + +char *hardware_types [] = { + "unknown-0", + "ethernet", + "unknown-2", + "unknown-3", + "unknown-4", + "unknown-5", + "token-ring", + "unknown-7", + "fddi", + "unknown-9", + "unknown-10", + "unknown-11", + "unknown-12", + "unknown-13", + "unknown-14", + "unknown-15", + "unknown-16", + "unknown-17", + "unknown-18", + "unknown-19", + "unknown-20", + "unknown-21", + "unknown-22", + "unknown-23", + "unknown-24", + "unknown-25", + "unknown-26", + "unknown-27", + "unknown-28", + "unknown-29", + "unknown-30", + "unknown-31", + "unknown-32", + "unknown-33", + "unknown-34", + "unknown-35", + "unknown-36", + "unknown-37", + "unknown-38", + "unknown-39", + "unknown-40", + "unknown-41", + "unknown-42", + "unknown-43", + "unknown-44", + "unknown-45", + "unknown-46", + "unknown-47", + "unknown-48", + "unknown-49", + "unknown-50", + "unknown-51", + "unknown-52", + "unknown-53", + "unknown-54", + "unknown-55", + "unknown-56", + "unknown-57", + "unknown-58", + "unknown-59", + "unknown-60", + "unknown-61", + "unknown-62", + "unknown-63", + "unknown-64", + "unknown-65", + "unknown-66", + "unknown-67", + "unknown-68", + "unknown-69", + "unknown-70", + "unknown-71", + "unknown-72", + "unknown-73", + "unknown-74", + "unknown-75", + "unknown-76", + "unknown-77", + "unknown-78", + "unknown-79", + "unknown-80", + "unknown-81", + "unknown-82", + "unknown-83", + "unknown-84", + "unknown-85", + "unknown-86", + "unknown-87", + "unknown-88", + "unknown-89", + "unknown-90", + "unknown-91", + "unknown-92", + "unknown-93", + "unknown-94", + "unknown-95", + "unknown-96", + "unknown-97", + "unknown-98", + "unknown-99", + "unknown-100", + "unknown-101", + "unknown-102", + "unknown-103", + "unknown-104", + "unknown-105", + "unknown-106", + "unknown-107", + "unknown-108", + "unknown-109", + "unknown-110", + "unknown-111", + "unknown-112", + "unknown-113", + "unknown-114", + "unknown-115", + "unknown-116", + "unknown-117", + "unknown-118", + "unknown-119", + "unknown-120", + "unknown-121", + "unknown-122", + "unknown-123", + "unknown-124", + "unknown-125", + "unknown-126", + "unknown-127", + "unknown-128", + "unknown-129", + "unknown-130", + "unknown-131", + "unknown-132", + "unknown-133", + "unknown-134", + "unknown-135", + "unknown-136", + "unknown-137", + "unknown-138", + "unknown-139", + "unknown-140", + "unknown-141", + "unknown-142", + "unknown-143", + "unknown-144", + "unknown-145", + "unknown-146", + "unknown-147", + "unknown-148", + "unknown-149", + "unknown-150", + "unknown-151", + "unknown-152", + "unknown-153", + "unknown-154", + "unknown-155", + "unknown-156", + "unknown-157", + "unknown-158", + "unknown-159", + "unknown-160", + "unknown-161", + "unknown-162", + "unknown-163", + "unknown-164", + "unknown-165", + "unknown-166", + "unknown-167", + "unknown-168", + "unknown-169", + "unknown-170", + "unknown-171", + "unknown-172", + "unknown-173", + "unknown-174", + "unknown-175", + "unknown-176", + "unknown-177", + "unknown-178", + "unknown-179", + "unknown-180", + "unknown-181", + "unknown-182", + "unknown-183", + "unknown-184", + "unknown-185", + "unknown-186", + "unknown-187", + "unknown-188", + "unknown-189", + "unknown-190", + "unknown-191", + "unknown-192", + "unknown-193", + "unknown-194", + "unknown-195", + "unknown-196", + "unknown-197", + "unknown-198", + "unknown-199", + "unknown-200", + "unknown-201", + "unknown-202", + "unknown-203", + "unknown-204", + "unknown-205", + "unknown-206", + "unknown-207", + "unknown-208", + "unknown-209", + "unknown-210", + "unknown-211", + "unknown-212", + "unknown-213", + "unknown-214", + "unknown-215", + "unknown-216", + "unknown-217", + "unknown-218", + "unknown-219", + "unknown-220", + "unknown-221", + "unknown-222", + "unknown-223", + "unknown-224", + "unknown-225", + "unknown-226", + "unknown-227", + "unknown-228", + "unknown-229", + "unknown-230", + "unknown-231", + "unknown-232", + "unknown-233", + "unknown-234", + "unknown-235", + "unknown-236", + "unknown-237", + "unknown-238", + "unknown-239", + "unknown-240", + "unknown-241", + "unknown-242", + "unknown-243", + "unknown-244", + "unknown-245", + "unknown-246", + "unknown-247", + "unknown-248", + "unknown-249", + "unknown-250", + "unknown-251", + "unknown-252", + "unknown-253", + "unknown-254", + "unknown-255" }; + + + +struct hash_table universe_hash; + +void initialize_universes() +{ + int i; + + dhcp_universe.name = "dhcp"; + dhcp_universe.hash = new_hash (); + if (!dhcp_universe.hash) + error ("Can't allocate dhcp option hash table."); + for (i = 0; i < 256; i++) { + dhcp_universe.options [i] = &dhcp_options [i]; + add_hash (dhcp_universe.hash, + (unsigned char *)dhcp_options [i].name, 0, + (unsigned char *)&dhcp_options [i]); + } + universe_hash.hash_count = DEFAULT_HASH_SIZE; + add_hash (&universe_hash, + (unsigned char *)dhcp_universe.name, 0, + (unsigned char *)&dhcp_universe); +} diff --git a/contrib/isc-dhcp/common/upf.c b/contrib/isc-dhcp/common/upf.c new file mode 100644 index 000000000000..7da9aff62ee8 --- /dev/null +++ b/contrib/isc-dhcp/common/upf.c @@ -0,0 +1,318 @@ +/* upf.c + + Ultrix PacketFilter interface code. + +/* + * Copyright (c) 1995, 1996, 1997 The Internet Software Consortium. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of The Internet Software Consortium nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND + * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This software has been written for the Internet Software Consortium + * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie + * Enterprises. To learn more about the Internet Software Consortium, + * see ``http://www.vix.com/isc''. To learn more about Vixie + * Enterprises, see ``http://www.vix.com''. + */ + +#ifndef lint +static char copyright[] = +"$Id: upf.c,v 1.3.2.1 1998/12/20 18:29:48 mellon Exp $ Copyright (c) 1995, 1996 The Internet Software Consortium. All rights reserved.\n"; +#endif /* not lint */ + +#include "dhcpd.h" +#if defined (USE_UPF_SEND) || defined (USE_UPF_RECEIVE) +#include <sys/ioctl.h> +#include <sys/uio.h> + +#include <net/pfilt.h> +#include <netinet/in_systm.h> +#include "includes/netinet/ip.h" +#include "includes/netinet/udp.h" +#include "includes/netinet/if_ether.h" + +/* Reinitializes the specified interface after an address change. This + is not required for packet-filter APIs. */ + +#ifdef USE_UPF_SEND +void if_reinitialize_send (info) + struct interface_info *info; +{ +} +#endif + +#ifdef USE_UPF_RECEIVE +void if_reinitialize_receive (info) + struct interface_info *info; +{ +} +#endif + +/* Called by get_interface_list for each interface that's discovered. + Opens a packet filter for each interface and adds it to the select + mask. */ + +int if_register_upf (info) + struct interface_info *info; +{ + int sock; + char filename[50]; + int b; + struct endevp param; + + /* Open a UPF device */ + for (b = 0; 1; b++) { +#ifndef NO_SNPRINTF + snprintf(filename, sizeof(filename), "/dev/pf/pfilt%d", b); +#else + sprintf(filename, "/dev/pf/pfilt%d", b); +#endif + sock = open (filename, O_RDWR, 0); + if (sock < 0) { + if (errno == EBUSY) { + continue; + } else { + error ("Can't find free upf: %m"); + } + } else { + break; + } + } + + /* Set the UPF device to point at this interface. */ + if (ioctl (sock, EIOCSETIF, info -> ifp) < 0) + error ("Can't attach interface %s to upf device %s: %m", + info -> name, filename); + + /* Get the hardware address. */ + if (ioctl (sock, EIOCDEVP, ¶m) < 0) + error ("Can't get interface %s hardware address: %m", + info -> name); + + /* We only know how to do ethernet. */ + if (param.end_dev_type != ENDT_10MB) + error ("Invalid device type on network interface %s: %d", + info -> name, param.end_dev_type); + + if (param.end_addr_len != 6) + error ("Invalid hardware address length on %s: %d", + info -> name, param.end_addr_len); + + info -> hw_address.hlen = 6; + info -> hw_address.htype = ARPHRD_ETHER; + memcpy (&info -> hw_address.haddr [0], param.end_addr, 6); + + return sock; +} +#endif /* USE_UPF_SEND || USE_UPF_RECEIVE */ + +#ifdef USE_UPF_SEND +void if_register_send (info) + struct interface_info *info; +{ + /* If we're using the upf API for sending and receiving, + we don't need to register this interface twice. */ +#ifndef USE_UPF_RECEIVE + info -> wfdesc = if_register_upf (info, interface); +#else + info -> wfdesc = info -> rfdesc; +#endif + if (!quiet_interface_discovery) + note ("Sending on UPF/%s/%s/%s", + info -> name, + print_hw_addr (info -> hw_address.htype, + info -> hw_address.hlen, + info -> hw_address.haddr), + (info -> shared_network ? + info -> shared_network -> name : "unattached")); +} +#endif /* USE_UPF_SEND */ + +#ifdef USE_UPF_RECEIVE +/* Packet filter program... + XXX Changes to the filter program may require changes to the constant + offsets used in if_register_send to patch the UPF program! XXX */ + + +void if_register_receive (info) + struct interface_info *info; +{ + int flag = 1; + u_int32_t addr; + struct enfilter pf; + u_int32_t bits; + + /* Open a UPF device and hang it on this interface... */ + info -> rfdesc = if_register_upf (info); + + /* Allow the copyall flag to be set... */ + if (ioctl(info -> rfdesc, EIOCALLOWCOPYALL, &flag) < 0) + error ("Can't set ALLOWCOPYALL: %m"); + + /* Clear all the packet filter mode bits first... */ + flag = (ENHOLDSIG | ENBATCH | ENTSTAMP | ENPROMISC | + ENNONEXCL | ENCOPYALL); + if (ioctl (info -> rfdesc, EIOCMBIC, &flag) < 0) + error ("Can't clear pfilt bits: %m"); + + /* Set the ENBATCH and ENCOPYALL bits... */ + bits = ENBATCH | ENCOPYALL; + if (ioctl (info -> rfdesc, EIOCMBIS, &bits) < 0) + error ("Can't set ENBATCH|ENCOPYALL: %m"); + + /* Set up the UPF filter program. */ + /* XXX Unlike the BPF filter program, this one won't work if the + XXX IP packet is fragmented or if there are options on the IP + XXX header. */ + pf.enf_Priority = 0; + pf.enf_FilterLen = 0; + + pf.enf_Filter [pf.enf_FilterLen++] = ENF_PUSHWORD + 6; + pf.enf_Filter [pf.enf_FilterLen++] = ENF_PUSHLIT + ENF_CAND; + pf.enf_Filter [pf.enf_FilterLen++] = htons (ETHERTYPE_IP); + pf.enf_Filter [pf.enf_FilterLen++] = ENF_PUSHLIT; + pf.enf_Filter [pf.enf_FilterLen++] = htons (IPPROTO_UDP); + pf.enf_Filter [pf.enf_FilterLen++] = ENF_PUSHWORD + 11; + pf.enf_Filter [pf.enf_FilterLen++] = ENF_PUSHLIT + ENF_AND; + pf.enf_Filter [pf.enf_FilterLen++] = htons (0xFF); + pf.enf_Filter [pf.enf_FilterLen++] = ENF_CAND; + pf.enf_Filter [pf.enf_FilterLen++] = ENF_PUSHWORD + 18; + pf.enf_Filter [pf.enf_FilterLen++] = ENF_PUSHLIT + ENF_CAND; + pf.enf_Filter [pf.enf_FilterLen++] = local_port; + + if (ioctl (info -> rfdesc, EIOCSETF, &pf) < 0) + error ("Can't install packet filter program: %m"); + if (!quiet_interface_discovery) + note ("Listening on UPF/%s/%s/%s", + info -> name, + print_hw_addr (info -> hw_address.htype, + info -> hw_address.hlen, + info -> hw_address.haddr), + (info -> shared_network ? + info -> shared_network -> name : "unattached")); +} +#endif /* USE_UPF_RECEIVE */ + +#ifdef USE_UPF_SEND +ssize_t send_packet (interface, packet, raw, len, from, to, hto) + struct interface_info *interface; + struct packet *packet; + struct dhcp_packet *raw; + size_t len; + struct in_addr from; + struct sockaddr_in *to; + struct hardware *hto; +{ + int bufp = 0; + unsigned char buf [256]; + struct iovec iov [2]; + + if (!strcmp (interface -> name, "fallback")) + return send_fallback (interface, packet, raw, + len, from, to, hto); + + /* Assemble the headers... */ + assemble_hw_header (interface, buf, &bufp, hto); + assemble_udp_ip_header (interface, buf, &bufp, from.s_addr, + to -> sin_addr.s_addr, to -> sin_port, + (unsigned char *)raw, len); + + /* Fire it off */ + iov [0].iov_base = (char *)buf; + iov [0].iov_len = bufp; + iov [1].iov_base = (char *)raw; + iov [1].iov_len = len; + + return writev(interface -> wfdesc, iov, 2); +} +#endif /* USE_UPF_SEND */ + +#ifdef USE_UPF_RECEIVE +ssize_t receive_packet (interface, buf, len, from, hfrom) + struct interface_info *interface; + unsigned char *buf; + size_t len; + struct sockaddr_in *from; + struct hardware *hfrom; +{ + int nread; + int length = 0; + int offset = 0; + unsigned char ibuf [1500 + sizeof (struct enstamp)]; + int bufix = 0; + + length = read (interface -> rfdesc, ibuf, sizeof ibuf); + if (length <= 0) + return length; + + bufix = sizeof (struct enstamp); + /* Decode the physical header... */ + offset = decode_hw_header (interface, ibuf, bufix, hfrom); + + /* If a physical layer checksum failed (dunno of any + physical layer that supports this, but WTH), skip this + packet. */ + if (offset < 0) { + return 0; + } + + bufix += offset; + length -= offset; + + /* Decode the IP and UDP headers... */ + offset = decode_udp_ip_header (interface, ibuf, bufix, + from, (unsigned char *)0, length); + + /* If the IP or UDP checksum was bad, skip the packet... */ + if (offset < 0) + return 0; + + bufix += offset; + length -= offset; + + /* Copy out the data in the packet... */ + memcpy (buf, &ibuf [bufix], length); + return length; +} + +int can_unicast_without_arp () +{ + return 1; +} + +void maybe_setup_fallback () +{ + struct interface_info *fbi; + fbi = setup_fallback (); + if (fbi) { + if_register_fallback (fbi); + add_protocol ("fallback", fallback_interface -> wfdesc, + fallback_discard, fallback_interface); + } +} +#endif diff --git a/contrib/isc-dhcp/includes/cf/freebsd.h b/contrib/isc-dhcp/includes/cf/freebsd.h new file mode 100644 index 000000000000..032d52c2b002 --- /dev/null +++ b/contrib/isc-dhcp/includes/cf/freebsd.h @@ -0,0 +1,93 @@ +/* freebsd.h + + System dependencies for FreeBSD... */ + +/* + * Copyright (c) 1996, 1998 The Internet Software Consortium. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of The Internet Software Consortium nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND + * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL + * THE INTERNET SOFTWARE CONSORTIUM OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + * + * This software was written for the Internet Software Consortium by Ted Lemon + * under a contract with Vixie Laboratories. + */ + +#define _ANSI_SOURCE + +#include <syslog.h> +#include <sys/types.h> +#include <string.h> +#include <paths.h> +#include <errno.h> +#include <unistd.h> +#include <setjmp.h> +#include <limits.h> + +#include <sys/wait.h> +#include <signal.h> + +extern int h_errno; + +#include <net/if.h> +#include <net/if_dl.h> +#include <net/if_arp.h> +#if !defined (INADDR_LOOPBACK) +# define INADDR_LOOPBACK ((u_int32_t)0x7f000001) +#endif + +/* Varargs stuff... */ +#include <stdarg.h> +#define VA_DOTDOTDOT ... +#define va_dcl +#define VA_start(list, last) va_start (list, last) + +#ifndef _PATH_DHCPD_PID +#define _PATH_DHCPD_PID "/var/run/dhcpd.pid" +#endif +#ifndef _PATH_DHCPD_DB +#define _PATH_DHCPD_DB "/var/db/dhcpd.leases" +#endif +#ifndef _PATH_DHCLIENT_PID +#define _PATH_DHCLIENT_PID "/var/run/dhclient.pid" +#endif +#ifndef _PATH_DHCLIENT_DB +#define _PATH_DHCLIENT_DB "/var/db/dhclient.leases" +#endif + +#define EOL '\n' +#define VOIDPTR void * + +/* Time stuff... */ +#include <sys/time.h> +#define TIME time_t +#define GET_TIME(x) time ((x)) + +#define HAVE_SA_LEN + +#if defined (USE_DEFAULT_NETWORK) +# define USE_BPF +#endif diff --git a/contrib/isc-dhcp/includes/dhcp.h b/contrib/isc-dhcp/includes/dhcp.h new file mode 100644 index 000000000000..b96ec3d096df --- /dev/null +++ b/contrib/isc-dhcp/includes/dhcp.h @@ -0,0 +1,168 @@ +/* dhcp.h + + Protocol structures... */ + +/* + * Copyright (c) 1995, 1996 The Internet Software Consortium. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of The Internet Software Consortium nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND + * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This software has been written for the Internet Software Consortium + * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie + * Enterprises. To learn more about the Internet Software Consortium, + * see ``http://www.vix.com/isc''. To learn more about Vixie + * Enterprises, see ``http://www.vix.com''. + */ + +#define DHCP_UDP_OVERHEAD (14 + /* Ethernet header */ \ + 20 + /* IP header */ \ + 8) /* UDP header */ +#define DHCP_SNAME_LEN 64 +#define DHCP_FILE_LEN 128 +#define DHCP_FIXED_NON_UDP 236 +#define DHCP_FIXED_LEN (DHCP_FIXED_NON_UDP + DHCP_UDP_OVERHEAD) + /* Everything but options. */ +#define DHCP_MTU_MAX 1500 +#define DHCP_OPTION_LEN (DHCP_MTU_MAX - DHCP_FIXED_LEN) + +#define BOOTP_MIN_LEN 300 +#define DHCP_MIN_LEN 548 + +struct dhcp_packet { + u_int8_t op; /* Message opcode/type */ + u_int8_t htype; /* Hardware addr type (see net/if_types.h) */ + u_int8_t hlen; /* Hardware addr length */ + u_int8_t hops; /* Number of relay agent hops from client */ + u_int32_t xid; /* Transaction ID */ + u_int16_t secs; /* Seconds since client started looking */ + u_int16_t flags; /* Flag bits */ + struct in_addr ciaddr; /* Client IP address (if already in use) */ + struct in_addr yiaddr; /* Client IP address */ + struct in_addr siaddr; /* IP address of next server to talk to */ + struct in_addr giaddr; /* DHCP relay agent IP address */ + unsigned char chaddr [16]; /* Client hardware address */ + char sname [DHCP_SNAME_LEN]; /* Server name */ + char file [DHCP_FILE_LEN]; /* Boot filename */ + unsigned char options [DHCP_OPTION_LEN]; + /* Optional parameters + (actual length dependent on MTU). */ +}; + +/* BOOTP (rfc951) message types */ +#define BOOTREQUEST 1 +#define BOOTREPLY 2 + +/* Possible values for flags field... */ +#define BOOTP_BROADCAST 32768L + +/* Possible values for hardware type (htype) field... */ +#define HTYPE_ETHER 1 /* Ethernet 10Mbps */ +#define HTYPE_IEEE802 6 /* IEEE 802.2 Token Ring... */ +#define HTYPE_FDDI 8 /* FDDI... */ + +/* Magic cookie validating dhcp options field (and bootp vendor + extensions field). */ +#define DHCP_OPTIONS_COOKIE "\143\202\123\143" + +/* DHCP Option codes: */ + +#define DHO_PAD 0 +#define DHO_SUBNET_MASK 1 +#define DHO_TIME_OFFSET 2 +#define DHO_ROUTERS 3 +#define DHO_TIME_SERVERS 4 +#define DHO_NAME_SERVERS 5 +#define DHO_DOMAIN_NAME_SERVERS 6 +#define DHO_LOG_SERVERS 7 +#define DHO_COOKIE_SERVERS 8 +#define DHO_LPR_SERVERS 9 +#define DHO_IMPRESS_SERVERS 10 +#define DHO_RESOURCE_LOCATION_SERVERS 11 +#define DHO_HOST_NAME 12 +#define DHO_BOOT_SIZE 13 +#define DHO_MERIT_DUMP 14 +#define DHO_DOMAIN_NAME 15 +#define DHO_SWAP_SERVER 16 +#define DHO_ROOT_PATH 17 +#define DHO_EXTENSIONS_PATH 18 +#define DHO_IP_FORWARDING 19 +#define DHO_NON_LOCAL_SOURCE_ROUTING 20 +#define DHO_POLICY_FILTER 21 +#define DHO_MAX_DGRAM_REASSEMBLY 22 +#define DHO_DEFAULT_IP_TTL 23 +#define DHO_PATH_MTU_AGING_TIMEOUT 24 +#define DHO_PATH_MTU_PLATEAU_TABLE 25 +#define DHO_INTERFACE_MTU 26 +#define DHO_ALL_SUBNETS_LOCAL 27 +#define DHO_BROADCAST_ADDRESS 28 +#define DHO_PERFORM_MASK_DISCOVERY 29 +#define DHO_MASK_SUPPLIER 30 +#define DHO_ROUTER_DISCOVERY 31 +#define DHO_ROUTER_SOLICITATION_ADDRESS 32 +#define DHO_STATIC_ROUTES 33 +#define DHO_TRAILER_ENCAPSULATION 34 +#define DHO_ARP_CACHE_TIMEOUT 35 +#define DHO_IEEE802_3_ENCAPSULATION 36 +#define DHO_DEFAULT_TCP_TTL 37 +#define DHO_TCP_KEEPALIVE_INTERVAL 38 +#define DHO_TCP_KEEPALIVE_GARBAGE 39 +#define DHO_NIS_DOMAIN 40 +#define DHO_NIS_SERVERS 41 +#define DHO_NTP_SERVERS 42 +#define DHO_VENDOR_ENCAPSULATED_OPTIONS 43 +#define DHO_NETBIOS_NAME_SERVERS 44 +#define DHO_NETBIOS_DD_SERVER 45 +#define DHO_NETBIOS_NODE_TYPE 46 +#define DHO_NETBIOS_SCOPE 47 +#define DHO_FONT_SERVERS 48 +#define DHO_X_DISPLAY_MANAGER 49 +#define DHO_DHCP_REQUESTED_ADDRESS 50 +#define DHO_DHCP_LEASE_TIME 51 +#define DHO_DHCP_OPTION_OVERLOAD 52 +#define DHO_DHCP_MESSAGE_TYPE 53 +#define DHO_DHCP_SERVER_IDENTIFIER 54 +#define DHO_DHCP_PARAMETER_REQUEST_LIST 55 +#define DHO_DHCP_MESSAGE 56 +#define DHO_DHCP_MAX_MESSAGE_SIZE 57 +#define DHO_DHCP_RENEWAL_TIME 58 +#define DHO_DHCP_REBINDING_TIME 59 +#define DHO_DHCP_CLASS_IDENTIFIER 60 +#define DHO_DHCP_CLIENT_IDENTIFIER 61 +#define DHO_DHCP_USER_CLASS_ID 77 +#define DHO_END 255 + +/* DHCP message types. */ +#define DHCPDISCOVER 1 +#define DHCPOFFER 2 +#define DHCPREQUEST 3 +#define DHCPDECLINE 4 +#define DHCPACK 5 +#define DHCPNAK 6 +#define DHCPRELEASE 7 +#define DHCPINFORM 8 diff --git a/contrib/isc-dhcp/includes/dhcpd.h b/contrib/isc-dhcp/includes/dhcpd.h new file mode 100644 index 000000000000..a1059e94eb59 --- /dev/null +++ b/contrib/isc-dhcp/includes/dhcpd.h @@ -0,0 +1,1000 @@ +/* dhcpd.h + + Definitions for dhcpd... */ + +/* + * Copyright (c) 1995, 1996, 1997, 1998, 1999 + * The Internet Software Consortium. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of The Internet Software Consortium nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND + * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This software has been written for the Internet Software Consortium + * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie + * Enterprises. To learn more about the Internet Software Consortium, + * see ``http://www.vix.com/isc''. To learn more about Vixie + * Enterprises, see ``http://www.vix.com''. + */ + +#ifndef __CYGWIN32__ +#include <sys/types.h> +#include <netinet/in.h> +#include <sys/socket.h> +#include <sys/un.h> +#include <arpa/inet.h> +#include <netdb.h> +#else +#define fd_set cygwin_fd_set +#include <sys/types.h> +#endif +#include <fcntl.h> +#include <stdio.h> +#include <unistd.h> +#include <string.h> +#include <stdlib.h> +#include <sys/stat.h> +#include <ctype.h> +#include <time.h> + +#include "cdefs.h" +#include "osdep.h" +#include "dhcp.h" +#include "tree.h" +#include "hash.h" +#include "inet.h" +#include "sysconf.h" + +struct option_data { + int len; + u_int8_t *data; +}; + +struct string_list { + struct string_list *next; + char string [1]; +}; + +/* A name server, from /etc/resolv.conf. */ +struct name_server { + struct name_server *next; + struct sockaddr_in addr; + TIME rcdate; +}; + +/* A domain search list element. */ +struct domain_search_list { + struct domain_search_list *next; + char *domain; + TIME rcdate; +}; + +/* A dhcp packet and the pointers to its option values. */ +struct packet { + struct dhcp_packet *raw; + int packet_length; + int packet_type; + int options_valid; + int client_port; + struct iaddr client_addr; + struct interface_info *interface; /* Interface on which packet + was received. */ + struct hardware *haddr; /* Physical link address + of local sender (maybe gateway). */ + struct shared_network *shared_network; + struct option_data options [256]; +}; + +struct hardware { + u_int8_t htype; + u_int8_t hlen; + u_int8_t haddr [16]; +}; + +/* A dhcp lease declaration structure. */ +struct lease { + struct lease *next; + struct lease *prev; + struct lease *n_uid, *n_hw; + struct lease *waitq_next; + + struct iaddr ip_addr; + TIME starts, ends, timestamp; + unsigned char *uid; + int uid_len; + int uid_max; + unsigned char uid_buf [32]; + char *hostname; + char *client_hostname; + struct host_decl *host; + struct subnet *subnet; + struct shared_network *shared_network; + struct hardware hardware_addr; + + int flags; +# define STATIC_LEASE 1 +# define BOOTP_LEASE 2 +# define DYNAMIC_BOOTP_OK 4 +# define PERSISTENT_FLAGS (DYNAMIC_BOOTP_OK) +# define EPHEMERAL_FLAGS (BOOTP_LEASE) +# define MS_NULL_TERMINATION 8 +# define ABANDONED_LEASE 16 + + struct lease_state *state; +}; + +struct lease_state { + struct lease_state *next; + + struct interface_info *ip; + + TIME offered_expiry; + + struct tree_cache *options [256]; + u_int32_t expiry, renewal, rebind; + char filename [DHCP_FILE_LEN]; + char *server_name; + + struct iaddr from; + + u_int32_t xid; + u_int16_t secs; + u_int16_t bootp_flags; + struct in_addr ciaddr; + struct in_addr giaddr; + u_int8_t hops; + u_int8_t offer; +}; + +#define ROOT_GROUP 0 +#define HOST_DECL 1 +#define SHARED_NET_DECL 2 +#define SUBNET_DECL 3 +#define CLASS_DECL 4 +#define GROUP_DECL 5 + +/* Possible modes in which discover_interfaces can run. */ + +#define DISCOVER_RUNNING 0 +#define DISCOVER_SERVER 1 +#define DISCOVER_UNCONFIGURED 2 +#define DISCOVER_RELAY 3 +#define DISCOVER_REQUESTED 4 + +/* Group of declarations that share common parameters. */ +struct group { + struct group *next; + + struct subnet *subnet; + struct shared_network *shared_network; + + TIME default_lease_time; + TIME max_lease_time; + TIME bootp_lease_cutoff; + TIME bootp_lease_length; + + char *filename; + char *server_name; + struct iaddr next_server; + + int boot_unknown_clients; + int dynamic_bootp; + int allow_bootp; + int allow_booting; + int one_lease_per_client; + int get_lease_hostnames; + int use_host_decl_names; + int use_lease_addr_for_default_route; + int authoritative; + + struct tree_cache *options [256]; +}; + +/* A dhcp host declaration structure. */ +struct host_decl { + struct host_decl *n_ipaddr; + char *name; + struct hardware interface; + struct tree_cache *fixed_addr; + struct group *group; +}; + +struct shared_network { + struct shared_network *next; + char *name; + struct subnet *subnets; + struct interface_info *interface; + struct lease *leases; + struct lease *insertion_point; + struct lease *last_lease; + + struct group *group; +}; + +struct subnet { + struct subnet *next_subnet; + struct subnet *next_sibling; + struct shared_network *shared_network; + struct interface_info *interface; + struct iaddr interface_address; + struct iaddr net; + struct iaddr netmask; + + struct group *group; +}; + +struct class { + char *name; + + struct group *group; +}; + +/* DHCP client lease structure... */ +struct client_lease { + struct client_lease *next; /* Next lease in list. */ + TIME expiry, renewal, rebind; /* Lease timeouts. */ + struct iaddr address; /* Address being leased. */ + char *server_name; /* Name of boot server. */ + char *filename; /* Name of file we're supposed to boot. */ + struct string_list *medium; /* Network medium. */ + + unsigned int is_static : 1; /* If set, lease is from config file. */ + unsigned int is_bootp: 1; /* If set, lease was aquired with BOOTP. */ + + struct option_data options [256]; /* Options supplied with lease. */ +}; + +/* Possible states in which the client can be. */ +enum dhcp_state { + S_REBOOTING, + S_INIT, + S_SELECTING, + S_REQUESTING, + S_BOUND, + S_RENEWING, + S_REBINDING +}; + +/* Configuration information from the config file... */ +struct client_config { + struct option_data defaults [256]; /* Default values for options. */ + enum { + ACTION_DEFAULT, /* Use server value if present, + otherwise default. */ + ACTION_SUPERSEDE, /* Always use default. */ + ACTION_PREPEND, /* Prepend default to server. */ + ACTION_APPEND, /* Append default to server. */ + } default_actions [256]; + + struct option_data send_options [256]; /* Send these to server. */ + u_int8_t required_options [256]; /* Options server must supply. */ + u_int8_t requested_options [256]; /* Options to request from server. */ + int requested_option_count; /* Number of requested options. */ + TIME timeout; /* Start to panic if we don't get a + lease in this time period when + SELECTING. */ + TIME initial_interval; /* All exponential backoff intervals + start here. */ + TIME retry_interval; /* If the protocol failed to produce + an address before the timeout, + try the protocol again after this + many seconds. */ + TIME select_interval; /* Wait this many seconds from the + first DHCPDISCOVER before + picking an offered lease. */ + TIME reboot_timeout; /* When in INIT-REBOOT, wait this + long before giving up and going + to INIT. */ + TIME backoff_cutoff; /* When doing exponential backoff, + never back off to an interval + longer than this amount. */ + struct string_list *media; /* Possible network media values. */ + char *script_name; /* Name of config script. */ + enum { IGNORE, ACCEPT, PREFER } bootp_policy; + /* Ignore, accept or prefer BOOTP + responses. */ + struct string_list *medium; /* Current network medium. */ + + struct iaddrlist *reject_list; /* Servers to reject. */ +}; + +/* Per-interface state used in the dhcp client... */ +struct client_state { + struct client_lease *active; /* Currently active lease. */ + struct client_lease *new; /* New lease. */ + struct client_lease *offered_leases; /* Leases offered to us. */ + struct client_lease *leases; /* Leases we currently hold. */ + struct client_lease *alias; /* Alias lease. */ + + enum dhcp_state state; /* Current state for this interface. */ + struct iaddr destination; /* Where to send packet. */ + u_int32_t xid; /* Transaction ID. */ + TIME first_sending; /* When was first copy sent? */ + TIME interval; /* What's the current resend interval? */ + struct string_list *medium; /* Last media type tried. */ + + struct dhcp_packet packet; /* Outgoing DHCP packet. */ + int packet_length; /* Actual length of generated packet. */ + + struct iaddr requested_address; /* Address we would like to get. */ + + struct client_config *config; /* Information from config file. */ +}; + +/* Information about each network interface. */ + +struct interface_info { + struct interface_info *next; /* Next interface in list... */ + struct shared_network *shared_network; + /* Networks connected to this interface. */ + struct hardware hw_address; /* Its physical address. */ + struct in_addr primary_address; /* Primary interface address. */ + char name [IFNAMSIZ]; /* Its name... */ + int rfdesc; /* Its read file descriptor. */ + int wfdesc; /* Its write file descriptor, if + different. */ + unsigned char *rbuf; /* Read buffer, if required. */ + size_t rbuf_max; /* Size of read buffer. */ + size_t rbuf_offset; /* Current offset into buffer. */ + size_t rbuf_len; /* Length of data in buffer. */ + + struct ifreq *ifp; /* Pointer to ifreq struct. */ + u_int32_t flags; /* Control flags... */ +#define INTERFACE_REQUESTED 1 +#define INTERFACE_AUTOMATIC 2 + + /* Only used by DHCP client code. */ + struct client_state *client; +}; + +struct hardware_link { + struct hardware_link *next; + char name [IFNAMSIZ]; + struct hardware address; +}; + +struct timeout { + struct timeout *next; + TIME when; + void (*func) PROTO ((void *)); + void *what; +}; + +struct protocol { + struct protocol *next; + int fd; + void (*handler) PROTO ((struct protocol *)); + void *local; +}; + +/* Bitmask of dhcp option codes. */ +typedef unsigned char option_mask [16]; + +/* DHCP Option mask manipulation macros... */ +#define OPTION_ZERO(mask) (memset (mask, 0, 16)) +#define OPTION_SET(mask, bit) (mask [bit >> 8] |= (1 << (bit & 7))) +#define OPTION_CLR(mask, bit) (mask [bit >> 8] &= ~(1 << (bit & 7))) +#define OPTION_ISSET(mask, bit) (mask [bit >> 8] & (1 << (bit & 7))) +#define OPTION_ISCLR(mask, bit) (!OPTION_ISSET (mask, bit)) + +/* An option occupies its length plus two header bytes (code and + length) for every 255 bytes that must be stored. */ +#define OPTION_SPACE(x) ((x) + 2 * ((x) / 255 + 1)) + +/* Default path to dhcpd config file. */ +#ifdef DEBUG +#undef _PATH_DHCPD_CONF +#define _PATH_DHCPD_CONF "dhcpd.conf" +#undef _PATH_DHCPD_DB +#define _PATH_DHCPD_DB "dhcpd.leases" +#else +#ifndef _PATH_DHCPD_CONF +#define _PATH_DHCPD_CONF "/etc/dhcpd.conf" +#endif + +#ifndef _PATH_DHCPD_DB +#define _PATH_DHCPD_DB "/etc/dhcpd.leases" +#endif + +#ifndef _PATH_DHCPD_PID +#define _PATH_DHCPD_PID "/var/run/dhcpd.pid" +#endif +#endif + +#ifndef _PATH_DHCLIENT_CONF +#define _PATH_DHCLIENT_CONF "/etc/dhclient.conf" +#endif + +#ifndef _PATH_DHCLIENT_PID +#define _PATH_DHCLIENT_PID "/var/run/dhclient.pid" +#endif + +#ifndef _PATH_DHCLIENT_DB +#define _PATH_DHCLIENT_DB "/etc/dhclient.leases" +#endif + +#ifndef _PATH_RESOLV_CONF +#define _PATH_RESOLV_CONF "/etc/resolv.conf" +#endif + +#ifndef _PATH_DHCRELAY_PID +#define _PATH_DHCRELAY_PID "/var/run/dhcrelay.pid" +#endif + +#ifndef DHCPD_LOG_FACILITY +#define DHCPD_LOG_FACILITY LOG_DAEMON +#endif + +#define MAX_TIME 0x7fffffff +#define MIN_TIME 0 + +/* External definitions... */ + +/* options.c */ + +void parse_options PROTO ((struct packet *)); +void parse_option_buffer PROTO ((struct packet *, unsigned char *, int)); +int cons_options PROTO ((struct packet *, struct dhcp_packet *, + struct tree_cache **, int, int, int)); +int store_options PROTO ((unsigned char *, int, struct tree_cache **, + unsigned char *, int, int, int, int)); +char *pretty_print_option PROTO ((unsigned int, + unsigned char *, int, int, int)); +void do_packet PROTO ((struct interface_info *, + struct dhcp_packet *, int, + unsigned int, struct iaddr, struct hardware *)); + +/* errwarn.c */ +extern int warnings_occurred; +void error PROTO ((char *, ...)); +int warn PROTO ((char *, ...)); +int note PROTO ((char *, ...)); +int debug PROTO ((char *, ...)); +int parse_warn PROTO ((char *, ...)); + +/* dhcpd.c */ +extern TIME cur_time; +extern struct group root_group; + +extern u_int16_t local_port; +extern u_int16_t remote_port; +extern int log_priority; +extern int log_perror; + +extern char *path_dhcpd_conf; +extern char *path_dhcpd_db; +extern char *path_dhcpd_pid; + +int main PROTO ((int, char **, char **)); +void cleanup PROTO ((void)); +void lease_pinged PROTO ((struct iaddr, u_int8_t *, int)); +void lease_ping_timeout PROTO ((void *)); + +/* conflex.c */ +extern int lexline, lexchar; +extern char *token_line, *tlname; +extern char comments [4096]; +extern int comment_index; +extern int eol_token; +void new_parse PROTO ((char *)); +int next_token PROTO ((char **, FILE *)); +int peek_token PROTO ((char **, FILE *)); + +/* confpars.c */ +int readconf PROTO ((void)); +void read_leases PROTO ((void)); +int parse_statement PROTO ((FILE *, + struct group *, int, struct host_decl *, int)); +void parse_allow_deny PROTO ((FILE *, struct group *, int)); +void skip_to_semi PROTO ((FILE *)); +int parse_boolean PROTO ((FILE *)); +int parse_semi PROTO ((FILE *)); +int parse_lbrace PROTO ((FILE *)); +void parse_host_declaration PROTO ((FILE *, struct group *)); +char *parse_host_name PROTO ((FILE *)); +void parse_class_declaration PROTO ((FILE *, struct group *, int)); +void parse_lease_time PROTO ((FILE *, TIME *)); +void parse_shared_net_declaration PROTO ((FILE *, struct group *)); +void parse_subnet_declaration PROTO ((FILE *, struct shared_network *)); +void parse_group_declaration PROTO ((FILE *, struct group *)); +void parse_hardware_param PROTO ((FILE *, struct hardware *)); +char *parse_string PROTO ((FILE *)); +struct tree *parse_ip_addr_or_hostname PROTO ((FILE *, int)); +struct tree_cache *parse_fixed_addr_param PROTO ((FILE *)); +void parse_option_param PROTO ((FILE *, struct group *)); +TIME parse_timestamp PROTO ((FILE *)); +struct lease *parse_lease_declaration PROTO ((FILE *)); +void parse_address_range PROTO ((FILE *, struct subnet *)); +TIME parse_date PROTO ((FILE *)); +unsigned char *parse_numeric_aggregate PROTO ((FILE *, + unsigned char *, int *, + int, int, int)); +void convert_num PROTO ((unsigned char *, char *, int, int)); + +/* tree.c */ +pair cons PROTO ((caddr_t, pair)); +struct tree_cache *tree_cache PROTO ((struct tree *)); +struct tree *tree_host_lookup PROTO ((char *)); +struct dns_host_entry *enter_dns_host PROTO ((char *)); +struct tree *tree_const PROTO ((unsigned char *, int)); +struct tree *tree_concat PROTO ((struct tree *, struct tree *)); +struct tree *tree_limit PROTO ((struct tree *, int)); +int tree_evaluate PROTO ((struct tree_cache *)); + +/* dhcp.c */ +extern int outstanding_pings; + +void dhcp PROTO ((struct packet *)); +void dhcpdiscover PROTO ((struct packet *)); +void dhcprequest PROTO ((struct packet *)); +void dhcprelease PROTO ((struct packet *)); +void dhcpdecline PROTO ((struct packet *)); +void dhcpinform PROTO ((struct packet *)); +void nak_lease PROTO ((struct packet *, struct iaddr *cip)); +void ack_lease PROTO ((struct packet *, struct lease *, unsigned int, TIME)); +void dhcp_reply PROTO ((struct lease *)); +struct lease *find_lease PROTO ((struct packet *, + struct shared_network *, int *)); +struct lease *mockup_lease PROTO ((struct packet *, + struct shared_network *, + struct host_decl *)); + +/* bootp.c */ +void bootp PROTO ((struct packet *)); + +/* memory.c */ +void enter_host PROTO ((struct host_decl *)); +struct host_decl *find_hosts_by_haddr PROTO ((int, unsigned char *, int)); +struct host_decl *find_hosts_by_uid PROTO ((unsigned char *, int)); +struct subnet *find_host_for_network PROTO ((struct host_decl **, + struct iaddr *, + struct shared_network *)); +void new_address_range PROTO ((struct iaddr, struct iaddr, + struct subnet *, int)); +extern struct subnet *find_grouped_subnet PROTO ((struct shared_network *, + struct iaddr)); +extern struct subnet *find_subnet PROTO ((struct iaddr)); +void enter_shared_network PROTO ((struct shared_network *)); +int subnet_inner_than PROTO ((struct subnet *, struct subnet *, int)); +void enter_subnet PROTO ((struct subnet *)); +void enter_lease PROTO ((struct lease *)); +int supersede_lease PROTO ((struct lease *, struct lease *, int)); +void release_lease PROTO ((struct lease *)); +void abandon_lease PROTO ((struct lease *, char *)); +struct lease *find_lease_by_uid PROTO ((unsigned char *, int)); +struct lease *find_lease_by_hw_addr PROTO ((unsigned char *, int)); +struct lease *find_lease_by_ip_addr PROTO ((struct iaddr)); +void uid_hash_add PROTO ((struct lease *)); +void uid_hash_delete PROTO ((struct lease *)); +void hw_hash_add PROTO ((struct lease *)); +void hw_hash_delete PROTO ((struct lease *)); +struct class *add_class PROTO ((int, char *)); +struct class *find_class PROTO ((int, unsigned char *, int)); +struct group *clone_group PROTO ((struct group *, char *)); +void write_leases PROTO ((void)); +void dump_subnets PROTO ((void)); + +/* alloc.c */ +VOIDPTR dmalloc PROTO ((int, char *)); +void dfree PROTO ((VOIDPTR, char *)); +struct packet *new_packet PROTO ((char *)); +struct dhcp_packet *new_dhcp_packet PROTO ((char *)); +struct tree *new_tree PROTO ((char *)); +struct tree_cache *new_tree_cache PROTO ((char *)); +struct hash_table *new_hash_table PROTO ((int, char *)); +struct hash_bucket *new_hash_bucket PROTO ((char *)); +struct lease *new_lease PROTO ((char *)); +struct lease *new_leases PROTO ((int, char *)); +struct subnet *new_subnet PROTO ((char *)); +struct class *new_class PROTO ((char *)); +struct shared_network *new_shared_network PROTO ((char *)); +struct group *new_group PROTO ((char *)); +struct protocol *new_protocol PROTO ((char *)); +struct lease_state *new_lease_state PROTO ((char *)); +struct domain_search_list *new_domain_search_list PROTO ((char *)); +struct name_server *new_name_server PROTO ((char *)); +void free_name_server PROTO ((struct name_server *, char *)); +void free_domain_search_list PROTO ((struct domain_search_list *, char *)); +void free_lease_state PROTO ((struct lease_state *, char *)); +void free_protocol PROTO ((struct protocol *, char *)); +void free_group PROTO ((struct group *, char *)); +void free_shared_network PROTO ((struct shared_network *, char *)); +void free_class PROTO ((struct class *, char *)); +void free_subnet PROTO ((struct subnet *, char *)); +void free_lease PROTO ((struct lease *, char *)); +void free_hash_bucket PROTO ((struct hash_bucket *, char *)); +void free_hash_table PROTO ((struct hash_table *, char *)); +void free_tree_cache PROTO ((struct tree_cache *, char *)); +void free_packet PROTO ((struct packet *, char *)); +void free_dhcp_packet PROTO ((struct dhcp_packet *, char *)); +void free_tree PROTO ((struct tree *, char *)); + +/* print.c */ +char *print_hw_addr PROTO ((int, int, unsigned char *)); +void print_lease PROTO ((struct lease *)); +void dump_raw PROTO ((unsigned char *, int)); +void dump_packet PROTO ((struct packet *)); +void hash_dump PROTO ((struct hash_table *)); + +/* socket.c */ +#if defined (USE_SOCKET_SEND) || defined (USE_SOCKET_RECEIVE) \ + || defined (USE_SOCKET_FALLBACK) +int if_register_socket PROTO ((struct interface_info *)); +#endif + +#ifdef USE_SOCKET_FALLBACK +void if_reinitialize_fallback PROTO ((struct interface_info *)); +void if_register_fallback PROTO ((struct interface_info *)); +ssize_t send_fallback PROTO ((struct interface_info *, + struct packet *, struct dhcp_packet *, size_t, + struct in_addr, + struct sockaddr_in *, struct hardware *)); +#endif + +#ifdef USE_SOCKET_SEND +void if_reinitialize_send PROTO ((struct interface_info *)); +void if_register_send PROTO ((struct interface_info *)); +ssize_t send_packet PROTO ((struct interface_info *, + struct packet *, struct dhcp_packet *, size_t, + struct in_addr, + struct sockaddr_in *, struct hardware *)); +#endif +#if defined (USE_SOCKET_FALLBACK) +void fallback_discard PROTO ((struct protocol *)); +#endif +#ifdef USE_SOCKET_RECEIVE +void if_reinitialize_receive PROTO ((struct interface_info *)); +void if_register_receive PROTO ((struct interface_info *)); +ssize_t receive_packet PROTO ((struct interface_info *, + unsigned char *, size_t, + struct sockaddr_in *, struct hardware *)); +#endif +#if defined (USE_SOCKET_SEND) && !defined (USE_SOCKET_FALLBACK) +int can_unicast_without_arp PROTO ((void)); +void maybe_setup_fallback PROTO ((void)); +#endif + +/* bpf.c */ +#if defined (USE_BPF_SEND) || defined (USE_BPF_RECEIVE) +int if_register_bpf PROTO ( (struct interface_info *)); +#endif +#ifdef USE_BPF_SEND +void if_reinitialize_send PROTO ((struct interface_info *)); +void if_register_send PROTO ((struct interface_info *)); +ssize_t send_packet PROTO ((struct interface_info *, + struct packet *, struct dhcp_packet *, size_t, + struct in_addr, + struct sockaddr_in *, struct hardware *)); +#endif +#ifdef USE_BPF_RECEIVE +void if_reinitialize_receive PROTO ((struct interface_info *)); +void if_register_receive PROTO ((struct interface_info *)); +ssize_t receive_packet PROTO ((struct interface_info *, + unsigned char *, size_t, + struct sockaddr_in *, struct hardware *)); +#endif +#if defined (USE_BPF_SEND) +int can_unicast_without_arp PROTO ((void)); +void maybe_setup_fallback PROTO ((void)); +#endif + +/* lpf.c */ +#if defined (USE_LPF_SEND) || defined (USE_LPF_RECEIVE) +int if_register_lpf PROTO ( (struct interface_info *)); +#endif +#ifdef USE_LPF_SEND +void if_reinitialize_send PROTO ((struct interface_info *)); +void if_register_send PROTO ((struct interface_info *)); +ssize_t send_packet PROTO ((struct interface_info *, + struct packet *, struct dhcp_packet *, size_t, + struct in_addr, + struct sockaddr_in *, struct hardware *)); +#endif +#ifdef USE_LPF_RECEIVE +void if_reinitialize_receive PROTO ((struct interface_info *)); +void if_register_receive PROTO ((struct interface_info *)); +ssize_t receive_packet PROTO ((struct interface_info *, + unsigned char *, size_t, + struct sockaddr_in *, struct hardware *)); +#endif +#if defined (USE_LPF_SEND) +int can_unicast_without_arp PROTO ((void)); +void maybe_setup_fallback PROTO ((void)); +#endif + +/* nit.c */ +#if defined (USE_NIT_SEND) || defined (USE_NIT_RECEIVE) +int if_register_nit PROTO ( (struct interface_info *)); +#endif + +#ifdef USE_NIT_SEND +void if_reinitialize_send PROTO ((struct interface_info *)); +void if_register_send PROTO ((struct interface_info *)); +ssize_t send_packet PROTO ((struct interface_info *, + struct packet *, struct dhcp_packet *, size_t, + struct in_addr, + struct sockaddr_in *, struct hardware *)); +#endif +#ifdef USE_NIT_RECEIVE +void if_reinitialize_receive PROTO ((struct interface_info *)); +void if_register_receive PROTO ((struct interface_info *)); +ssize_t receive_packet PROTO ((struct interface_info *, + unsigned char *, size_t, + struct sockaddr_in *, struct hardware *)); +#endif +#if defined (USE_NIT_SEND) +int can_unicast_without_arp PROTO ((void)); +void maybe_setup_fallback PROTO ((void)); +#endif + +#ifdef USE_DLPI_SEND +void if_reinitialize_send PROTO ((struct interface_info *)); +void if_register_send PROTO ((struct interface_info *)); +ssize_t send_packet PROTO ((struct interface_info *, + struct packet *, struct dhcp_packet *, size_t, + struct in_addr, + struct sockaddr_in *, struct hardware *)); +#endif +#ifdef USE_DLPI_RECEIVE +void if_reinitialize_receive PROTO ((struct interface_info *)); +void if_register_receive PROTO ((struct interface_info *)); +ssize_t receive_packet PROTO ((struct interface_info *, + unsigned char *, size_t, + struct sockaddr_in *, struct hardware *)); +#endif +#if defined (USE_DLPI_SEND) +int can_unicast_without_arp PROTO ((void)); +void maybe_setup_fallback PROTO ((void)); +#endif + +/* raw.c */ +#ifdef USE_RAW_SEND +void if_reinitialize_send PROTO ((struct interface_info *)); +void if_register_send PROTO ((struct interface_info *)); +ssize_t send_packet PROTO ((struct interface_info *, + struct packet *, struct dhcp_packet *, size_t, + struct in_addr, + struct sockaddr_in *, struct hardware *)); +int can_unicast_without_arp PROTO ((void)); +void maybe_setup_fallback PROTO ((void)); +#endif + +/* dispatch.c */ +extern struct interface_info *interfaces, + *dummy_interfaces, *fallback_interface; +extern struct protocol *protocols; +extern int quiet_interface_discovery; +extern void (*bootp_packet_handler) PROTO ((struct interface_info *, + struct dhcp_packet *, int, + unsigned int, + struct iaddr, struct hardware *)); +extern struct timeout *timeouts; +void discover_interfaces PROTO ((int)); +struct interface_info *setup_fallback PROTO ((void)); +void reinitialize_interfaces PROTO ((void)); +void dispatch PROTO ((void)); +int locate_network PROTO ((struct packet *)); +void got_one PROTO ((struct protocol *)); +void add_timeout PROTO ((TIME, void (*) PROTO ((void *)), void *)); +void cancel_timeout PROTO ((void (*) PROTO ((void *)), void *)); +void add_protocol PROTO ((char *, int, + void (*) PROTO ((struct protocol *)), void *)); + +void remove_protocol PROTO ((struct protocol *)); + +/* hash.c */ +struct hash_table *new_hash PROTO ((void)); +void add_hash PROTO ((struct hash_table *, unsigned char *, + int, unsigned char *)); +void delete_hash_entry PROTO ((struct hash_table *, unsigned char *, int)); +unsigned char *hash_lookup PROTO ((struct hash_table *, unsigned char *, int)); + +/* tables.c */ +extern struct option dhcp_options [256]; +extern unsigned char dhcp_option_default_priority_list []; +extern int sizeof_dhcp_option_default_priority_list; +extern char *hardware_types [256]; +extern struct hash_table universe_hash; +extern struct universe dhcp_universe; +void initialize_universes PROTO ((void)); + +/* convert.c */ +u_int32_t getULong PROTO ((unsigned char *)); +int32_t getLong PROTO ((unsigned char *)); +u_int16_t getUShort PROTO ((unsigned char *)); +int16_t getShort PROTO ((unsigned char *)); +void putULong PROTO ((unsigned char *, u_int32_t)); +void putLong PROTO ((unsigned char *, int32_t)); +void putUShort PROTO ((unsigned char *, unsigned int)); +void putShort PROTO ((unsigned char *, int)); + +/* inet.c */ +struct iaddr subnet_number PROTO ((struct iaddr, struct iaddr)); +struct iaddr ip_addr PROTO ((struct iaddr, struct iaddr, u_int32_t)); +struct iaddr broadcast_addr PROTO ((struct iaddr, struct iaddr)); +u_int32_t host_addr PROTO ((struct iaddr, struct iaddr)); +int addr_eq PROTO ((struct iaddr, struct iaddr)); +char *piaddr PROTO ((struct iaddr)); + +/* dhclient.c */ +extern char *path_dhclient_conf; +extern char *path_dhclient_db; +extern char *path_dhclient_pid; +extern int interfaces_requested; + +extern struct client_config top_level_config; + +void dhcpoffer PROTO ((struct packet *)); +void dhcpack PROTO ((struct packet *)); +void dhcpnak PROTO ((struct packet *)); + +void send_discover PROTO ((void *)); +void send_request PROTO ((void *)); +void send_release PROTO ((void *)); +void send_decline PROTO ((void *)); + +void state_reboot PROTO ((void *)); +void state_init PROTO ((void *)); +void state_selecting PROTO ((void *)); +void state_requesting PROTO ((void *)); +void state_bound PROTO ((void *)); +void state_panic PROTO ((void *)); + +void bind_lease PROTO ((struct interface_info *)); + +void make_discover PROTO ((struct interface_info *, struct client_lease *)); +void make_request PROTO ((struct interface_info *, struct client_lease *)); +void make_decline PROTO ((struct interface_info *, struct client_lease *)); +void make_release PROTO ((struct interface_info *, struct client_lease *)); + +void free_client_lease PROTO ((struct client_lease *)); +void rewrite_client_leases PROTO ((void)); +void write_client_lease PROTO ((struct interface_info *, + struct client_lease *, int)); +char *dhcp_option_ev_name PROTO ((struct option *)); + +void script_init PROTO ((struct interface_info *, char *, + struct string_list *)); +void script_write_params PROTO ((struct interface_info *, + char *, struct client_lease *)); +int script_go PROTO ((struct interface_info *)); + +struct client_lease *packet_to_lease PROTO ((struct packet *)); +void go_daemon PROTO ((void)); +void write_client_pid_file PROTO ((void)); +void status_message PROTO ((struct sysconf_header *, void *)); +void client_location_changed PROTO ((void)); + +/* db.c */ +int write_lease PROTO ((struct lease *)); +int commit_leases PROTO ((void)); +void db_startup PROTO ((void)); +void new_lease_file PROTO ((void)); + +/* packet.c */ +u_int32_t checksum PROTO ((unsigned char *, int, u_int32_t)); +u_int32_t wrapsum PROTO ((u_int32_t)); +void assemble_hw_header PROTO ((struct interface_info *, unsigned char *, + int *, struct hardware *)); +void assemble_udp_ip_header PROTO ((struct interface_info *, unsigned char *, + int *, u_int32_t, u_int32_t, unsigned int, + unsigned char *, int)); +ssize_t decode_hw_header PROTO ((struct interface_info *, unsigned char *, + int, struct hardware *)); +ssize_t decode_udp_ip_header PROTO ((struct interface_info *, unsigned char *, + int, struct sockaddr_in *, + unsigned char *, int)); + +/* dhxpxlt.c */ +void convert_statement PROTO ((FILE *)); +void convert_host_statement PROTO ((FILE *, jrefproto)); +void convert_host_name PROTO ((FILE *, jrefproto)); +void convert_class_statement PROTO ((FILE *, jrefproto, int)); +void convert_class_decl PROTO ((FILE *, jrefproto)); +void convert_lease_time PROTO ((FILE *, jrefproto, char *)); +void convert_shared_net_statement PROTO ((FILE *, jrefproto)); +void convert_subnet_statement PROTO ((FILE *, jrefproto)); +void convert_subnet_decl PROTO ((FILE *, jrefproto)); +void convert_host_decl PROTO ((FILE *, jrefproto)); +void convert_hardware_decl PROTO ((FILE *, jrefproto)); +void convert_hardware_addr PROTO ((FILE *, jrefproto)); +void convert_filename_decl PROTO ((FILE *, jrefproto)); +void convert_servername_decl PROTO ((FILE *, jrefproto)); +void convert_ip_addr_or_hostname PROTO ((FILE *, jrefproto, int)); +void convert_fixed_addr_decl PROTO ((FILE *, jrefproto)); +void convert_option_decl PROTO ((FILE *, jrefproto)); +void convert_timestamp PROTO ((FILE *, jrefproto)); +void convert_lease_statement PROTO ((FILE *, jrefproto)); +void convert_address_range PROTO ((FILE *, jrefproto)); +void convert_date PROTO ((FILE *, jrefproto, char *)); +void convert_numeric_aggregate PROTO ((FILE *, jrefproto, int, int, int, int)); +void indent PROTO ((int)); + +/* route.c */ +void add_route_direct PROTO ((struct interface_info *, struct in_addr)); +void add_route_net PROTO ((struct interface_info *, struct in_addr, + struct in_addr)); +void add_route_default_gateway PROTO ((struct interface_info *, + struct in_addr)); +void remove_routes PROTO ((struct in_addr)); +void remove_if_route PROTO ((struct interface_info *, struct in_addr)); +void remove_all_if_routes PROTO ((struct interface_info *)); +void set_netmask PROTO ((struct interface_info *, struct in_addr)); +void set_broadcast_addr PROTO ((struct interface_info *, struct in_addr)); +void set_ip_address PROTO ((struct interface_info *, struct in_addr)); + +/* clparse.c */ +int read_client_conf PROTO ((void)); +void read_client_leases PROTO ((void)); +void parse_client_statement PROTO ((FILE *, struct interface_info *, + struct client_config *)); +int parse_X PROTO ((FILE *, u_int8_t *, int)); +int parse_option_list PROTO ((FILE *, u_int8_t *)); +void parse_interface_declaration PROTO ((FILE *, struct client_config *)); +struct interface_info *interface_or_dummy PROTO ((char *)); +void make_client_state PROTO ((struct interface_info *)); +void make_client_config PROTO ((struct interface_info *, + struct client_config *)); +void parse_client_lease_statement PROTO ((FILE *, int)); +void parse_client_lease_declaration PROTO ((FILE *, struct client_lease *, + struct interface_info **)); +struct option *parse_option_decl PROTO ((FILE *, struct option_data *)); +void parse_string_list PROTO ((FILE *, struct string_list **, int)); +int parse_ip_addr PROTO ((FILE *, struct iaddr *)); +void parse_reject_statement PROTO ((FILE *, struct client_config *)); + +/* dhcrelay.c */ +void relay PROTO ((struct interface_info *, struct dhcp_packet *, int, + unsigned int, struct iaddr, struct hardware *)); + +/* icmp.c */ +void icmp_startup PROTO ((int, void (*) PROTO ((struct iaddr, + u_int8_t *, int)))); +int icmp_echorequest PROTO ((struct iaddr *)); +void icmp_echoreply PROTO ((struct protocol *)); + +/* dns.c */ +void dns_startup PROTO ((void)); +int ns_inaddr_lookup PROTO ((u_int16_t, struct iaddr)); +void dns_packet PROTO ((struct protocol *)); + +/* resolv.c */ +extern char path_resolv_conf []; +struct name_server *name_servers; +struct domain_search_list *domains; + +void read_resolv_conf PROTO ((TIME)); +struct sockaddr_in *pick_name_server PROTO ((void)); + +/* inet_addr.c */ +#ifdef NEED_INET_ATON +int inet_aton PROTO ((const char *, struct in_addr *)); +#endif + +/* sysconf.c */ +void sysconf_startup PROTO ((void (*) (struct sysconf_header *, void *))); +void sysconf_restart PROTO ((void *)); +void sysconf_message PROTO ((struct protocol *proto)); diff --git a/contrib/isc-dhcp/includes/dhctoken.h b/contrib/isc-dhcp/includes/dhctoken.h new file mode 100644 index 000000000000..73f6879e3ddf --- /dev/null +++ b/contrib/isc-dhcp/includes/dhctoken.h @@ -0,0 +1,135 @@ +/* dhctoken.h + + Tokens for config file lexer and parser. */ + +/* + * Copyright (c) 1995, 1996, 1997, 1998, 1999 + * The Internet Software Consortium. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of The Internet Software Consortium nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND + * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This software has been written for the Internet Software Consortium + * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie + * Enterprises. To learn more about the Internet Software Consortium, + * see ``http://www.vix.com/isc''. To learn more about Vixie + * Enterprises, see ``http://www.vix.com''. + */ + +#define SEMI ';' +#define DOT '.' +#define COLON ':' +#define COMMA ',' +#define SLASH '/' +#define LBRACE '{' +#define RBRACE '}' + +#define FIRST_TOKEN HOST +#define HOST 256 +#define HARDWARE 257 +#define FILENAME 258 +#define FIXED_ADDR 259 +#define OPTION 260 +#define ETHERNET 261 +#define STRING 262 +#define NUMBER 263 +#define NUMBER_OR_NAME 264 +#define NAME 265 +#define TIMESTAMP 266 +#define STARTS 267 +#define ENDS 268 +#define UID 269 +#define CLASS 270 +#define LEASE 271 +#define RANGE 272 +#define PACKET 273 +#define CIADDR 274 +#define YIADDR 275 +#define SIADDR 276 +#define GIADDR 277 +#define SUBNET 278 +#define NETMASK 279 +#define DEFAULT_LEASE_TIME 280 +#define MAX_LEASE_TIME 281 +#define VENDOR_CLASS 282 +#define USER_CLASS 283 +#define SHARED_NETWORK 284 +#define SERVER_NAME 285 +#define DYNAMIC_BOOTP 286 +#define SERVER_IDENTIFIER 287 +#define DYNAMIC_BOOTP_LEASE_CUTOFF 288 +#define DYNAMIC_BOOTP_LEASE_LENGTH 289 +#define BOOT_UNKNOWN_CLIENTS 290 +#define NEXT_SERVER 291 +#define TOKEN_RING 292 +#define GROUP 293 +#define ONE_LEASE_PER_CLIENT 294 +#define GET_LEASE_HOSTNAMES 295 +#define USE_HOST_DECL_NAMES 296 +#define SEND 297 +#define CLIENT_IDENTIFIER 298 +#define REQUEST 299 +#define REQUIRE 300 +#define TIMEOUT 301 +#define RETRY 302 +#define SELECT_TIMEOUT 303 +#define SCRIPT 304 +#define INTERFACE 305 +#define RENEW 306 +#define REBIND 307 +#define EXPIRE 308 +#define UNKNOWN_CLIENTS 309 +#define ALLOW 310 +#define BOOTP 311 +#define DENY 312 +#define BOOTING 313 +#define DEFAULT 314 +#define MEDIA 315 +#define MEDIUM 316 +#define ALIAS 317 +#define REBOOT 318 +#define ABANDONED 319 +#define BACKOFF_CUTOFF 320 +#define INITIAL_INTERVAL 321 +#define NAMESERVER 322 +#define DOMAIN 323 +#define SEARCH 324 +#define SUPERSEDE 325 +#define APPEND 326 +#define PREPEND 327 +#define HOSTNAME 328 +#define CLIENT_HOSTNAME 329 +#define REJECT 330 +#define FDDI 331 +#define USE_LEASE_ADDR_FOR_DEFAULT_ROUTE 332 +#define AUTHORITATIVE 333 +#define TOKEN_NOT 334 + +#define is_identifier(x) ((x) >= FIRST_TOKEN && \ + (x) != STRING && \ + (x) != NUMBER && \ + (x) != EOF) diff --git a/contrib/isc-dhcp/includes/osdep.h b/contrib/isc-dhcp/includes/osdep.h new file mode 100644 index 000000000000..ca40e8a75bba --- /dev/null +++ b/contrib/isc-dhcp/includes/osdep.h @@ -0,0 +1,228 @@ +/* osdep.h + + Operating system dependencies... */ + +/* + * Copyright (c) 1996, 1997, 1998 The Internet Software Consortium. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of The Internet Software Consortium nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND + * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL + * THE INTERNET SOFTWARE CONSORTIUM OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + * + * This software was written for the Internet Software Consortium by Ted Lemon + * under a contract with Vixie Laboratories. + */ + +#include "site.h" + +/* Porting:: + + If you add a new network API, you must add a check for it below: */ + +#if !defined (USE_SOCKETS) && \ + !defined (USE_SOCKET_SEND) && \ + !defined (USE_SOCKET_RECEIVE) && \ + !defined (USE_RAW_SOCKETS) && \ + !defined (USE_RAW_SEND) && \ + !defined (USE_SOCKET_RECEIVE) && \ + !defined (USE_BPF) && \ + !defined (USE_BPF_SEND) && \ + !defined (USE_BPF_RECEIVE) && \ + !defined (USE_LPF) && \ + !defined (USE_LPF_SEND) && \ + !defined (USE_LPF_RECEIVE) && \ + !defined (USE_NIT) && \ + !defined (USE_NIT_SEND) && \ + !defined (USE_NIT_RECEIVE) && \ + !defined (USR_DLPI_SEND) && \ + !defined (USE_DLPI_RECEIVE) +# define USE_DEFAULT_NETWORK +#endif + + +/* Porting:: + + If you add a new system configuration file, include it here: */ + +#if defined (sun) +# if defined (__svr4__) || defined (__SVR4) +# include "cf/sunos5-5.h" +# else +# include "cf/sunos4.h" +# endif +#endif + +#ifdef bsdi +# include "cf/bsdos.h" +#endif + +#ifdef __NetBSD__ +# include "cf/netbsd.h" +#endif + +#ifdef __FreeBSD__ +# include "cf/freebsd.h" +#endif + +#if defined (__osf__) && defined (__alpha) +# include "cf/alphaosf.h" +#endif + +#ifdef ultrix +# include "cf/ultrix.h" +#endif + +#ifdef linux +# include "cf/linux.h" +#endif + +#ifdef SCO +# include "cf/sco.h" +#endif + +#ifdef hpux +# include "cf/hpux.h" +#endif + +#ifdef __QNX__ +# include "cf/qnx.h" +#endif + +#ifdef __CYGWIN32__ +# include "cf/cygwin32.h" +#endif + +#ifdef NeXT +# ifdef __APPLE__ +# include "cf/rhapsody.h" +# else +# include "cf/nextstep.h" +# endif +#endif + +/* Porting:: + + If you add a new network API, and have it set up so that it can be + used for sending or receiving, but doesn't have to be used for both, + then set up an ifdef like the ones below: */ + +#ifdef USE_SOCKETS +# define USE_SOCKET_SEND +# define USE_SOCKET_RECEIVE +#endif + +#ifdef USE_RAW_SOCKETS +# define USE_RAW_SEND +# define USE_SOCKET_RECEIVE +#endif + +#ifdef USE_BPF +# define USE_BPF_SEND +# define USE_BPF_RECEIVE +#endif + +#ifdef USE_LPF +# define USE_LPF_SEND +# define USE_LPF_RECEIVE +#endif + +#ifdef USE_NIT +# define USE_NIT_SEND +# define USE_NIT_RECEIVE +#endif + +#ifdef USE_DLPI +# define USE_DLPI_SEND +# define USE_DLPI_RECEIVE +#endif + +#ifdef USE_UPF +# define USE_UPF_SEND +# define USE_UPF_RECEIVE +#endif + +/* Porting:: + + If you add support for sending packets directly out an interface, + and your support does not do ARP or routing, you must use a fallback + mechanism to deal with packets that need to be sent to routers. + Currently, all low-level packet interfaces use BSD sockets as a + fallback. */ + +#if defined (USE_BPF_SEND) || defined (USE_NIT_SEND) || \ + defined (USE_DLPI_SEND) || defined (USE_UPF_SEND) || defined (USE_LPF_SEND) +# define USE_SOCKET_FALLBACK +# define USE_FALLBACK +#endif + +/* Porting:: + + If you add support for sending packets directly out an interface + and need to be able to assemble packets, add the USE_XXX_SEND + definition for your interface to the list tested below. */ + +#if defined (USE_RAW_SEND) || defined (USE_BPF_SEND) || \ + defined (USE_NIT_SEND) || defined (USE_UPF_SEND) || \ + defined (USE_DLPI_SEND) || defined (USE_LPF_SEND) +# define PACKET_ASSEMBLY +#endif + +/* Porting:: + + If you add support for receiving packets directly from an interface + and need to be able to decode raw packets, add the USE_XXX_RECEIVE + definition for your interface to the list tested below. */ + +#if defined (USE_RAW_RECEIVE) || defined (USE_BPF_SEND) || \ + defined (USE_NIT_RECEIVE) || defined (USE_UPF_RECEIVE) || \ + defined (USE_DLPI_RECEIVE) || defined (USE_LPF_RECEIVE) +# define PACKET_DECODING +#endif + +/* If we don't have a DLPI packet filter, we have to filter in userland. + Probably not worth doing, actually. */ +#if defined (USE_DLPI_RECEIVE) && !defined (USE_DLPI_PFMOD) +# define USERLAND_FILTER +#endif + +/* jmp_buf is assumed to be a struct unless otherwise defined in the + system header. */ +#ifndef jbp_decl +# define jbp_decl(x) jmp_buf *x +#endif +#ifndef jref +# define jref(x) (&(x)) +#endif +#ifndef jdref +# define jdref(x) (*(x)) +#endif +#ifndef jrefproto +# define jrefproto jmp_buf * +#endif + +#ifndef BPF_FORMAT +# define BPF_FORMAT "/dev/bpf%d" +#endif diff --git a/etc/dhclient.conf b/etc/dhclient.conf new file mode 100644 index 000000000000..b3608a3af703 --- /dev/null +++ b/etc/dhclient.conf @@ -0,0 +1,8 @@ +# $Id$ +# +# This file is required by the ISC DHCP client. +# See ``man 5 dhclient.conf'' for details. +# +# In most cases an empty file is suffient for most people as the +# defaults are usually fine. +# diff --git a/etc/rc.diskless2 b/etc/rc.diskless2 new file mode 100644 index 000000000000..37412d31a910 --- /dev/null +++ b/etc/rc.diskless2 @@ -0,0 +1,35 @@ +# rc.diskless2 +# + +# If there is a global system configuration file, suck it in. +# +if [ -f /etc/defaults/rc.conf ]; then + . /etc/defaults/rc.conf +elif [ -f /etc/rc.conf ]; then + . /etc/rc.conf +fi + +mount_mfs -s ${var_run_sectors:=2048} -T qp120at dummy /var/run +mount_mfs -s ${var_db_sectors:=16384} -T qp120at dummy /var/db +mount_mfs -s ${var_tmp_sectors:=65536} -T qp120at dummy /var/tmp +mount_mfs -s ${var_spool_sectors:=65536} -T qp120at dummy /var/spool +chmod 755 /var/run +chmod 755 /var/db +chmod 755 /var/spool +chmod 1777 /var/tmp + +if [ ! -h /tmp -a ! -h /var/tmp ]; then + mount_null /var/tmp /tmp +fi + +mkdir /var/spool/mqueue +mkdir /var/spool/lpd +mkdir /var/spool/output +mkdir /var/spool/output/lpd +chown -R root.daemon /var/spool/output +chgrp daemon /var/spool/lpd + +( cd /; find -x dev | cpio -o -H newc ) > /tmp/dev.tmp +mount_mfs -s 4096 -i 512 -T qp120at dummy /dev +( cd /; cpio -i -H newc -d < /tmp/dev.tmp ) + diff --git a/lib/libstand/alpha/_setjmp.S b/lib/libstand/alpha/_setjmp.S new file mode 100644 index 000000000000..2aa8c55a5ee7 --- /dev/null +++ b/lib/libstand/alpha/_setjmp.S @@ -0,0 +1,123 @@ +/* $NetBSD: _setjmp.S,v 1.2 1996/10/17 03:08:03 cgd Exp $ */ + +/* + * Copyright (c) 1994, 1995 Carnegie-Mellon University. + * All rights reserved. + * + * Author: Chris G. Demetriou + * + * Permission to use, copy, modify and distribute this software and + * its documentation is hereby granted, provided that both the copyright + * notice and this permission notice appear in all copies of the + * software, derivative works or modified versions, and any portions + * thereof, and that both notices appear in supporting documentation. + * + * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" + * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND + * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. + * + * Carnegie Mellon requests users of this software to return to + * + * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU + * School of Computer Science + * Carnegie Mellon University + * Pittsburgh PA 15213-3890 + * + * any improvements or extensions that they make and grant Carnegie the + * rights to redistribute these changes. + */ + +#include <machine/asm.h> + +/* + * C library -- _setjmp, _longjmp + * + * _longjmp(a,v) + * will generate a "return(v)" from + * the last call to + * _setjmp(a) + * by restoring registers from the stack, + * The previous signal state is NOT restored. + */ + + .set noreorder + +LEAF(_setjmp, 1) + LDGP(pv) + stq ra, (2 * 8)(a0) /* sc_pc = return address */ + stq s0, (( 9 + 4) * 8)(a0) /* saved bits of sc_regs */ + stq s1, ((10 + 4) * 8)(a0) + stq s2, ((11 + 4) * 8)(a0) + stq s3, ((12 + 4) * 8)(a0) + stq s4, ((13 + 4) * 8)(a0) + stq s5, ((14 + 4) * 8)(a0) + stq s6, ((15 + 4) * 8)(a0) + stq ra, ((26 + 4) * 8)(a0) + stq sp, ((30 + 4) * 8)(a0) + ldiq t0, 0xacedbadd /* sigcontext magic number */ + stq t0, ((31 + 4) * 8)(a0) /* magic in sc_regs[31] */ + /* Too bad we can't check if we actually used FP */ + ldiq t0, 1 + stq t0, (36 * 8)(a0) /* say we've used FP. */ + stt fs0, ((2 + 37) * 8)(a0) /* saved bits of sc_fpregs */ + stt fs1, ((3 + 37) * 8)(a0) + stt fs2, ((4 + 37) * 8)(a0) + stt fs3, ((5 + 37) * 8)(a0) + stt fs4, ((6 + 37) * 8)(a0) + stt fs5, ((7 + 37) * 8)(a0) + stt fs6, ((8 + 37) * 8)(a0) + stt fs7, ((9 + 37) * 8)(a0) + mf_fpcr ft0 /* get FP control reg */ + stt ft0, (69 * 8)(a0) /* and store it in sc_fpcr */ + stq zero, (70 * 8)(a0) /* FP software control XXX */ + stq zero, (71 * 8)(a0) /* sc_reserved[0] */ + stq zero, (72 * 8)(a0) /* sc_reserved[1] */ + stq zero, (73 * 8)(a0) /* sc_xxx[0] */ + stq zero, (74 * 8)(a0) /* sc_xxx[1] */ + stq zero, (75 * 8)(a0) /* sc_xxx[2] */ + stq zero, (76 * 8)(a0) /* sc_xxx[3] */ + stq zero, (77 * 8)(a0) /* sc_xxx[4] */ + stq zero, (78 * 8)(a0) /* sc_xxx[5] */ + stq zero, (79 * 8)(a0) /* sc_xxx[6] */ + stq zero, (80 * 8)(a0) /* sc_xxx[7] */ + + mov zero, v0 /* return zero */ + RET +END(_setjmp) + +LEAF(_longjmp, 2) + LDGP(pv) + ldq t0, ((31 + 4) * 8)(a0) /* magic in sc_regs[31] */ + ldiq t1, 0xacedbadd + cmpeq t0, t1, t0 + beq t0, botch /* If the magic was bad, punt */ + + ldq ra, (2 * 8)(a0) /* sc_pc = return address */ + ldq s0, (( 9 + 4) * 8)(a0) /* saved bits of sc_regs */ + ldq s1, ((10 + 4) * 8)(a0) + ldq s2, ((11 + 4) * 8)(a0) + ldq s3, ((12 + 4) * 8)(a0) + ldq s4, ((13 + 4) * 8)(a0) + ldq s5, ((14 + 4) * 8)(a0) + ldq s6, ((15 + 4) * 8)(a0) + /* ldq ra, ((26 + 4) * 8)(a0) set above */ + ldq sp, ((30 + 4) * 8)(a0) + ldt fs0, ((2 + 37) * 8)(a0) /* saved bits of sc_fpregs */ + ldt fs1, ((3 + 37) * 8)(a0) + ldt fs2, ((4 + 37) * 8)(a0) + ldt fs3, ((5 + 37) * 8)(a0) + ldt fs4, ((6 + 37) * 8)(a0) + ldt fs5, ((7 + 37) * 8)(a0) + ldt fs6, ((8 + 37) * 8)(a0) + ldt fs7, ((9 + 37) * 8)(a0) + ldt ft0, (69 * 8)(a0) /* get sc_fpcr */ + mt_fpcr ft0 /* and restore it. */ + + mov a1, v0 /* return second arg */ + RET + +botch: + CALL(longjmperror) + CALL(abort) + RET /* "can't" get here... */ +END(_longjmp) diff --git a/lib/libstand/i386/_setjmp.S b/lib/libstand/i386/_setjmp.S new file mode 100644 index 000000000000..d3b168c4db50 --- /dev/null +++ b/lib/libstand/i386/_setjmp.S @@ -0,0 +1,81 @@ +/*- + * Copyright (c) 1990 The Regents of the University of California. + * All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * William Jolitz. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: _setjmp.S,v 1.1 1999/02/12 17:20:19 dcs Exp $ + */ + +#if defined(LIBC_RCS) && !defined(lint) + .text + .asciz "$Id: _setjmp.S,v 1.1 1999/02/12 17:20:19 dcs Exp $" +#endif /* LIBC_RCS and not lint */ + +/* + * C library -- _setjmp, _longjmp + * + * _longjmp(a,v) + * will generate a "return(v)" from the last call to + * _setjmp(a) + * by restoring registers from the environment 'a'. + * The previous signal state is NOT restored. + */ + +#include "DEFS.h" + +ENTRY(_setjmp) + movl 4(%esp),%eax + movl 0(%esp),%edx + movl %edx, 0(%eax) /* rta */ + movl %ebx, 4(%eax) + movl %esp, 8(%eax) + movl %ebp,12(%eax) + movl %esi,16(%eax) + movl %edi,20(%eax) + xorl %eax,%eax + ret + +ENTRY(_longjmp) + movl 4(%esp),%edx + movl 8(%esp),%eax + movl 0(%edx),%ecx + movl 4(%edx),%ebx + movl 8(%edx),%esp + movl 12(%edx),%ebp + movl 16(%edx),%esi + movl 20(%edx),%edi + testl %eax,%eax + jnz 1f + incl %eax +1: movl %ecx,0(%esp) + ret diff --git a/share/examples/ppp/ppp.linkdown.sample b/share/examples/ppp/ppp.linkdown.sample new file mode 100644 index 000000000000..c5c488ac9be9 --- /dev/null +++ b/share/examples/ppp/ppp.linkdown.sample @@ -0,0 +1,34 @@ +######################################################################### +# +# Example of ppp.linkdown file +# +# This file is checked when ppp closes a connection. +# ppp searches the labels in this file as follows: +# +# 1) The label that matches the IP number assigned to our side. +# +# 2) The label specified on the command line to ppp. +# +# 3) If no label has been found, use MYADDR if it exists. +# +# +# $Id: ppp.linkdown.sample,v 1.2 1998/11/05 23:14:19 brian Exp $ +# +######################################################################### + +# We don't really need to do much here. If we have notified a DNS +# of our temporary IP number, we may want to ``un-notify'' them. +# +# If you're into sound effects when the link goes down, you can run +# ``auplay'' (assuming NAS is installed and configured). +# +MYADDR: + !bg /usr/X11R6/bin/auplay /etc/ppp/linkdown.au + +# If you're running ``ppp -auto -alias dynamic-alias-auto'', and are +# assigned a dynamic IP number by the peer, this may be worth while +# to keep the interface aliases to a minimum (see ``enable iface-alias'' +# in the man page): +# +dynamic-alias-auto: + iface clear diff --git a/share/examples/ppp/ppp.linkup.sample b/share/examples/ppp/ppp.linkup.sample new file mode 100644 index 000000000000..76b423645bca --- /dev/null +++ b/share/examples/ppp/ppp.linkup.sample @@ -0,0 +1,49 @@ +######################################################################### +# +# Example of ppp.linkup file +# +# This file is checked when ppp establishes a connection. +# ppp searches the labels in this file as follows: +# +# 1) The label that matches the IP number assigned to our side. +# +# 2) The label specified on the command line to ppp. +# +# 3) If no label has been found, use MYADDR if it exists. +# +# +# $Id: ppp.linkup.sample,v 1.14 1998/05/21 21:45:47 brian Exp $ +# +######################################################################### + +# It is no longer necessary to re-add the default route here as our +# ppp.conf route is `sticky' (see the man page). +# If you're into sound effects when the link comes up, you can run +# ``auplay'' (assuming NAS is installed and configured). +# +MYADDR: + !bg /usr/X11R6/bin/auplay /etc/ppp/linkup.au + +# If we've got 192.244.176.32 as our address, then regard peer as a gateway +# to 192.244.176.0 network. This may also be done in ppp.conf instead. +# +192.244.176.32: + add 192.244.176.0 0 HISADDR + +#You may want to execute a script after connecting. This script can do +# nice things such as kick off "sendmail -q", "popclient my.isp" and +# "slurp -d news". It can be passed MYADDR, HISADDR and INTERFACE +# as arguments too - useful for informing a DNS of your assigned IP. +# +# You may also want some sound effects.... +# +pmdemand: + !bg /etc/ppp/ppp.etherup.pmdemand + ! sh -c "cat /etc/ppp/linkup.au >/dev/audio" + +# If your minimum call charge is 5 minutes, you may as well stay on +# the line for that amount of time. If we want a 60 second subsequent +# timeout, set your timeout to 300 in ppp.conf and then do this: +# +min5minutes: + !bg sh -c "sleep 240; pppctl -p mypassword 3000 set timeout 60" diff --git a/share/examples/ppp/ppp.secret.sample b/share/examples/ppp/ppp.secret.sample new file mode 100644 index 000000000000..14bcc9e59594 --- /dev/null +++ b/share/examples/ppp/ppp.secret.sample @@ -0,0 +1,41 @@ +################################################## +# +# Example of ppp.secret file +# +# This file is used to authenticate incoming connections. +# You must ``enable'' either PAP or CHAP in your ppp.conf file. +# The peer may then use any of the Authname/Authkey pairs listed. +# Additionally, if ``passwdauth'' is enabled and an entry isn't +# found in this file, the passwd(5) database is used. +# +# If the password is specified as "*", look it up in passwd(5). +# This doesn't work for CHAP connections as ppp must have access +# to the unencrypted password for CHAP. +# +# If an IP address or address range is given as the third field, it +# will be assigned to the peer. A ``*'' or an empty field may be +# used as a placeholder if you do not wish to override the IP +# address, but wish to specify further fields. +# +# If a label is given as the forth field, it is used when reading +# the ppp.linkup and ppp.linkdown files. A ``*'' or an empty field +# can be used as a placeholder if you do not wish to override the +# label, but wish to specify further fields. +# +# If a phone number or list of phone numbers is given as the fifth +# field, these numbers will be used to call back the client if +# ``auth'' or ``cbcp'' callback is enabled (see ``set callback''). +# A ``*'' specifies that the client must specify the number. +# +# $Id: ppp.secret.sample,v 1.8 1998/08/07 18:44:31 brian Exp $ +# +################################################## + +# Authname Authkey Peer's IP address Label Callback + +oscar OurSecretKey 192.2.18.34 +BigBird X4dWg9327 192.2.18.33/32 +fred * * fred +subnet * 192.2.18.35-192.2.18.70 subnet +admin * * * * +homeworker * * * 1234567 |