1 /* Copyright (c) 2006 Simon Kelley 2 3 This program is free software; you can redistribute it and/or modify 4 it under the terms of the GNU General Public License as published by 5 the Free Software Foundation; version 2 dated June, 1991. 6 7 This program is distributed in the hope that it will be useful, 8 but WITHOUT ANY WARRANTY; without even the implied warranty of 9 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 10 GNU General Public License for more details. 11 */ 12 13 /* dhcp_release <interface> <address> <MAC address> <client_id> 14 MUST be run as root - will fail otherwise. */ 15 16 /* Send a DHCPRELEASE message via the specified interface 17 to tell the local DHCP server to delete a particular lease. 18 19 The interface argument is the interface in which a DHCP 20 request _would_ be received if it was coming from the client, 21 rather than being faked up here. 22 23 The address argument is a dotted-quad IP addresses and mandatory. 24 25 The MAC address is colon separated hex, and is mandatory. It may be 26 prefixed by an address-type byte followed by -, eg 27 28 10-11:22:33:44:55:66 29 30 but if the address-type byte is missing it is assumed to be 1, the type 31 for ethernet. This encoding is the one used in dnsmasq lease files. 32 33 The client-id is optional. If it is "*" then it treated as being missing. 34 */ 35 36 #include <sys/types.h> 37 #include <netinet/in.h> 38 #include <net/if.h> 39 #include <arpa/inet.h> 40 #include <sys/socket.h> 41 #include <unistd.h> 42 #include <stdio.h> 43 #include <string.h> 44 #include <stdlib.h> 45 #include <net/if_arp.h> 46 #include <sys/ioctl.h> 47 #include <linux/types.h> 48 #include <linux/netlink.h> 49 #include <linux/rtnetlink.h> 50 #include <errno.h> 51 52 #define DHCP_CHADDR_MAX 16 53 #define BOOTREQUEST 1 54 #define DHCP_COOKIE 0x63825363 55 #define OPTION_SERVER_IDENTIFIER 54 56 #define OPTION_CLIENT_ID 61 57 #define OPTION_MESSAGE_TYPE 53 58 #define OPTION_END 255 59 #define DHCPRELEASE 7 60 #define DHCP_SERVER_PORT 67 61 62 typedef unsigned char u8; 63 typedef unsigned short u16; 64 typedef unsigned int u32; 65 66 struct dhcp_packet { 67 u8 op, htype, hlen, hops; 68 u32 xid; 69 u16 secs, flags; 70 struct in_addr ciaddr, yiaddr, siaddr, giaddr; 71 u8 chaddr[DHCP_CHADDR_MAX], sname[64], file[128]; 72 u32 cookie; 73 unsigned char options[308]; 74 }; 75 76 static struct iovec iov; 77 78 static int expand_buf(struct iovec *iov, size_t size) 79 { 80 void *new; 81 82 if (size <= iov->iov_len) 83 return 1; 84 85 if (!(new = malloc(size))) 86 { 87 errno = ENOMEM; 88 return 0; 89 } 90 91 if (iov->iov_base) 92 { 93 memcpy(new, iov->iov_base, iov->iov_len); 94 free(iov->iov_base); 95 } 96 97 iov->iov_base = new; 98 iov->iov_len = size; 99 100 return 1; 101 } 102 103 static ssize_t netlink_recv(int fd) 104 { 105 struct msghdr msg; 106 ssize_t rc; 107 108 msg.msg_control = NULL; 109 msg.msg_controllen = 0; 110 msg.msg_name = NULL; 111 msg.msg_namelen = 0; 112 msg.msg_iov = &iov; 113 msg.msg_iovlen = 1; 114 115 while (1) 116 { 117 msg.msg_flags = 0; 118 while ((rc = recvmsg(fd, &msg, MSG_PEEK)) == -1 && errno == EINTR); 119 120 /* 2.2.x doesn't suport MSG_PEEK at all, returning EOPNOTSUPP, so we just grab a 121 big buffer and pray in that case. */ 122 if (rc == -1 && errno == EOPNOTSUPP) 123 { 124 if (!expand_buf(&iov, 2000)) 125 return -1; 126 break; 127 } 128 129 if (rc == -1 || !(msg.msg_flags & MSG_TRUNC)) 130 break; 131 132 if (!expand_buf(&iov, iov.iov_len + 100)) 133 return -1; 134 } 135 136 /* finally, read it for real */ 137 while ((rc = recvmsg(fd, &msg, 0)) == -1 && errno == EINTR); 138 139 return rc; 140 } 141 142 static int parse_hex(char *in, unsigned char *out, int maxlen, int *mac_type) 143 { 144 int i = 0; 145 char *r; 146 147 if (mac_type) 148 *mac_type = 0; 149 150 while (maxlen == -1 || i < maxlen) 151 { 152 for (r = in; *r != 0 && *r != ':' && *r != '-'; r++); 153 if (*r == 0) 154 maxlen = i; 155 156 if (r != in ) 157 { 158 if (*r == '-' && i == 0 && mac_type) 159 { 160 *r = 0; 161 *mac_type = strtol(in, NULL, 16); 162 mac_type = NULL; 163 } 164 else 165 { 166 *r = 0; 167 out[i] = strtol(in, NULL, 16); 168 i++; 169 } 170 } 171 in = r+1; 172 } 173 return i; 174 } 175 176 static int is_same_net(struct in_addr a, struct in_addr b, struct in_addr mask) 177 { 178 return (a.s_addr & mask.s_addr) == (b.s_addr & mask.s_addr); 179 } 180 181 static struct in_addr find_interface(struct in_addr client, int fd, int index) 182 { 183 struct sockaddr_nl addr; 184 struct nlmsghdr *h; 185 ssize_t len; 186 187 struct { 188 struct nlmsghdr nlh; 189 struct rtgenmsg g; 190 } req; 191 192 addr.nl_family = AF_NETLINK; 193 addr.nl_pad = 0; 194 addr.nl_groups = 0; 195 addr.nl_pid = 0; /* address to kernel */ 196 197 req.nlh.nlmsg_len = sizeof(req); 198 req.nlh.nlmsg_type = RTM_GETADDR; 199 req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST | NLM_F_ACK; 200 req.nlh.nlmsg_pid = 0; 201 req.nlh.nlmsg_seq = 1; 202 req.g.rtgen_family = AF_INET; 203 204 if (sendto(fd, (void *)&req, sizeof(req), 0, 205 (struct sockaddr *)&addr, sizeof(addr)) == -1) 206 { 207 perror("sendto failed"); 208 exit(1); 209 } 210 211 while (1) 212 { 213 if ((len = netlink_recv(fd)) == -1) 214 { 215 perror("netlink"); 216 exit(1); 217 } 218 219 for (h = (struct nlmsghdr *)iov.iov_base; NLMSG_OK(h, (size_t)len); h = NLMSG_NEXT(h, len)) 220 if (h->nlmsg_type == NLMSG_DONE) 221 exit(0); 222 else if (h->nlmsg_type == RTM_NEWADDR) 223 { 224 struct ifaddrmsg *ifa = NLMSG_DATA(h); 225 struct rtattr *rta; 226 unsigned int len1 = h->nlmsg_len - NLMSG_LENGTH(sizeof(*ifa)); 227 228 if (ifa->ifa_index == index && ifa->ifa_family == AF_INET) 229 { 230 struct in_addr netmask, addr; 231 232 netmask.s_addr = htonl(0xffffffff << (32 - ifa->ifa_prefixlen)); 233 addr.s_addr = 0; 234 235 for (rta = IFA_RTA(ifa); RTA_OK(rta, len1); rta = RTA_NEXT(rta, len1)) 236 if (rta->rta_type == IFA_LOCAL) 237 addr = *((struct in_addr *)(rta+1)); 238 239 if (addr.s_addr && is_same_net(addr, client, netmask)) 240 return addr; 241 } 242 } 243 } 244 245 exit(0); 246 } 247 248 int main(int argc, char **argv) 249 { 250 struct in_addr server, lease; 251 int mac_type; 252 struct dhcp_packet packet; 253 unsigned char *p = packet.options; 254 struct sockaddr_in dest; 255 struct ifreq ifr; 256 int fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP); 257 int nl = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE); 258 struct iovec iov; 259 260 iov.iov_len = 200; 261 iov.iov_base = malloc(iov.iov_len); 262 263 if (argc < 4 || argc > 5) 264 { 265 fprintf(stderr, "usage: dhcp_release <interface> <addr> <mac> [<client_id>]\n"); 266 exit(1); 267 } 268 269 if (fd == -1 || nl == -1) 270 { 271 perror("cannot create socket"); 272 exit(1); 273 } 274 275 /* This voodoo fakes up a packet coming from the correct interface, which really matters for 276 a DHCP server */ 277 strcpy(ifr.ifr_name, argv[1]); 278 if (setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, &ifr, sizeof(ifr)) == -1) 279 { 280 perror("cannot setup interface"); 281 exit(1); 282 } 283 284 285 lease.s_addr = inet_addr(argv[2]); 286 server = find_interface(lease, nl, if_nametoindex(argv[1])); 287 288 memset(&packet, 0, sizeof(packet)); 289 290 packet.hlen = parse_hex(argv[3], packet.chaddr, DHCP_CHADDR_MAX, &mac_type); 291 if (mac_type == 0) 292 packet.htype = ARPHRD_ETHER; 293 else 294 packet.htype = mac_type; 295 296 packet.op = BOOTREQUEST; 297 packet.ciaddr = lease; 298 packet.cookie = htonl(DHCP_COOKIE); 299 300 *(p++) = OPTION_MESSAGE_TYPE; 301 *(p++) = 1; 302 *(p++) = DHCPRELEASE; 303 304 *(p++) = OPTION_SERVER_IDENTIFIER; 305 *(p++) = sizeof(server); 306 memcpy(p, &server, sizeof(server)); 307 p += sizeof(server); 308 309 if (argc == 5 && strcmp(argv[4], "*") != 0) 310 { 311 unsigned int clid_len = parse_hex(argv[4], p+2, 255, NULL); 312 *(p++) = OPTION_CLIENT_ID; 313 *(p++) = clid_len; 314 p += clid_len; 315 } 316 317 *(p++) = OPTION_END; 318 319 dest.sin_family = AF_INET; 320 dest.sin_port = ntohs(DHCP_SERVER_PORT); 321 dest.sin_addr = server; 322 323 if (sendto(fd, &packet, sizeof(packet), 0, 324 (struct sockaddr *)&dest, sizeof(dest)) == -1) 325 { 326 perror("sendto failed"); 327 exit(1); 328 } 329 330 return 0; 331 } 332
