Google Git
Sign in
apache / nuttx-apps / 7032c72f2f66c9cbe8d803bdd696b830f3f380b3 / . / netutils / dhcpd / dhcpd.c
blob: d72d7e3b0d76aeae3bc8a624e80b143ef5ff352b [file] [log] [blame]
/****************************************************************************
* apps/netutils/dhcpd/dhcpd.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#ifdef CONFIG_NETUTILS_DHCPD_HOST
# include <stdio.h>
# define HTONS(a) htons(a)
# define HTONL(a) htonl(a)
# define CONFIG_CPP_HAVE_WARNING 1
# define FAR
# define nerr(...) printf(__VA_ARGS__)
# define ninfo(...) printf(__VA_ARGS__)
# define ERROR (-1)
# define OK (0)
#else
# include <nuttx/config.h> /* NuttX configuration */
# include <debug.h> /* For nerr, info */
# include <nuttx/compiler.h> /* For CONFIG_CPP_HAVE_WARNING */
# include "netutils/dhcpd.h" /* Advertised DHCPD APIs */
#endif
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <inttypes.h>
#include <sched.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#include <errno.h>
#include <net/if.h>
#include <netinet/in.h>
#include <netinet/udp.h>
#include <arpa/inet.h>
#include "netutils/netlib.h"
/****************************************************************************
* Private Data
****************************************************************************/
#define DHCP_SERVER_PORT 67
#define DHCP_CLIENT_PORT 68
/* Option codes understood in this file
* Code Data Description
* Length
*/
#define DHCP_OPTION_PAD 0 /* 1 Pad */
#define DHCP_OPTION_SUBNET_MASK 1 /* 1 Subnet Mask */
#define DHCP_OPTION_ROUTER 3 /* 4 Router */
#define DHCP_OPTION_DNS_SERVER 6 /* 4N DNS */
#define DHCP_OPTION_REQ_IPADDR 50 /* 4 Requested IP Address */
#define DHCP_OPTION_LEASE_TIME 51 /* 4 IP address lease time */
#define DHCP_OPTION_OVERLOAD 52 /* 1 Option overload */
#define DHCP_OPTION_MSG_TYPE 53 /* 1 DHCP message type */
#define DHCP_OPTION_SERVER_ID 54 /* 4 Server identifier */
#define DHCP_OPTION_END 255 /* 0 End */
/* Values for the dhcp msg 'op' field */
#define DHCP_REQUEST 1
#define DHCP_REPLY 2
/* DHCP message types understood in this file */
#define DHCPDISCOVER 1 /* Received from client only */
#define DHCPOFFER 2 /* Sent from server only */
#define DHCPREQUEST 3 /* Received from client only */
#define DHCPDECLINE 4 /* Received from client only */
#define DHCPACK 5 /* Sent from server only */
#define DHCPNAK 6 /* Sent from server only */
#define DHCPRELEASE 7 /* Received from client only */
#define DHCPINFORM 8 /* Not used */
/* The form of an option is:
* code - 1 byte
* length - 1 byte
* data - variable number of bytes
*/
#define DHCPD_OPTION_CODE 0
#define DHCPD_OPTION_LENGTH 1
#define DHCPD_OPTION_DATA 2
/* Size of options in DHCP message */
#define DHCPD_OPTIONS_SIZE 312
/* Values for htype and hlen field */
#define DHCP_HTYPE_ETHERNET 1
#define DHCP_HLEN_ETHERNET 6
/* Values for flags field */
#define BOOTP_BROADCAST 0x8000
/* Legal values for this option are:
*
* 1 the 'file' field is used to hold options
* 2 the 'sname' field is used to hold options
* 3 both fields are used to hold options
*/
#define DHCPD_OPTION_FIELD 0
#define DHCPD_FILE_FIELD 1
#define DHCPD_SNAME_FIELD 2
#ifndef CONFIG_NETUTILS_DHCPD_LEASETIME
# define CONFIG_NETUTILS_DHCPD_LEASETIME (60*60*24*10) /* 10 days */
# undef CONFIG_NETUTILS_DHCPD_MINLEASETIME
# undef CONFIG_NETUTILS_DHCPD_MAXLEASETIME
#endif
#ifndef CONFIG_NETUTILS_DHCPD_MINLEASETIME
# define CONFIG_NETUTILS_DHCPD_MINLEASETIME (60*60*24*1) /* 1 days */
#endif
#ifndef CONFIG_NETUTILS_DHCPD_MAXLEASETIME
# define CONFIG_NETUTILS_DHCPD_MAXLEASETIME (60*60*24*30) /* 30 days */
#endif
#ifndef CONFIG_NETUTILS_DHCPD_MAXLEASES
# define CONFIG_NETUTILS_DHCPD_MAXLEASES 16
#endif
#ifndef CONFIG_NETUTILS_DHCPD_STARTIP
# define CONFIG_NETUTILS_DHCPD_STARTIP (10L<<24|0L<<16|0L<<16|2L)
#endif
#undef CONFIG_NETUTILS_DHCP_OPTION_ENDIP
#define CONFIG_NETUTILS_DHCP_OPTION_ENDIP \
(CONFIG_NETUTILS_DHCPD_STARTIP + CONFIG_NETUTILS_DHCPD_MAXLEASES - 1)
#ifndef CONFIG_NETUTILS_DHCPD_OFFERTIME
# define CONFIG_NETUTILS_DHCPD_OFFERTIME (60*60) /* 1 hour */
#endif
#ifndef CONFIG_NETUTILS_DHCPD_DECLINETIME
# define CONFIG_NETUTILS_DHCPD_DECLINETIME (60*60) /* 1 hour */
#endif
#undef HAVE_ROUTERIP
#if defined(CONFIG_NETUTILS_DHCPD_ROUTERIP) && CONFIG_NETUTILS_DHCPD_ROUTERIP
# define HAVE_ROUTERIP 1
#endif
#undef HAVE_NETMASK
#if defined(CONFIG_NETUTILS_DHCPD_NETMASK) && CONFIG_NETUTILS_DHCPD_NETMASK
# define HAVE_NETMASK 1
#endif
#undef HAVE_DNSIP
#if defined(CONFIG_NETUTILS_DHCPD_DNSIP) && CONFIG_NETUTILS_DHCPD_DNSIP
# define HAVE_DNSIP 1
#endif
#undef HAVE_LEASE_TIME
#if defined(CONFIG_NETUTILS_DHCPD_HOST) || !defined(CONFIG_DISABLE_POSIX_TIMERS)
# define HAVE_LEASE_TIME 1
#endif
/****************************************************************************
* Private Types
****************************************************************************/
/* This structure describes one element in the lease table. There is one
* slot in the lease table for each assign-able IP address (hence, the IP
* address itself does not have to be in the table.
*/
struct lease_s
{
uint8_t mac[DHCP_HLEN_ETHERNET]; /* MAC address (network order) -- could be larger! */
bool allocated; /* true: IP address is allocated */
#ifdef HAVE_LEASE_TIME
time_t expiry; /* Lease expiration time (seconds past Epoch) */
#endif
};
struct dhcpmsg_s
{
uint8_t op;
uint8_t htype;
uint8_t hlen;
uint8_t hops;
uint8_t xid[4];
uint16_t secs;
uint16_t flags;
uint8_t ciaddr[4];
uint8_t yiaddr[4];
uint8_t siaddr[4];
uint8_t giaddr[4];
uint8_t chaddr[16];
#ifndef CONFIG_NET_DHCP_LIGHT
uint8_t sname[64];
uint8_t file[128];
#endif
uint8_t options[312];
};
/* This enumeration describes the state of the DHCPD daemon */
enum dhcpd_daemon_e
{
DHCPD_NOT_RUNNING = 0,
DHCPD_STARTED,
DHCPD_RUNNING,
DHCPD_STOP_REQUESTED,
DHCPD_STOPPED
};
struct dhcpd_state_s
{
/* Server configuration */
in_addr_t ds_serverip; /* The server IP address */
/* Message buffers */
struct dhcpmsg_s ds_inpacket; /* Holds the incoming DHCP client message */
struct dhcpmsg_s ds_outpacket; /* Holds the outgoing DHCP server message */
/* Parsed options from the incoming DHCP client message */
uint8_t ds_optmsgtype; /* Incoming DHCP message type */
in_addr_t ds_optreqip; /* Requested IP address (host order) */
in_addr_t ds_optserverip; /* Serverip IP address (host order) */
time_t ds_optleasetime; /* Requested lease time (host order) */
/* End option pointer for outgoing DHCP server message */
uint8_t *ds_optend;
/* Leases */
struct lease_s ds_leases[CONFIG_NETUTILS_DHCPD_MAXLEASES];
};
/* This type describes the state of the DHCPD client daemon. Only one
* instance of the DHCPD daemon is permitted in this implementation.
*/
struct dhcpd_daemon_s
{
uint8_t ds_state; /* See enum dhcpd_daemon_e */
sem_t ds_lock; /* Used to protect the whole structure */
sem_t ds_sync; /* Used to synchronize start and stop events */
pid_t ds_pid; /* Task ID of the DHCPD daemon */
};
/****************************************************************************
* Private Data
****************************************************************************/
static const uint8_t g_magiccookie[4] =
{
99, 130, 83, 99
};
static struct dhcpd_state_s g_state;
/* This type describes the state of the DHCPD client daemon. Only one
* instance of the DHCPD daemon is permitted in this implementation. This
* limitation is due only to this global data structure.
*/
static struct dhcpd_daemon_s g_dhcpd_daemon =
{
DHCPD_NOT_RUNNING,
SEM_INITIALIZER(1),
SEM_INITIALIZER(0),
-1
};
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: dhcpd_arpupdate
****************************************************************************/
#ifndef CONFIG_NETUTILS_DHCPD_IGNOREBROADCAST
# ifndef CONFIG_NETUTILS_DHCPD_HOST
static inline void dhcpd_arpupdate(FAR uint8_t *ipaddr, FAR uint8_t *hwaddr)
{
struct sockaddr_in inaddr;
/* Put the protocol address in a standard form. ipaddr is assumed to be in
* network order by the memcpy.
*/
inaddr.sin_family = AF_INET;
inaddr.sin_port = 0;
memcpy(&inaddr.sin_addr.s_addr, ipaddr, sizeof(in_addr_t));
/* Update the ARP table */
netlib_set_arpmapping(&inaddr, hwaddr, NULL);
}
# else
# define dhcpd_arpupdate(ipaddr,hwaddr)
# endif
#endif
/****************************************************************************
* Name: dhcpd_time
****************************************************************************/
#ifdef CONFIG_NETUTILS_DHCPD_HOST
# define dhcpd_time() time(0)
#elif defined(HAVE_LEASE_TIME)
static time_t dhcpd_time(void)
{
struct timespec ts;
time_t ret = 0;
if (clock_gettime(CLOCK_REALTIME, &ts) == OK)
{
ret = ts.tv_sec;
}
return ret;
}
#else
# define dhcpd_time() (0)
#endif
/****************************************************************************
* Name: dhcpd_leaseexpired
****************************************************************************/
#ifdef HAVE_LEASE_TIME
static inline bool dhcpd_leaseexpired(struct lease_s *lease)
{
if (lease->expiry > dhcpd_time())
{
return false;
}
else
{
memset(lease, 0, sizeof(struct lease_s));
return true;
}
}
#else
# define dhcpd_leaseexpired(lease) (false)
#endif
/****************************************************************************
* Name: dhcpd_setlease
****************************************************************************/
struct lease_s *dhcpd_setlease(const uint8_t *mac,
in_addr_t ipaddr, time_t expiry)
{
/* Calculate the offset from the first IP address managed by DHCPD.
* ipaddr must be in host order!
*/
int ndx = ipaddr - CONFIG_NETUTILS_DHCPD_STARTIP;
struct lease_s *ret = NULL;
ninfo("ipaddr: %08" PRIx32 " ipaddr: %08" PRIx32 " ndx: %d MAX: %d\n",
(uint32_t)ipaddr, (uint32_t)CONFIG_NETUTILS_DHCPD_STARTIP, ndx,
CONFIG_NETUTILS_DHCPD_MAXLEASES);
/* Verify that the address offset is within the supported range */
if (ndx >= 0 && ndx < CONFIG_NETUTILS_DHCPD_MAXLEASES)
{
ret = &g_state.ds_leases[ndx];
memcpy(ret->mac, mac, DHCP_HLEN_ETHERNET);
ret->allocated = true;
#ifdef HAVE_LEASE_TIME
ret->expiry = dhcpd_time() + expiry;
#endif
}
return ret;
}
/****************************************************************************
* Name: dhcp_leaseipaddr
****************************************************************************/
static inline in_addr_t dhcp_leaseipaddr(FAR struct lease_s *lease)
{
/* Return IP address in host order */
return (in_addr_t)(lease - g_state.ds_leases) +
CONFIG_NETUTILS_DHCPD_STARTIP;
}
/****************************************************************************
* Name: dhcpd_findbymac
****************************************************************************/
static FAR struct lease_s *dhcpd_findbymac(FAR const uint8_t *mac)
{
int i;
for (i = 0; i < CONFIG_NETUTILS_DHCPD_MAXLEASES; i++)
{
if (memcmp(g_state.ds_leases[i].mac, mac, DHCP_HLEN_ETHERNET) == 0)
{
return &(g_state.ds_leases[i]);
}
}
return NULL;
}
/****************************************************************************
* Name: dhcpd_findbyipaddr
****************************************************************************/
static FAR struct lease_s *dhcpd_findbyipaddr(in_addr_t ipaddr)
{
if (ipaddr >= CONFIG_NETUTILS_DHCPD_STARTIP &&
ipaddr <= CONFIG_NETUTILS_DHCP_OPTION_ENDIP)
{
FAR struct lease_s *lease =
&g_state.ds_leases[ipaddr - CONFIG_NETUTILS_DHCPD_STARTIP];
if (lease->allocated > 0)
{
return lease;
}
}
return NULL;
}
/****************************************************************************
* Name: dhcpd_allocipaddr
****************************************************************************/
static in_addr_t dhcpd_allocipaddr(void)
{
struct lease_s *lease = NULL;
in_addr_t ipaddr, startaddr;
ipaddr = startaddr = CONFIG_NETUTILS_DHCPD_STARTIP;
for (; ipaddr <= CONFIG_NETUTILS_DHCP_OPTION_ENDIP; ipaddr++)
{
/* Skip over address ending in 0 or 255 */
if ((ipaddr & 0xff) == 0 || (ipaddr & 0xff) == 0xff)
{
continue;
}
/* Is there already a lease on this address? If so, has it expired? */
lease = dhcpd_findbyipaddr(ipaddr);
if ((!lease || dhcpd_leaseexpired(lease)))
{
#ifdef CONFIG_CPP_HAVE_WARNING
# warning "FIXME: Should check if anything responds to an ARP request or ping"
# warning " to verify that there is no other user of this IP address"
#endif
memset(g_state.ds_leases[ipaddr - startaddr].mac,
0, DHCP_HLEN_ETHERNET);
g_state.ds_leases[ipaddr - startaddr].allocated = true;
#ifdef HAVE_LEASE_TIME
g_state.ds_leases[ipaddr - startaddr].expiry =
dhcpd_time() + CONFIG_NETUTILS_DHCPD_OFFERTIME;
#endif
/* Return the address in host order */
return ipaddr;
}
}
return 0;
}
/****************************************************************************
* Name: dhcpd_parseoptions
****************************************************************************/
static inline bool dhcpd_parseoptions(void)
{
uint32_t tmp;
uint8_t *ptr;
#ifndef CONFIG_NET_DHCP_LIGHT
uint8_t overloaded;
uint8_t currfield;
#endif
int optlen = 0;
int remaining;
/* Verify that the option field starts with a valid magic number */
ptr = g_state.ds_inpacket.options;
if (memcmp(ptr, g_magiccookie, 4) != 0)
{
/* Bad magic number... skip g_state.ds_outpacket */
nerr("ERROR: Bad magic: %d,%d,%d,%d\n",
ptr[0], ptr[1], ptr[2], ptr[3]);
return false;
}
/* Set up to parse the options */
ptr += 4;
remaining = DHCPD_OPTIONS_SIZE - 4;
#ifndef CONFIG_NET_DHCP_LIGHT
overloaded = DHCPD_OPTION_FIELD;
currfield = DHCPD_OPTION_FIELD;
#endif
/* Set all options to the default value */
g_state.ds_optmsgtype = 0; /* Incoming DHCP message type */
g_state.ds_optreqip = 0; /* Requested IP address (host order) */
g_state.ds_optserverip = 0; /* Serverip IP address (host order) */
g_state.ds_optleasetime = 0; /* Requested lease time (host order) */
g_state.ds_optend = NULL;
do
{
/* The form of an option is:
* code - 1 byte
* length - 1 byte
* data - variable number of bytes
*/
switch (ptr[DHCPD_OPTION_CODE])
{
/* Skip over any padding bytes */
case DHCP_OPTION_PAD:
optlen = 1;
break;
/* the Overload option is used to indicate that the DHCP 'sname'
* or 'file' fields are being overloaded by using them to carry
* DHCP options. A DHCP server inserts this option if the
* returned parameters will exceed the usual space allotted for
* options.
*
* If this option is present, the client interprets the specified
* additional fields after it concludes interpretation of the
* standard option fields.
*
* Legal values for this option are:
*
* 1 the 'file' field is used to hold options
* 2 the 'sname' field is used to hold options
* 3 both fields are used to hold options
*/
#ifndef CONFIG_NET_DHCP_LIGHT
case DHCP_OPTION_OVERLOAD:
optlen = ptr[DHCPD_OPTION_LENGTH] + 2;
if (optlen >= 3 && optlen < remaining)
{
overloaded = ptr[DHCPD_OPTION_DATA];
}
break;
#endif
case DHCP_OPTION_END:
#ifndef CONFIG_NET_DHCP_LIGHT
if (currfield == DHCPD_OPTION_FIELD &&
(overloaded & DHCPD_FILE_FIELD) != 0)
{
ptr = g_state.ds_inpacket.file;
remaining = sizeof(g_state.ds_inpacket.file);
currfield = DHCPD_FILE_FIELD;
}
else if (currfield == DHCPD_FILE_FIELD &&
(overloaded & DHCPD_SNAME_FIELD) != 0)
{
ptr = g_state.ds_inpacket.sname;
remaining = sizeof(g_state.ds_inpacket.sname);
currfield = DHCPD_SNAME_FIELD;
}
else
{
return true;
}
break;
#else
return true;
#endif
case DHCP_OPTION_REQ_IPADDR: /* Requested IP Address */
optlen = ptr[DHCPD_OPTION_LENGTH] + 2;
if (optlen >= 6 && optlen < remaining)
{
memcpy(&tmp, &ptr[DHCPD_OPTION_DATA], 4);
g_state.ds_optreqip = (in_addr_t)ntohl(tmp);
}
break;
case DHCP_OPTION_LEASE_TIME: /* IP address lease time */
optlen = ptr[DHCPD_OPTION_LENGTH] + 2;
if (optlen >= 6 && optlen < remaining)
{
memcpy(&tmp, &ptr[DHCPD_OPTION_DATA], 4);
g_state.ds_optleasetime = (time_t)ntohl(tmp);
}
break;
case DHCP_OPTION_MSG_TYPE: /* DHCP message type */
optlen = ptr[DHCPD_OPTION_LENGTH] + 2;
if (optlen >= 3 && optlen < remaining)
{
g_state.ds_optmsgtype = ptr[DHCPD_OPTION_DATA];
}
break;
case DHCP_OPTION_SERVER_ID: /* Server identifier */
optlen = ptr[DHCPD_OPTION_LENGTH] + 2;
if (optlen >= 6 && optlen < remaining)
{
memcpy(&tmp, &ptr[DHCPD_OPTION_DATA], 4);
g_state.ds_optserverip = (in_addr_t)ntohl(tmp);
}
break;
default:
/* Skip over unsupported options */
optlen = ptr[DHCPD_OPTION_LENGTH] + 2;
break;
}
/* Advance to the next option */
ptr += optlen;
remaining -= optlen;
}
while (remaining > 0);
return false;
}
/****************************************************************************
* Name: dhcpd_verifyreqip
****************************************************************************/
static inline bool dhcpd_verifyreqip(void)
{
struct lease_s *lease;
/* Verify that the requested IP address is within the supported lease
* range
*/
if (g_state.ds_optreqip >= CONFIG_NETUTILS_DHCPD_STARTIP &&
g_state.ds_optreqip <= CONFIG_NETUTILS_DHCP_OPTION_ENDIP)
{
/* And verify that the lease has not already been taken or offered
* (unless the lease/offer is expired, then the address is free game).
*/
lease = dhcpd_findbyipaddr(g_state.ds_optreqip);
if (!lease || dhcpd_leaseexpired(lease))
{
return true;
}
}
return false;
}
/****************************************************************************
* Name: dhcpd_verifyreqleasetime
****************************************************************************/
static inline bool dhcpd_verifyreqleasetime(uint32_t *leasetime)
{
uint32_t tmp = g_state.ds_optleasetime;
/* Did the client request a specific lease time? */
if (tmp != 0)
{
/* Yes.. Verify that the requested lease time is within a
* valid range
*/
if (tmp > CONFIG_NETUTILS_DHCPD_MAXLEASETIME)
{
tmp = CONFIG_NETUTILS_DHCPD_MAXLEASETIME;
}
else if (tmp < CONFIG_NETUTILS_DHCPD_MINLEASETIME)
{
tmp = CONFIG_NETUTILS_DHCPD_MINLEASETIME;
}
/* Return the clipped lease time */
*leasetime = tmp;
return true;
}
return false;
}
/****************************************************************************
* Name: dhcpd_addoption
****************************************************************************/
static int dhcpd_addoption(uint8_t *option)
{
int offset;
int len = 4;
if (g_state.ds_optend)
{
offset = g_state.ds_optend - g_state.ds_outpacket.options;
len = option[DHCPD_OPTION_LENGTH] + 2;
/* Check if the option will fit into the options array */
if (offset + len + 1 < DHCPD_OPTIONS_SIZE)
{
/* Copy the option into the option array */
memcpy(g_state.ds_optend, option, len);
g_state.ds_optend += len;
*g_state.ds_optend = DHCP_OPTION_END;
}
}
return len;
}
/****************************************************************************
* Name: dhcpd_addoption8
****************************************************************************/
static int dhcpd_addoption8(uint8_t code, uint8_t value)
{
uint8_t option[3];
/* Construct the option sequence */
option[DHCPD_OPTION_CODE] = code;
option[DHCPD_OPTION_LENGTH] = 1;
option[DHCPD_OPTION_DATA] = value;
/* Add the option sequence to the response */
return dhcpd_addoption(option);
}
/****************************************************************************
* Name: dhcpd_addoption32
****************************************************************************/
static int dhcpd_addoption32(uint8_t code, uint32_t value)
{
uint8_t option[6];
/* Construct the option sequence */
option[DHCPD_OPTION_CODE] = code;
option[DHCPD_OPTION_LENGTH] = 4;
memcpy(&option[DHCPD_OPTION_DATA], &value, 4);
/* Add the option sequence to the response */
return dhcpd_addoption(option);
}
/****************************************************************************
* Name: dhcp_addoption32p
****************************************************************************/
#ifdef HAVE_DNSIP
static int dhcp_addoption32p(uint8_t code, FAR uint8_t *value)
{
uint8_t option[6];
/* Construct the option sequence */
option[DHCPD_OPTION_CODE] = code;
option[DHCPD_OPTION_LENGTH] = 4;
memcpy(&option[DHCPD_OPTION_DATA], value, 4);
/* Add the option sequence to the response */
return dhcpd_addoption(option);
}
#endif
/****************************************************************************
* Name: dhcpd_socket
****************************************************************************/
static inline int dhcpd_socket(FAR const char *interface)
{
int sockfd;
#if defined(HAVE_SO_REUSEADDR) || defined(HAVE_SO_BROADCAST)
int optval;
int ret;
#endif
/* Create a socket to listen for requests from DHCP clients */
sockfd = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
if (sockfd < 0)
{
nerr("ERROR: socket failed: %d\n", errno);
return ERROR;
}
/* Configure the socket */
#ifdef HAVE_SO_REUSEADDR
optval = 1;
ret = setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (FAR void *)&optval,
sizeof(int));
if (ret < 0)
{
nerr("ERROR: setsockopt SO_REUSEADDR failed: %d\n", errno);
close(sockfd);
return ERROR;
}
#endif
#ifdef HAVE_SO_BROADCAST
optval = 1;
ret = setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, (FAR void *)&optval,
sizeof(int));
if (ret < 0)
{
nerr("ERROR: setsockopt SO_BROADCAST failed: %d\n", errno);
close(sockfd);
return ERROR;
}
#endif
#ifdef CONFIG_NET_BINDTODEVICE
/* Bind socket to interface, because UDP packets have to be sent to the
* broadcast address at a moment when it is not possible to decide the
* target network device using the local or remote address (which is,
* by definition and purpose of DHCP, undefined yet).
*/
if (setsockopt(sockfd, SOL_SOCKET, SO_BINDTODEVICE,
interface, strlen(interface)) < 0)
{
ninfo("ERROR: setsockopt SO_BINDTODEVICE failed: %d\n", errno);
close(sockfd);
return ERROR;
}
#endif
return sockfd;
}
/****************************************************************************
* Name: dhcpd_initpacket
****************************************************************************/
static void dhcpd_initpacket(uint8_t mtype)
{
uint32_t nulladdr = 0;
/* Set up the generic parts of the DHCP server message */
memset(&g_state.ds_outpacket, 0, sizeof(struct dhcpmsg_s));
g_state.ds_outpacket.op = DHCP_REPLY;
g_state.ds_outpacket.htype = g_state.ds_inpacket.htype;
g_state.ds_outpacket.hlen = g_state.ds_inpacket.hlen;
memcpy(&g_state.ds_outpacket.xid, &g_state.ds_inpacket.xid, 4);
memcpy(g_state.ds_outpacket.chaddr, g_state.ds_inpacket.chaddr, 16);
if (memcmp(g_state.ds_outpacket.giaddr, &nulladdr, 4) != 0)
{
g_state.ds_outpacket.flags = g_state.ds_inpacket.flags;
}
/* Add the generic options */
memcpy(g_state.ds_outpacket.options, g_magiccookie, 4);
g_state.ds_optend = &g_state.ds_outpacket.options[4];
*g_state.ds_optend = DHCP_OPTION_END;
dhcpd_addoption8(DHCP_OPTION_MSG_TYPE, mtype);
dhcpd_addoption32(DHCP_OPTION_SERVER_ID, g_state.ds_serverip);
}
/****************************************************************************
* Name: dhcpd_sendpacket
****************************************************************************/
static int dhcpd_sendpacket(int sockfd, int bbroadcast)
{
struct sockaddr_in addr;
in_addr_t ipaddr;
int len;
#ifdef CONFIG_NETUTILS_DHCPD_IGNOREBROADCAST
/* This is a hack. I've had problems with Windows machines responding
* to unicast. I think this is associated with a Windows registry key in
* HKEY_LOCAL_MACHINE\
* SYSTEM\CurrentControlSet\Services\DHCPServer\Parameters:
* The IgnoreBroadcastFlag value controls this behavior: A value of 1 will
* cause the server to ignore the client broadcast flag and always respond
* with multicast; the value 0 to allows clients to request unicast.
*/
ipaddr = INADDR_BROADCAST;
#else
const uint8_t anyipaddr[4] =
{
};
/* Determine which address to respond to (or if we need to broadcast the
* response)
*
* (1) If he caller know that it needs to multicast the response, it will
* set broadcast.
* (2) Otherwise, if the client already has and address (ciaddr), then use
* that for unicast
* (3) Broadcast if the client says it can't handle uni-cast
* (BOOTP_BROADCAST set)
* (4) Otherwise, the client claims it can handle the uni-casst response
* and we will uni-cast to the offered address (yiaddr).
*
* NOTE: We really should also check the giaddr field. If no zero, the
* server should send any return messages to the 'DHCP server' port on the
* BOOTP relay agent whose address appears in 'giaddr'.
*/
if (bbroadcast)
{
ipaddr = INADDR_BROADCAST;
}
else if (memcmp(g_state.ds_outpacket.ciaddr, anyipaddr, 4) != 0)
{
dhcpd_arpupdate(g_state.ds_outpacket.ciaddr,
g_state.ds_outpacket.chaddr);
memcpy(&ipaddr, g_state.ds_outpacket.ciaddr, 4);
}
else if (g_state.ds_outpacket.flags & HTONS(BOOTP_BROADCAST))
{
ipaddr = INADDR_BROADCAST;
}
else
{
dhcpd_arpupdate(g_state.ds_outpacket.yiaddr,
g_state.ds_outpacket.chaddr);
memcpy(&ipaddr, g_state.ds_outpacket.yiaddr, 4);
}
#endif
/* Create a socket to respond with a packet to the client. We
* cannot re-use the listener socket because it is not bound correctly
*/
/* Then send the response to the DHCP client port at that address */
memset(&addr, 0, sizeof(struct sockaddr_in));
addr.sin_family = AF_INET;
addr.sin_port = HTONS(DHCP_CLIENT_PORT);
addr.sin_addr.s_addr = ipaddr;
/* Send the minimum sized packet that includes the END option */
len = (g_state.ds_optend - (FAR uint8_t *)&g_state.ds_outpacket) + 1;
ninfo("sendto %08lx:%04x len=%d\n",
(long)ntohl(addr.sin_addr.s_addr), ntohs(addr.sin_port), len);
return sendto(sockfd, &g_state.ds_outpacket, len, 0,
(struct sockaddr *)&addr, sizeof(struct sockaddr_in));
}
/****************************************************************************
* Name: dhcpd_sendoffer
****************************************************************************/
static inline int dhcpd_sendoffer(int sockfd, in_addr_t ipaddr,
uint32_t leasetime)
{
in_addr_t netaddr;
#ifdef HAVE_DNSIP
uint32_t dnsaddr;
dnsaddr = htonl(CONFIG_NETUTILS_DHCPD_DNSIP);
#endif
/* IP address is in host order */
ninfo("Sending offer: %08lx\n", (long)ipaddr);
/* Initialize the outgoing packet */
dhcpd_initpacket(DHCPOFFER);
/* Add the address offered to the client (converting to network order) */
netaddr = htonl(ipaddr);
memcpy(g_state.ds_outpacket.yiaddr, &netaddr, 4);
/* Add the leasetime to the response options */
dhcpd_addoption32(DHCP_OPTION_LEASE_TIME, htonl(leasetime));
#ifdef HAVE_NETMASK
dhcpd_addoption32(DHCP_OPTION_SUBNET_MASK,
htonl(CONFIG_NETUTILS_DHCPD_NETMASK));
#endif
#ifdef HAVE_ROUTERIP
dhcpd_addoption32(DHCP_OPTION_ROUTER,
htonl(CONFIG_NETUTILS_DHCPD_ROUTERIP));
#endif
#ifdef HAVE_DNSIP
dhcp_addoption32p(DHCP_OPTION_DNS_SERVER, (FAR uint8_t *)&dnsaddr);
#endif
/* Send the offer response */
#ifdef CONFIG_NETUTILS_DHCPD_IGNOREBROADCAST
return dhcpd_sendpacket(sockfd, true);
#else
return dhcpd_sendpacket(sockfd, false);
#endif
}
/****************************************************************************
* Name: dhcpd_sendnak
****************************************************************************/
static int dhcpd_sendnak(int sockfd)
{
/* Initialize and send the NAK response */
dhcpd_initpacket(DHCPNAK);
memcpy(g_state.ds_outpacket.ciaddr, g_state.ds_inpacket.ciaddr, 4);
return dhcpd_sendpacket(sockfd, true);
}
/****************************************************************************
* Name: dhcpd_sendack
****************************************************************************/
int dhcpd_sendack(int sockfd, in_addr_t ipaddr)
{
uint32_t leasetime = CONFIG_NETUTILS_DHCPD_LEASETIME;
in_addr_t netaddr;
#ifdef HAVE_DNSIP
uint32_t dnsaddr;
dnsaddr = htonl(CONFIG_NETUTILS_DHCPD_DNSIP);
#endif
/* Initialize the ACK response */
dhcpd_initpacket(DHCPACK);
memcpy(g_state.ds_outpacket.ciaddr, g_state.ds_inpacket.ciaddr, 4);
/* Add the IP address assigned to the client */
netaddr = htonl(ipaddr);
memcpy(g_state.ds_outpacket.yiaddr, &netaddr, 4);
/* Did the client request a specific lease time? */
dhcpd_verifyreqleasetime(&leasetime);
/* Add the lease time to the response */
dhcpd_addoption32(DHCP_OPTION_LEASE_TIME, htonl(leasetime));
#ifdef HAVE_NETMASK
dhcpd_addoption32(DHCP_OPTION_SUBNET_MASK,
htonl(CONFIG_NETUTILS_DHCPD_NETMASK));
#endif
#ifdef HAVE_ROUTERIP
dhcpd_addoption32(DHCP_OPTION_ROUTER,
htonl(CONFIG_NETUTILS_DHCPD_ROUTERIP));
#endif
#ifdef HAVE_DNSIP
dhcp_addoption32p(DHCP_OPTION_DNS_SERVER, (FAR uint8_t *)&dnsaddr);
#endif
#ifdef CONFIG_NETUTILS_DHCPD_IGNOREBROADCAST
if (dhcpd_sendpacket(sockfd, true) < 0)
#else
if (dhcpd_sendpacket(sockfd, false) < 0)
#endif
{
return ERROR;
}
dhcpd_setlease(g_state.ds_inpacket.chaddr, ipaddr, leasetime);
return OK;
}
/****************************************************************************
* Name: dhcpd_discover
****************************************************************************/
static inline int dhcpd_discover(int sockfd)
{
struct lease_s *lease;
in_addr_t ipaddr;
uint32_t leasetime = CONFIG_NETUTILS_DHCPD_LEASETIME;
/* Check if the client is already in the lease table */
lease = dhcpd_findbymac(g_state.ds_inpacket.chaddr);
if (lease)
{
/* Yes... get the remaining time on the lease */
#ifdef HAVE_LEASE_TIME
if (!dhcpd_leaseexpired(lease))
{
leasetime = lease->expiry - dhcpd_time();
if (leasetime < CONFIG_NETUTILS_DHCPD_MINLEASETIME)
{
leasetime = CONFIG_NETUTILS_DHCPD_MINLEASETIME;
}
}
#endif
/* Get the IP address associated with the lease (host order) */
ipaddr = dhcp_leaseipaddr(lease);
ninfo("Already have lease for IP %08lx\n", (long)ipaddr);
}
/* Check if the client has requested a specific IP address */
else if (dhcpd_verifyreqip())
{
/* Use the requested IP address (host order) */
ipaddr = g_state.ds_optreqip;
ninfo("User requested IP %08lx\n", (long)ipaddr);
}
else
{
/* No... allocate a new IP address (host order) */
ipaddr = dhcpd_allocipaddr();
ninfo("Allocated IP %08lx\n", (long)ipaddr);
}
/* Did we get any IP address? */
if (!ipaddr)
{
/* Nope... return failure */
nerr("ERROR: Failed to get IP address\n");
return ERROR;
}
/* Reserve the leased IP for a shorter time for the offer */
if (!dhcpd_setlease(g_state.ds_inpacket.chaddr, ipaddr,
CONFIG_NETUTILS_DHCPD_OFFERTIME))
{
nerr("ERROR: Failed to set lease\n");
return ERROR;
}
/* Check if the client has requested a specific lease time */
dhcpd_verifyreqleasetime(&leasetime);
/* Send the offer response */
return dhcpd_sendoffer(sockfd, ipaddr, leasetime);
}
/****************************************************************************
* Name: dhcpd_request
****************************************************************************/
static inline int dhcpd_request(int sockfd)
{
struct lease_s *lease;
in_addr_t ipaddr = 0;
uint8_t response = 0;
/* Check if this client already holds a lease. This can happen when the
* client (1) the IP is reserved for the client from a previous offer,
* or (2) the client is re-initializing or rebooting while the lease is
* still valid.
*/
lease = dhcpd_findbymac(g_state.ds_inpacket.chaddr);
if (lease)
{
/* Yes.. the client already holds a lease. Verify that the request is
* consistent* with the existing lease (host order).
*/
ipaddr = dhcp_leaseipaddr(lease);
ninfo("Lease ipaddr: %08" PRIx32 " Server IP: %08" PRIx32
" Requested IP: %08" PRIx32 "\n",
(uint32_t)ipaddr,
(uint32_t)g_state.ds_optserverip,
(uint32_t)g_state.ds_optreqip);
if (g_state.ds_optserverip)
{
/* ACK if the serverip is correct and the requested IP address is
* the one already offered to the client.
*/
if (g_state.ds_optserverip == ntohl(g_state.ds_serverip) &&
(g_state.ds_optreqip != 0 || g_state.ds_optreqip == ipaddr))
{
response = DHCPACK;
}
else
{
response = DHCPNAK;
}
}
/* We have the lease and no server IP was requested. Was a specific IP
* address requested? (host order)
*/
else if (g_state.ds_optreqip)
{
/* Yes..ACK if the requested IP address is the one already leased.
* Both addresses are in host order.
*/
if (ipaddr == g_state.ds_optreqip)
{
response = DHCPACK;
}
else
{
response = DHCPNAK;
}
}
/* The client has specified neither a server IP nor requested
* IP address
*/
else
{
/* ACK if the IP used by the client is the one already assigned
* to it. NOTE ipaddr is in host order; ciaddr is network order!
*/
uint32_t tmp = htonl(ipaddr);
if (memcmp(&tmp, g_state.ds_inpacket.ciaddr, 4) == 0)
{
response = DHCPACK;
}
else
{
response = DHCPNAK;
}
}
}
/* The client does not hold a lease (referenced by its MAC address) and is
* requesting a specific IP address that was, apparently, never offered to
* to the client. Perform some sanity checks before sending the NAK.
*/
else if (g_state.ds_optreqip && !g_state.ds_optserverip)
{
ninfo("Server IP: %08" PRIx32 " Requested IP: %08" PRIx32 "\n",
(uint32_t)g_state.ds_optserverip,
(uint32_t)g_state.ds_optreqip);
/* Is this IP address already assigned? */
lease = dhcpd_findbyipaddr(g_state.ds_optreqip);
if (lease)
{
/* Yes.. Send NAK unless the lease has expired */
if (!dhcpd_leaseexpired(lease))
{
response = DHCPNAK;
}
}
/* DHCPREQUEST without DHCPDISCOVER:
* The request IP address is in the range but has not been leased,
* maybe requested before the last shutdown, lease again.
*/
else if (g_state.ds_optreqip >= CONFIG_NETUTILS_DHCPD_STARTIP &&
g_state.ds_optreqip <= CONFIG_NETUTILS_DHCP_OPTION_ENDIP)
{
ipaddr = g_state.ds_optreqip;
response = DHCPACK;
}
/* The requested IP address out of range, negative */
else
{
response = DHCPNAK;
}
}
/* Otherwise, the client does not hold a lease and is not requesting any
* specific IP address.
*/
/* Finally, either (1) send the ACK, (2) send a NAK, or (3) remain silent
* based on the checks above.
*/
if (response == DHCPACK)
{
ninfo("ACK IP %08lx\n", (long)ipaddr);
dhcpd_sendack(sockfd, ipaddr);
}
else if (response == DHCPNAK)
{
ninfo("NAK IP %08lx\n", (long)ipaddr);
dhcpd_sendnak(sockfd);
}
else
{
ninfo("Remaining silent IP %08lx\n", (long)ipaddr);
}
return OK;
}
/****************************************************************************
* Name: dhcpd_decline
****************************************************************************/
static inline int dhcpd_decline(void)
{
struct lease_s *lease;
/* Find the lease associated with this hardware address */
lease = dhcpd_findbymac(g_state.ds_inpacket.chaddr);
if (lease)
{
/* Disassociate the IP from the MAC, but prevent re-used of this
* address for a period of time.
*/
memset(lease->mac, 0, DHCP_HLEN_ETHERNET);
#ifdef HAVE_LEASE_TIME
lease->expiry = dhcpd_time() + CONFIG_NETUTILS_DHCPD_DECLINETIME;
#endif
}
return OK;
}
static inline int dhcpd_release(void)
{
struct lease_s *lease;
/* Find the lease associated with this hardware address */
lease = dhcpd_findbymac(g_state.ds_inpacket.chaddr);
if (lease)
{
/* Release the IP address now */
memset(lease, 0, sizeof(struct lease_s));
}
return OK;
}
/****************************************************************************
* Name: dhcpd_openlistener
****************************************************************************/
static inline int dhcpd_openlistener(FAR const char *interface)
{
struct sockaddr_in addr;
struct ifreq req;
int sockfd;
int ret;
/* Create a socket to listen for requests from DHCP clients */
sockfd = dhcpd_socket(interface);
if (sockfd < 0)
{
nerr("ERROR: socket failed: %d\n", errno);
return ERROR;
}
/* Get the IP address of the selected device */
strlcpy(req.ifr_name, interface, IFNAMSIZ);
ret = ioctl(sockfd, SIOCGIFADDR, (unsigned long)&req);
if (ret < 0)
{
nerr("ERROR: setsockopt SIOCGIFADDR failed: %d\n", errno);
close(sockfd);
return ERROR;
}
g_state.ds_serverip = ((FAR struct sockaddr_in *)
&req.ifr_addr)->sin_addr.s_addr;
ninfo("serverip: %08" PRIx32 "\n", ntohl(g_state.ds_serverip));
/* Bind the socket to a local port. We have to bind to INADDRY_ANY to
* receive broadcast messages.
*/
addr.sin_family = AF_INET;
addr.sin_port = htons(DHCP_SERVER_PORT);
addr.sin_addr.s_addr = INADDR_ANY;
ret = bind(sockfd, (struct sockaddr *)&addr, sizeof(struct sockaddr_in));
if (ret < 0)
{
nerr("ERROR: bind failed, port=%d addr=%08lx: %d\n",
addr.sin_port, (long)addr.sin_addr.s_addr, errno);
close(sockfd);
return ERROR;
}
return sockfd;
}
/****************************************************************************
* Name: dhcpd_task_run
****************************************************************************/
static int dhcpd_task_run(int argc, char **argv)
{
return dhcpd_run(argv[1]);
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: dhcpd_run
****************************************************************************/
int dhcpd_run(FAR const char *interface)
{
int sockfd;
int nbytes;
ninfo("Started\n");
/* Exit if the dhcpd is already executed */
if (g_dhcpd_daemon.ds_state == DHCPD_RUNNING)
{
return OK;
}
/* Update the pid if running in daemon mode */
g_dhcpd_daemon.ds_pid = getpid();
/* Indicate that we have started */
g_dhcpd_daemon.ds_state = DHCPD_RUNNING;
sem_post(&g_dhcpd_daemon.ds_sync);
/* Initialize everything to zero */
memset(&g_state, 0, sizeof(struct dhcpd_state_s));
/* Now loop indefinitely, reading packets from the DHCP server socket */
sockfd = -1;
while (g_dhcpd_daemon.ds_state != DHCPD_STOP_REQUESTED)
{
/* Create a socket to listen for requests from DHCP clients */
if (sockfd < 0)
{
sockfd = dhcpd_openlistener(interface);
if (sockfd < 0)
{
nerr("ERROR: Failed to create socket\n");
break;
}
}
/* Read the next g_state.ds_outpacket */
nbytes = recv(sockfd, &g_state.ds_inpacket,
sizeof(struct dhcpmsg_s), 0);
if (nbytes < 0)
{
/* On errors (other EINTR), close the socket and try again */
nerr("ERROR: recv failed: %d\n", errno);
if (errno != EINTR && errno != EAGAIN)
{
close(sockfd);
sockfd = -1;
}
continue;
}
/* Parse the incoming message options */
if (!dhcpd_parseoptions())
{
/* Failed to parse the message options */
nerr("ERROR: No msg type\n");
continue;
}
#ifdef CONFIG_NETUTILS_DHCPD_HOST
/* Get the poor little uC a change to get its recvfrom in place */
usleep(500 * 1000);
#endif
/* Now process the incoming DHCP message by its message type */
switch (g_state.ds_optmsgtype)
{
case DHCPDISCOVER:
ninfo("DHCPDISCOVER\n");
dhcpd_discover(sockfd);
break;
case DHCPREQUEST:
ninfo("DHCPREQUEST\n");
dhcpd_request(sockfd);
break;
case DHCPDECLINE:
ninfo("DHCPDECLINE\n");
dhcpd_decline();
break;
case DHCPRELEASE:
ninfo("DHCPRELEASE\n");
dhcpd_release();
break;
case DHCPINFORM: /* Not supported */
default:
nerr("ERROR: Unsupported message type: %d\n",
g_state.ds_optmsgtype);
break;
}
}
g_dhcpd_daemon.ds_pid = -1;
g_dhcpd_daemon.ds_state = DHCPD_STOPPED;
sem_post(&g_dhcpd_daemon.ds_sync);
return OK;
}
/****************************************************************************
* Name: dhcpd_start
*
* Description:
* Start the DHCPD daemon
*
* Returned Value:
* On success, the non-negative task ID of the DHCPDC daemon is returned;
* On failure, a negated errno value is returned.
*
****************************************************************************/
int dhcpd_start(FAR const char *interface)
{
FAR char *argv[2];
int pid;
argv[0] = (char *)interface;
argv[1] = NULL;
/* Is the DHCPD in a non-running state? */
sem_wait(&g_dhcpd_daemon.ds_lock);
if (g_dhcpd_daemon.ds_state == DHCPD_NOT_RUNNING ||
g_dhcpd_daemon.ds_state == DHCPD_STOPPED)
{
/* Start the DHCPD daemon */
g_dhcpd_daemon.ds_state = DHCPD_STARTED;
pid =
task_create("DHCPD daemon", CONFIG_NETUTILS_DHCPD_PRIORITY,
CONFIG_NETUTILS_DHCPD_STACKSIZE, dhcpd_task_run,
argv);
/* Handle failures to start the DHCPD daemon */
if (pid < 0)
{
int errval = errno;
g_dhcpd_daemon.ds_state = DHCPD_STOPPED;
nerr("ERROR: Failed to start the DHCPD daemon: %d\n", errval);
sem_post(&g_dhcpd_daemon.ds_lock);
return -errval;
}
/* Wait for any daemon state change */
do
{
sem_wait(&g_dhcpd_daemon.ds_sync);
}
while (g_dhcpd_daemon.ds_state == DHCPD_STARTED);
}
sem_post(&g_dhcpd_daemon.ds_lock);
return OK;
}
/****************************************************************************
* Name: dhcpd_stop
*
* Description:
* Stop the DHCPD daemon
*
* Returned Value:
* Zero on success; a negated errno value on failure. The current
* implementation only returns success.
*
****************************************************************************/
int dhcpd_stop(void)
{
int ret;
/* Is the DHCPD in a running state? */
sem_wait(&g_dhcpd_daemon.ds_lock);
if (g_dhcpd_daemon.ds_state == DHCPD_STARTED ||
g_dhcpd_daemon.ds_state == DHCPD_RUNNING)
{
/* Yes.. request that the daemon stop. */
g_dhcpd_daemon.ds_state = DHCPD_STOP_REQUESTED;
/* Wait for any daemon state change */
do
{
/* Signal the DHCPD client */
ret = kill(g_dhcpd_daemon.ds_pid,
CONFIG_NETUTILS_DHCPD_SIGWAKEUP);
if (ret < 0)
{
nerr("ERROR: kill pid %d failed: %d\n",
g_dhcpd_daemon.ds_pid, errno);
break;
}
/* Wait for the DHCPD client to respond to the stop request */
sem_wait(&g_dhcpd_daemon.ds_sync);
}
while (g_dhcpd_daemon.ds_state == DHCPD_STOP_REQUESTED);
}
sem_post(&g_dhcpd_daemon.ds_lock);
return OK;
}