Annotation of embedaddon/dnsmasq/contrib/lease-tools/dhcp_release6.c, revision 1.1
1.1 ! misho 1: /*
! 2: dhcp_release6 --iface <interface> --client-id <client-id> --server-id
! 3: server-id --iaid <iaid> --ip <IP> [--dry-run] [--help]
! 4: MUST be run as root - will fail othewise
! 5: */
! 6:
! 7: /* Send a DHCPRELEASE message to IPv6 multicast address via the specified interface
! 8: to tell the local DHCP server to delete a particular lease.
! 9:
! 10: The interface argument is the interface in which a DHCP
! 11: request _would_ be received if it was coming from the client,
! 12: rather than being faked up here.
! 13:
! 14: The client-id argument is colon-separated hex string and mandatory. Normally
! 15: it can be found in leases file both on client and server
! 16:
! 17: The server-id argument is colon-separated hex string and mandatory. Normally
! 18: it can be found in leases file both on client and server.
! 19:
! 20: The iaid argument is numeric string and mandatory. Normally
! 21: it can be found in leases file both on client and server.
! 22:
! 23: IP is an IPv6 adress to release
! 24:
! 25: If --dry-run is specified, dhcp_release6 just prints hexadecimal represantation of
! 26: packet to send to stdout and exits.
! 27:
! 28: If --help is specified, dhcp_release6 print usage information to stdout and exits
! 29:
! 30:
! 31:
! 32: */
! 33: #include <stdio.h>
! 34: #include <stdlib.h>
! 35: #include <string.h>
! 36: #include <strings.h>
! 37: #include <sys/types.h>
! 38: #include <sys/socket.h>
! 39: #include <arpa/inet.h>
! 40: #include <getopt.h>
! 41: #include <errno.h>
! 42: #include <unistd.h>
! 43:
! 44: #define NOT_REPLY_CODE 115
! 45: typedef unsigned char u8;
! 46: typedef unsigned short u16;
! 47: typedef unsigned int u32;
! 48:
! 49: enum DHCP6_TYPES{
! 50: SOLICIT = 1,
! 51: ADVERTISE = 2,
! 52: REQUEST = 3,
! 53: CONFIRM = 4,
! 54: RENEW = 5,
! 55: REBIND = 6,
! 56: REPLY = 7,
! 57: RELEASE = 8,
! 58: DECLINE = 9,
! 59: RECONFIGURE = 10,
! 60: INFORMATION_REQUEST = 11,
! 61: RELAY_FORW = 12,
! 62: RELAY_REPL = 13
! 63:
! 64: };
! 65: enum DHCP6_OPTIONS{
! 66: CLIENTID = 1,
! 67: SERVERID = 2,
! 68: IA_NA = 3,
! 69: IA_TA = 4,
! 70: IAADDR = 5,
! 71: ORO = 6,
! 72: PREFERENCE = 7,
! 73: ELAPSED_TIME = 8,
! 74: RELAY_MSG = 9,
! 75: AUTH = 11,
! 76: UNICAST = 12,
! 77: STATUS_CODE = 13,
! 78: RAPID_COMMIT = 14,
! 79: USER_CLASS = 15,
! 80: VENDOR_CLASS = 16,
! 81: VENDOR_OPTS = 17,
! 82: INTERFACE_ID = 18,
! 83: RECONF_MSG = 19,
! 84: RECONF_ACCEPT = 20,
! 85: };
! 86:
! 87: enum DHCP6_STATUSES{
! 88: SUCCESS = 0,
! 89: UNSPEC_FAIL = 1,
! 90: NOADDR_AVAIL=2,
! 91: NO_BINDING = 3,
! 92: NOT_ON_LINK = 4,
! 93: USE_MULTICAST =5
! 94: };
! 95: static struct option longopts[] = {
! 96: {"ip", required_argument, 0, 'a'},
! 97: {"server-id", required_argument, 0, 's'},
! 98: {"client-id", required_argument, 0, 'c'},
! 99: {"iface", required_argument, 0, 'n'},
! 100: {"iaid", required_argument, 0, 'i'},
! 101: {"dry-run", no_argument, 0, 'd'},
! 102: {"help", no_argument, 0, 'h'},
! 103: {0, 0, 0, 0}
! 104: };
! 105:
! 106: const short DHCP6_CLIENT_PORT = 546;
! 107: const short DHCP6_SERVER_PORT = 547;
! 108:
! 109: const char* DHCP6_MULTICAST_ADDRESS = "ff02::1:2";
! 110:
! 111: struct dhcp6_option{
! 112: uint16_t type;
! 113: uint16_t len;
! 114: char value[1024];
! 115: };
! 116:
! 117: struct dhcp6_iaaddr_option{
! 118: uint16_t type;
! 119: uint16_t len;
! 120: struct in6_addr ip;
! 121: uint32_t preferred_lifetime;
! 122: uint32_t valid_lifetime;
! 123:
! 124:
! 125: };
! 126:
! 127: struct dhcp6_iana_option{
! 128: uint16_t type;
! 129: uint16_t len;
! 130: uint32_t iaid;
! 131: uint32_t t1;
! 132: uint32_t t2;
! 133: char options[1024];
! 134: };
! 135:
! 136:
! 137: struct dhcp6_packet{
! 138: size_t len;
! 139: char buf[2048];
! 140:
! 141: } ;
! 142:
! 143: size_t pack_duid(const char* str, char* dst){
! 144:
! 145: char* tmp = strdup(str);
! 146: char* tmp_to_free = tmp;
! 147: char *ptr;
! 148: uint8_t write_pos = 0;
! 149: while ((ptr = strtok (tmp, ":"))) {
! 150: dst[write_pos] = (uint8_t) strtol(ptr, NULL, 16);
! 151: write_pos += 1;
! 152: tmp = NULL;
! 153:
! 154: }
! 155: free(tmp_to_free);
! 156: return write_pos;
! 157: }
! 158:
! 159: struct dhcp6_option create_client_id_option(const char* duid){
! 160: struct dhcp6_option option;
! 161: option.type = htons(CLIENTID);
! 162: bzero(option.value, sizeof(option.value));
! 163: option.len = htons(pack_duid(duid, option.value));
! 164: return option;
! 165: }
! 166:
! 167: struct dhcp6_option create_server_id_option(const char* duid){
! 168: struct dhcp6_option option;
! 169: option.type = htons(SERVERID);
! 170: bzero(option.value, sizeof(option.value));
! 171: option.len = htons(pack_duid(duid, option.value));
! 172: return option;
! 173: }
! 174:
! 175: struct dhcp6_iaaddr_option create_iaadr_option(const char* ip){
! 176: struct dhcp6_iaaddr_option result;
! 177: result.type =htons(IAADDR);
! 178: /* no suboptions needed here, so length is 24 */
! 179: result.len = htons(24);
! 180: result.preferred_lifetime = 0;
! 181: result.valid_lifetime = 0;
! 182: int s = inet_pton(AF_INET6, ip, &(result.ip));
! 183: if (s <= 0) {
! 184: if (s == 0)
! 185: fprintf(stderr, "Not in presentation format");
! 186: else
! 187: perror("inet_pton");
! 188: exit(EXIT_FAILURE);
! 189: }
! 190: return result;
! 191: }
! 192: struct dhcp6_iana_option create_iana_option(const char * iaid, struct dhcp6_iaaddr_option ia_addr){
! 193: struct dhcp6_iana_option result;
! 194: result.type = htons(IA_NA);
! 195: result.iaid = htonl(atoi(iaid));
! 196: result.t1 = 0;
! 197: result.t2 = 0;
! 198: result.len = htons(12 + ntohs(ia_addr.len) + 2 * sizeof(uint16_t));
! 199: memcpy(result.options, &ia_addr, ntohs(ia_addr.len) + 2 * sizeof(uint16_t));
! 200: return result;
! 201: }
! 202:
! 203: struct dhcp6_packet create_release_packet(const char* iaid, const char* ip, const char* client_id, const char* server_id){
! 204: struct dhcp6_packet result;
! 205: bzero(result.buf, sizeof(result.buf));
! 206: /* message_type */
! 207: result.buf[0] = RELEASE;
! 208: /* tx_id */
! 209: bzero(result.buf+1, 3);
! 210:
! 211: struct dhcp6_option client_option = create_client_id_option(client_id);
! 212: struct dhcp6_option server_option = create_server_id_option(server_id);
! 213: struct dhcp6_iaaddr_option iaaddr_option = create_iaadr_option(ip);
! 214: struct dhcp6_iana_option iana_option = create_iana_option(iaid, iaaddr_option);
! 215: int offset = 4;
! 216: memcpy(result.buf + offset, &client_option, ntohs(client_option.len) + 2*sizeof(uint16_t));
! 217: offset += (ntohs(client_option.len)+ 2 *sizeof(uint16_t) );
! 218: memcpy(result.buf + offset, &server_option, ntohs(server_option.len) + 2*sizeof(uint16_t) );
! 219: offset += (ntohs(server_option.len)+ 2* sizeof(uint16_t));
! 220: memcpy(result.buf + offset, &iana_option, ntohs(iana_option.len) + 2*sizeof(uint16_t) );
! 221: offset += (ntohs(iana_option.len)+ 2* sizeof(uint16_t));
! 222: result.len = offset;
! 223: return result;
! 224: }
! 225:
! 226: uint16_t parse_iana_suboption(char* buf, size_t len){
! 227: size_t current_pos = 0;
! 228: char option_value[1024];
! 229: while (current_pos < len) {
! 230: uint16_t option_type, option_len;
! 231: memcpy(&option_type,buf + current_pos, sizeof(uint16_t));
! 232: memcpy(&option_len,buf + current_pos + sizeof(uint16_t), sizeof(uint16_t));
! 233: option_type = ntohs(option_type);
! 234: option_len = ntohs(option_len);
! 235: current_pos += 2 * sizeof(uint16_t);
! 236: if (option_type == STATUS_CODE){
! 237: uint16_t status;
! 238: memcpy(&status, buf + current_pos, sizeof(uint16_t));
! 239: status = ntohs(status);
! 240: if (status != SUCCESS){
! 241: memcpy(option_value, buf + current_pos + sizeof(uint16_t) , option_len - sizeof(uint16_t));
! 242: option_value[option_len-sizeof(uint16_t)] ='\0';
! 243: fprintf(stderr, "Error: %s\n", option_value);
! 244: }
! 245: return status;
! 246: }
! 247: }
! 248: return -2;
! 249: }
! 250:
! 251: int16_t parse_packet(char* buf, size_t len){
! 252: uint8_t type = buf[0];
! 253: /*skipping tx id. you need it, uncomment following line
! 254: uint16_t tx_id = ntohs((buf[1] <<16) + (buf[2] <<8) + buf[3]);
! 255: */
! 256: size_t current_pos = 4;
! 257: if (type != REPLY ){
! 258: return NOT_REPLY_CODE;
! 259: }
! 260: char option_value[1024];
! 261: while (current_pos < len) {
! 262: uint16_t option_type, option_len;
! 263: memcpy(&option_type,buf + current_pos, sizeof(uint16_t));
! 264: memcpy(&option_len,buf + current_pos + sizeof(uint16_t), sizeof(uint16_t));
! 265: option_type = ntohs(option_type);
! 266: option_len = ntohs(option_len);
! 267: current_pos += 2 * sizeof(uint16_t);
! 268: if (option_type == STATUS_CODE){
! 269: uint16_t status;
! 270: memcpy(&status, buf + current_pos, sizeof(uint16_t));
! 271: status = ntohs(status);
! 272: if (status != SUCCESS){
! 273: memcpy(option_value, buf + current_pos +sizeof(uint16_t) , option_len -sizeof(uint16_t));
! 274: fprintf(stderr, "Error: %d %s\n", status, option_value);
! 275: return status;
! 276: }
! 277:
! 278: }
! 279: if (option_type == IA_NA ){
! 280: uint16_t result = parse_iana_suboption(buf + current_pos +24, option_len -24);
! 281: if (result){
! 282: return result;
! 283: }
! 284: }
! 285: current_pos += option_len;
! 286:
! 287: }
! 288: return -1;
! 289: }
! 290:
! 291: void usage(const char* arg, FILE* stream){
! 292: const char* usage_string ="--ip IPv6 --iface IFACE --server-id SERVER_ID --client-id CLIENT_ID --iaid IAID [--dry-run] | --help";
! 293: fprintf (stream, "Usage: %s %s\n", arg, usage_string);
! 294:
! 295: }
! 296:
! 297: int send_release_packet(const char* iface, struct dhcp6_packet* packet){
! 298:
! 299: struct sockaddr_in6 server_addr, client_addr;
! 300: char response[1400];
! 301: int sock = socket(PF_INET6, SOCK_DGRAM, 0);
! 302: int i = 0;
! 303: if (sock < 0) {
! 304: perror("creating socket");
! 305: return -1;
! 306: }
! 307: if (setsockopt(sock, SOL_SOCKET, 25, iface, strlen(iface)) == -1) {
! 308: perror("SO_BINDTODEVICE");
! 309: close(sock);
! 310: return -1;
! 311: }
! 312: memset(&server_addr, 0, sizeof(server_addr));
! 313: server_addr.sin6_family = AF_INET6;
! 314: client_addr.sin6_family = AF_INET6;
! 315: client_addr.sin6_port = htons(DHCP6_CLIENT_PORT);
! 316: client_addr.sin6_flowinfo = 0;
! 317: client_addr.sin6_scope_id =0;
! 318: inet_pton(AF_INET6, "::", &client_addr.sin6_addr);
! 319: bind(sock, (struct sockaddr*)&client_addr, sizeof(struct sockaddr_in6));
! 320: inet_pton(AF_INET6, DHCP6_MULTICAST_ADDRESS, &server_addr.sin6_addr);
! 321: server_addr.sin6_port = htons(DHCP6_SERVER_PORT);
! 322: int16_t recv_size = 0;
! 323: for (i = 0; i < 5; i++) {
! 324: if (sendto(sock, packet->buf, packet->len, 0,
! 325: (struct sockaddr *)&server_addr,
! 326: sizeof(server_addr)) < 0) {
! 327: perror("sendto failed");
! 328: exit(4);
! 329: }
! 330: recv_size = recvfrom(sock, response, sizeof(response), MSG_DONTWAIT, NULL, 0);
! 331: if (recv_size == -1){
! 332: if (errno == EAGAIN){
! 333: sleep(1);
! 334: continue;
! 335: }else {
! 336: perror("recvfrom");
! 337: }
! 338: }
! 339: int16_t result = parse_packet(response, recv_size);
! 340: if (result == NOT_REPLY_CODE){
! 341: sleep(1);
! 342: continue;
! 343: }
! 344: return result;
! 345: }
! 346: fprintf(stderr, "Response timed out\n");
! 347: return -1;
! 348:
! 349: }
! 350:
! 351:
! 352: int main(int argc, char * const argv[]) {
! 353: const char* UNINITIALIZED = "";
! 354: const char* iface = UNINITIALIZED;
! 355: const char* ip = UNINITIALIZED;
! 356: const char* client_id = UNINITIALIZED;
! 357: const char* server_id = UNINITIALIZED;
! 358: const char* iaid = UNINITIALIZED;
! 359: int dry_run = 0;
! 360: while (1) {
! 361: int option_index = 0;
! 362: int c = getopt_long(argc, argv, "a:s:c:n:i:hd", longopts, &option_index);
! 363: if (c == -1){
! 364: break;
! 365: }
! 366: switch(c){
! 367: case 0:
! 368: if (longopts[option_index].flag !=0){
! 369: break;
! 370: }
! 371: printf ("option %s", longopts[option_index].name);
! 372: if (optarg)
! 373: printf (" with arg %s", optarg);
! 374: printf ("\n");
! 375: break;
! 376: case 'i':
! 377: iaid = optarg;
! 378: break;
! 379: case 'n':
! 380: iface = optarg;
! 381: break;
! 382: case 'a':
! 383: ip = optarg;
! 384: break;
! 385: case 'c':
! 386: client_id = optarg;
! 387: break;
! 388: case 'd':
! 389: dry_run = 1;
! 390: break;
! 391: case 's':
! 392: server_id = optarg;
! 393: break;
! 394: case 'h':
! 395: usage(argv[0], stdout);
! 396: return 0;
! 397: case '?':
! 398: usage(argv[0], stderr);
! 399: return -1;
! 400: default:
! 401: abort();
! 402:
! 403: }
! 404:
! 405: }
! 406: if (iaid == UNINITIALIZED){
! 407: fprintf(stderr, "Missing required iaid parameter\n");
! 408: usage(argv[0], stderr);
! 409: return -1;
! 410: }
! 411: if (server_id == UNINITIALIZED){
! 412: fprintf(stderr, "Missing required server-id parameter\n");
! 413: usage(argv[0], stderr);
! 414: return -1;
! 415: }
! 416: if (client_id == UNINITIALIZED){
! 417: fprintf(stderr, "Missing required client-id parameter\n");
! 418: usage(argv[0], stderr);
! 419: return -1;
! 420: }
! 421: if (ip == UNINITIALIZED){
! 422: fprintf(stderr, "Missing required ip parameter\n");
! 423: usage(argv[0], stderr);
! 424: return -1;
! 425: }
! 426: if (iface == UNINITIALIZED){
! 427: fprintf(stderr, "Missing required iface parameter\n");
! 428: usage(argv[0], stderr);
! 429: return -1;
! 430: }
! 431:
! 432:
! 433:
! 434: struct dhcp6_packet packet = create_release_packet(iaid, ip, client_id, server_id);
! 435: if (dry_run){
! 436: uint16_t i;
! 437: for(i=0;i<packet.len;i++){
! 438: printf("%hhx", packet.buf[i]);
! 439: }
! 440: printf("\n");
! 441: return 0;
! 442: }
! 443: return send_release_packet(iface, &packet);
! 444:
! 445: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to dhcp_release6.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dnsmasq / contrib / lease-tools