contrib/wrt/dhcp_release.c - thekelleys/dnsmasq - Gitiles

 /* Copyright (c) 2006 Simon Kelley

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; version 2 dated June, 1991.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 */

 /* dhcp_release <interface> <address> <MAC address> <client_id>
    MUST be run as root - will fail otherwise. */

 /* Send a DHCPRELEASE message via the specified interface
    to tell the local DHCP server to delete a particular lease.

    The interface argument is the interface in which a DHCP
    request _would_ be received if it was coming from the client,
    rather than being faked up here.

    The address argument is a dotted-quad IP addresses and mandatory.

    The MAC address is colon separated hex, and is mandatory. It may be
    prefixed by an address-type byte followed by -, eg

    10-11:22:33:44:55:66

    but if the address-type byte is missing it is assumed to be 1, the type
    for ethernet. This encoding is the one used in dnsmasq lease files.

    The client-id is optional. If it is "*" then it treated as being missing.
 */

 #include <sys/types.h>
 #include <netinet/in.h>
 #include <net/if.h>
 #include <arpa/inet.h>
 #include <sys/socket.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <net/if_arp.h>
 #include <sys/ioctl.h>
 #include <linux/types.h>
 #include <linux/netlink.h>
 #include <linux/rtnetlink.h>
 #include <errno.h>

 #define DHCP_CHADDR_MAX          16
 #define BOOTREQUEST              1
 #define DHCP_COOKIE              0x63825363
 #define OPTION_SERVER_IDENTIFIER 54
 #define OPTION_CLIENT_ID         61
 #define OPTION_MESSAGE_TYPE      53
 #define OPTION_END               255
 #define DHCPRELEASE              7
 #define DHCP_SERVER_PORT         67

 typedef unsigned char u8;
 typedef unsigned short u16;
 typedef unsigned int u32;

 struct dhcp_packet {
   u8 op, htype, hlen, hops;
   u32 xid;
   u16 secs, flags;
   struct in_addr ciaddr, yiaddr, siaddr, giaddr;
   u8 chaddr[DHCP_CHADDR_MAX], sname[64], file[128];
   u32 cookie;
   unsigned char options[308];
 };

 static struct iovec iov;

 static int expand_buf(struct iovec *iov, size_t size)
 {
   void *new;

   if (size <= iov->iov_len)
     return 1;

   if (!(new = malloc(size)))
     {
       errno = ENOMEM;
       return 0;
     }

   if (iov->iov_base)
     {
       memcpy(new, iov->iov_base, iov->iov_len);
       free(iov->iov_base);
     }

   iov->iov_base = new;
   iov->iov_len = size;

   return 1;
 }

 static ssize_t netlink_recv(int fd)
 {
   struct msghdr msg;
   ssize_t rc;

   msg.msg_control = NULL;
   msg.msg_controllen = 0;
   msg.msg_name = NULL;
   msg.msg_namelen = 0;
   msg.msg_iov = &iov;
   msg.msg_iovlen = 1;

   while (1)
     {
       msg.msg_flags = 0;
       while ((rc = recvmsg(fd, &msg, MSG_PEEK)) == -1 && errno == EINTR);

       /* 2.2.x doesn't suport MSG_PEEK at all, returning EOPNOTSUPP, so we just grab a
          big buffer and pray in that case. */
       if (rc == -1 && errno == EOPNOTSUPP)
         {
           if (!expand_buf(&iov, 2000))
             return -1;
           break;
         }

       if (rc == -1 || !(msg.msg_flags & MSG_TRUNC))
         break;

       if (!expand_buf(&iov, iov.iov_len + 100))
         return -1;
     }

   /* finally, read it for real */
   while ((rc = recvmsg(fd, &msg, 0)) == -1 && errno == EINTR);

   return rc;
 }

 static int parse_hex(char *in, unsigned char *out, int maxlen, int *mac_type)
 {
   int i = 0;
   char *r;

   if (mac_type)
     *mac_type = 0;

   while (maxlen == -1 || i < maxlen)
     {
       for (r = in; *r != 0 && *r != ':' && *r != '-'; r++);
       if (*r == 0)
         maxlen = i;

       if (r != in )
         {
           if (*r == '-' && i == 0 && mac_type)
            {
               *r = 0;
               *mac_type = strtol(in, NULL, 16);
               mac_type = NULL;
            }
           else
             {
               *r = 0;
 	      out[i] = strtol(in, NULL, 16);
               i++;
             }
         }
       in = r+1;
     }
     return i;
 }

 static int is_same_net(struct in_addr a, struct in_addr b, struct in_addr mask)
 {
   return (a.s_addr & mask.s_addr) == (b.s_addr & mask.s_addr);
 }

 static struct in_addr find_interface(struct in_addr client, int fd, unsigned int index)
 {
   struct sockaddr_nl addr;
   struct nlmsghdr *h;
   ssize_t len;

   struct {
     struct nlmsghdr nlh;
     struct rtgenmsg g;
   } req;

   addr.nl_family = AF_NETLINK;
   addr.nl_pad = 0;
   addr.nl_groups = 0;
   addr.nl_pid = 0; /* address to kernel */

   req.nlh.nlmsg_len = sizeof(req);
   req.nlh.nlmsg_type = RTM_GETADDR;
   req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST | NLM_F_ACK;
   req.nlh.nlmsg_pid = 0;
   req.nlh.nlmsg_seq = 1;
   req.g.rtgen_family = AF_INET;

   if (sendto(fd, (void *)&req, sizeof(req), 0,
 	     (struct sockaddr *)&addr, sizeof(addr)) == -1)
     {
       perror("sendto failed");
       exit(1);
     }

   while (1)
     {
       if ((len = netlink_recv(fd)) == -1)
 	{
 	  perror("netlink");
 	  exit(1);
 	}

       for (h = (struct nlmsghdr *)iov.iov_base; NLMSG_OK(h, (size_t)len); h = NLMSG_NEXT(h, len))
 	if (h->nlmsg_type == NLMSG_DONE)
 	  exit(0);
 	else if (h->nlmsg_type == RTM_NEWADDR)
           {
             struct ifaddrmsg *ifa = NLMSG_DATA(h);
             struct rtattr *rta;
             unsigned int len1 = h->nlmsg_len - NLMSG_LENGTH(sizeof(*ifa));

             if (ifa->ifa_index == index && ifa->ifa_family == AF_INET)
               {
                 struct in_addr netmask, addr;

                 netmask.s_addr = htonl(0xffffffff << (32 - ifa->ifa_prefixlen));
                 addr.s_addr = 0;

                 for (rta = IFA_RTA(ifa); RTA_OK(rta, len1); rta = RTA_NEXT(rta, len1))
 		  if (rta->rta_type == IFA_LOCAL)
 		    addr = *((struct in_addr *)(rta+1));

                 if (addr.s_addr && is_same_net(addr, client, netmask))
 		  return addr;
 	      }
 	  }
     }

   exit(0);
 }

 int main(int argc, char **argv)
 {
   struct in_addr server, lease;
   int mac_type;
   struct dhcp_packet packet;
   unsigned char *p = packet.options;
   struct sockaddr_in dest;
   struct ifreq ifr;
   int fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
   int nl = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);

   if (argc < 4 || argc > 5)
     {
       fprintf(stderr, "usage: dhcp_release <interface> <addr> <mac> [<client_id>]\n");
       exit(1);
     }

   if (fd == -1 || nl == -1)
     {
       perror("cannot create socket");
       exit(1);
     }

   /* This voodoo fakes up a packet coming from the correct interface, which really matters for
      a DHCP server */
   strcpy(ifr.ifr_name, argv[1]);
   if (setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, &ifr, sizeof(ifr)) == -1)
     {
       perror("cannot setup interface");
       exit(1);
     }

   if (inet_addr(argv[2]) == INADDR_NONE)
     {
       perror("invalid ip address");
       exit(1);
     }

   lease.s_addr = inet_addr(argv[2]);
   server = find_interface(lease, nl, if_nametoindex(argv[1]));

   memset(&packet, 0, sizeof(packet));

   packet.hlen = parse_hex(argv[3], packet.chaddr, DHCP_CHADDR_MAX, &mac_type);
   if (mac_type == 0)
     packet.htype = ARPHRD_ETHER;
   else
     packet.htype = mac_type;

   packet.op = BOOTREQUEST;
   packet.ciaddr = lease;
   packet.cookie = htonl(DHCP_COOKIE);

   *(p++) = OPTION_MESSAGE_TYPE;
   *(p++) = 1;
   *(p++) = DHCPRELEASE;

   *(p++) = OPTION_SERVER_IDENTIFIER;
   *(p++) = sizeof(server);
   memcpy(p, &server, sizeof(server));
   p += sizeof(server);

   if (argc == 5 && strcmp(argv[4], "*") != 0)
     {
       unsigned int clid_len = parse_hex(argv[4], p+2, 255, NULL);
       *(p++) = OPTION_CLIENT_ID;
       *(p++) = clid_len;
       p += clid_len;
     }

   *(p++) = OPTION_END;

   dest.sin_family = AF_INET;
   dest.sin_port = ntohs(DHCP_SERVER_PORT);
   dest.sin_addr = server;

   if (sendto(fd, &packet, sizeof(packet), 0,
 	     (struct sockaddr *)&dest, sizeof(dest)) == -1)
     {
       perror("sendto failed");
       exit(1);
     }

   return 0;
 }
	/* Copyright (c) 2006 Simon Kelley

	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; version 2 dated June, 1991.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.
	*/

	/* dhcp_release <interface> <address> <MAC address> <client_id>
	MUST be run as root - will fail otherwise. */

	/* Send a DHCPRELEASE message via the specified interface
	to tell the local DHCP server to delete a particular lease.

	The interface argument is the interface in which a DHCP
	request _would_ be received if it was coming from the client,
	rather than being faked up here.

	The address argument is a dotted-quad IP addresses and mandatory.

	The MAC address is colon separated hex, and is mandatory. It may be
	prefixed by an address-type byte followed by -, eg

	10-11:22:33:44:55:66

	but if the address-type byte is missing it is assumed to be 1, the type
	for ethernet. This encoding is the one used in dnsmasq lease files.

	The client-id is optional. If it is "*" then it treated as being missing.
	*/

	#include <sys/types.h>
	#include <netinet/in.h>
	#include <net/if.h>
	#include <arpa/inet.h>
	#include <sys/socket.h>
	#include <unistd.h>
	#include <stdio.h>
	#include <string.h>
	#include <stdlib.h>
	#include <net/if_arp.h>
	#include <sys/ioctl.h>
	#include <linux/types.h>
	#include <linux/netlink.h>
	#include <linux/rtnetlink.h>
	#include <errno.h>

	#define DHCP_CHADDR_MAX 16
	#define BOOTREQUEST 1
	#define DHCP_COOKIE 0x63825363
	#define OPTION_SERVER_IDENTIFIER 54
	#define OPTION_CLIENT_ID 61
	#define OPTION_MESSAGE_TYPE 53
	#define OPTION_END 255
	#define DHCPRELEASE 7
	#define DHCP_SERVER_PORT 67

	typedef unsigned char u8;
	typedef unsigned short u16;
	typedef unsigned int u32;

	struct dhcp_packet {
	u8 op, htype, hlen, hops;
	u32 xid;
	u16 secs, flags;
	struct in_addr ciaddr, yiaddr, siaddr, giaddr;
	u8 chaddr[DHCP_CHADDR_MAX], sname[64], file[128];
	u32 cookie;
	unsigned char options[308];
	};

	static struct iovec iov;

	static int expand_buf(struct iovec *iov, size_t size)
	{
	void *new;

	if (size <= iov->iov_len)
	return 1;

	if (!(new = malloc(size)))
	{
	errno = ENOMEM;
	return 0;
	}

	if (iov->iov_base)
	{
	memcpy(new, iov->iov_base, iov->iov_len);
	free(iov->iov_base);
	}

	iov->iov_base = new;
	iov->iov_len = size;

	return 1;
	}

	static ssize_t netlink_recv(int fd)
	{
	struct msghdr msg;
	ssize_t rc;

	msg.msg_control = NULL;
	msg.msg_controllen = 0;
	msg.msg_name = NULL;
	msg.msg_namelen = 0;
	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;

	while (1)
	{
	msg.msg_flags = 0;
	while ((rc = recvmsg(fd, &msg, MSG_PEEK)) == -1 && errno == EINTR);

	/* 2.2.x doesn't suport MSG_PEEK at all, returning EOPNOTSUPP, so we just grab a
	big buffer and pray in that case. */
	if (rc == -1 && errno == EOPNOTSUPP)
	{
	if (!expand_buf(&iov, 2000))
	return -1;
	break;
	}

	if (rc == -1 \|\| !(msg.msg_flags & MSG_TRUNC))
	break;

	if (!expand_buf(&iov, iov.iov_len + 100))
	return -1;
	}

	/* finally, read it for real */
	while ((rc = recvmsg(fd, &msg, 0)) == -1 && errno == EINTR);

	return rc;
	}

	static int parse_hex(char in, unsigned char out, int maxlen, int *mac_type)
	{
	int i = 0;
	char *r;

	if (mac_type)
	*mac_type = 0;

	while (maxlen == -1 \|\| i < maxlen)
	{
	for (r = in; r != 0 && r != ':' && *r != '-'; r++);
	if (*r == 0)
	maxlen = i;

	if (r != in )
	{
	if (*r == '-' && i == 0 && mac_type)
	{
	*r = 0;
	*mac_type = strtol(in, NULL, 16);
	mac_type = NULL;
	}
	else
	{
	*r = 0;
	out[i] = strtol(in, NULL, 16);
	i++;
	}
	}
	in = r+1;
	}
	return i;
	}

	static int is_same_net(struct in_addr a, struct in_addr b, struct in_addr mask)
	{
	return (a.s_addr & mask.s_addr) == (b.s_addr & mask.s_addr);
	}

	static struct in_addr find_interface(struct in_addr client, int fd, unsigned int index)
	{
	struct sockaddr_nl addr;
	struct nlmsghdr *h;
	ssize_t len;

	struct {
	struct nlmsghdr nlh;
	struct rtgenmsg g;
	} req;

	addr.nl_family = AF_NETLINK;
	addr.nl_pad = 0;
	addr.nl_groups = 0;
	addr.nl_pid = 0; /* address to kernel */

	req.nlh.nlmsg_len = sizeof(req);
	req.nlh.nlmsg_type = RTM_GETADDR;
	req.nlh.nlmsg_flags = NLM_F_ROOT \| NLM_F_MATCH \| NLM_F_REQUEST \| NLM_F_ACK;
	req.nlh.nlmsg_pid = 0;
	req.nlh.nlmsg_seq = 1;
	req.g.rtgen_family = AF_INET;

	if (sendto(fd, (void *)&req, sizeof(req), 0,
	(struct sockaddr *)&addr, sizeof(addr)) == -1)
	{
	perror("sendto failed");
	exit(1);
	}

	while (1)
	{
	if ((len = netlink_recv(fd)) == -1)
	{
	perror("netlink");
	exit(1);
	}

	for (h = (struct nlmsghdr *)iov.iov_base; NLMSG_OK(h, (size_t)len); h = NLMSG_NEXT(h, len))
	if (h->nlmsg_type == NLMSG_DONE)
	exit(0);
	else if (h->nlmsg_type == RTM_NEWADDR)
	{
	struct ifaddrmsg *ifa = NLMSG_DATA(h);
	struct rtattr *rta;
	unsigned int len1 = h->nlmsg_len - NLMSG_LENGTH(sizeof(*ifa));

	if (ifa->ifa_index == index && ifa->ifa_family == AF_INET)
	{
	struct in_addr netmask, addr;

	netmask.s_addr = htonl(0xffffffff << (32 - ifa->ifa_prefixlen));
	addr.s_addr = 0;

	for (rta = IFA_RTA(ifa); RTA_OK(rta, len1); rta = RTA_NEXT(rta, len1))
	if (rta->rta_type == IFA_LOCAL)
	addr = ((struct in_addr )(rta+1));

	if (addr.s_addr && is_same_net(addr, client, netmask))
	return addr;
	}
	}
	}

	exit(0);
	}

	int main(int argc, char **argv)
	{
	struct in_addr server, lease;
	int mac_type;
	struct dhcp_packet packet;
	unsigned char *p = packet.options;
	struct sockaddr_in dest;
	struct ifreq ifr;
	int fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
	int nl = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);

	if (argc < 4 \|\| argc > 5)
	{
	fprintf(stderr, "usage: dhcp_release <interface> <addr> <mac> [<client_id>]\n");
	exit(1);
	}

	if (fd == -1 \|\| nl == -1)
	{
	perror("cannot create socket");
	exit(1);
	}

	/* This voodoo fakes up a packet coming from the correct interface, which really matters for
	a DHCP server */
	strcpy(ifr.ifr_name, argv[1]);
	if (setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, &ifr, sizeof(ifr)) == -1)
	{
	perror("cannot setup interface");
	exit(1);
	}

	if (inet_addr(argv[2]) == INADDR_NONE)
	{
	perror("invalid ip address");
	exit(1);
	}

	lease.s_addr = inet_addr(argv[2]);
	server = find_interface(lease, nl, if_nametoindex(argv[1]));

	memset(&packet, 0, sizeof(packet));

	packet.hlen = parse_hex(argv[3], packet.chaddr, DHCP_CHADDR_MAX, &mac_type);
	if (mac_type == 0)
	packet.htype = ARPHRD_ETHER;
	else
	packet.htype = mac_type;

	packet.op = BOOTREQUEST;
	packet.ciaddr = lease;
	packet.cookie = htonl(DHCP_COOKIE);

	*(p++) = OPTION_MESSAGE_TYPE;
	*(p++) = 1;
	*(p++) = DHCPRELEASE;

	*(p++) = OPTION_SERVER_IDENTIFIER;
	*(p++) = sizeof(server);
	memcpy(p, &server, sizeof(server));
	p += sizeof(server);

	if (argc == 5 && strcmp(argv[4], "*") != 0)
	{
	unsigned int clid_len = parse_hex(argv[4], p+2, 255, NULL);
	*(p++) = OPTION_CLIENT_ID;
	*(p++) = clid_len;
	p += clid_len;
	}

	*(p++) = OPTION_END;

	dest.sin_family = AF_INET;
	dest.sin_port = ntohs(DHCP_SERVER_PORT);
	dest.sin_addr = server;

	if (sendto(fd, &packet, sizeof(packet), 0,
	(struct sockaddr *)&dest, sizeof(dest)) == -1)
	{
	perror("sendto failed");
	exit(1);
	}

	return 0;
	}