projects / project / odhcp6c.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
odhcp6c: add -K option to set packet kernel priority
[project/odhcp6c.git] / src / odhcp6c.c
1 /**
2 * Copyright (C) 2012-2014 Steven Barth <steven@midlink.org>
3 * Copyright (C) 2017-2018 Hans Dedecker <dedeckeh@gmail.com>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License v2 as published by
7 * the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 */
15
16 #include <time.h>
17 #include <errno.h>
18 #include <ctype.h>
19 #include <fcntl.h>
20 #include <limits.h>
21 #include <resolv.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <stddef.h>
25 #include <unistd.h>
26 #include <syslog.h>
27 #include <signal.h>
28 #include <string.h>
29 #include <strings.h>
30 #include <stdbool.h>
31
32 #include <net/if.h>
33 #include <sys/syscall.h>
34 #include <arpa/inet.h>
35 #include <linux/if_addr.h>
36
37 #include "odhcp6c.h"
38 #include "ra.h"
39
40 #ifndef IN6_IS_ADDR_UNIQUELOCAL
41 #define IN6_IS_ADDR_UNIQUELOCAL(a) \
42 ((((__const uint32_t *) (a))[0] & htonl (0xfe000000)) \
43 == htonl (0xfc000000))
44 #endif
45 #define ARRAY_SEP " ,\t"
46
47 static void sighandler(int signal);
48 static int usage(void);
49 static int add_opt(const uint16_t code, const uint8_t *data,
50 const uint16_t len);
51 static int parse_opt_data(const char *data, uint8_t **dst,
52 const unsigned int type, const bool array);
53 static int parse_opt(const char *opt);
54
55 static uint8_t *state_data[_STATE_MAX] = {NULL};
56 static size_t state_len[_STATE_MAX] = {0};
57
58 static volatile bool signal_io = false;
59 static volatile bool signal_usr1 = false;
60 static volatile bool signal_usr2 = false;
61 static volatile bool signal_term = false;
62
63 static int urandom_fd = -1, allow_slaac_only = 0;
64 static bool bound = false, release = true, ra = false;
65 static time_t last_update = 0;
66 static char *ifname = NULL;
67
68 static unsigned int script_sync_delay = 10;
69 static unsigned int script_accu_delay = 1;
70
71 static struct odhcp6c_opt opts[] = {
72 { .code = DHCPV6_OPT_CLIENTID, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
73 { .code = DHCPV6_OPT_SERVERID, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
74 { .code = DHCPV6_OPT_IA_NA, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str= NULL },
75 { .code = DHCPV6_OPT_IA_TA, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
76 { .code = DHCPV6_OPT_IA_ADDR, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
77 { .code = DHCPV6_OPT_ORO, .flags = OPT_INTERNAL, .str = NULL },
78 { .code = DHCPV6_OPT_PREF, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
79 { .code = DHCPV6_OPT_ELAPSED, .flags = OPT_INTERNAL, .str = NULL },
80 { .code = DHCPV6_OPT_RELAY_MSG, .flags = OPT_INTERNAL, .str = NULL },
81 { .code = DHCPV6_OPT_AUTH, .flags = OPT_U8 | OPT_NO_PASSTHRU, .str = "authentication" },
82 { .code = DHCPV6_OPT_UNICAST, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
83 { .code = DHCPV6_OPT_STATUS, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
84 { .code = DHCPV6_OPT_RAPID_COMMIT, .flags = OPT_INTERNAL, .str = NULL },
85 { .code = DHCPV6_OPT_USER_CLASS, .flags = OPT_USER_CLASS | OPT_ARRAY, .str = "userclass" },
86 { .code = DHCPV6_OPT_VENDOR_CLASS, .flags = OPT_U8, .str = "vendorclass" },
87 { .code = DHCPV6_OPT_INTERFACE_ID, .flags = OPT_INTERNAL, .str = NULL },
88 { .code = DHCPV6_OPT_RECONF_MESSAGE, .flags = OPT_INTERNAL, .str = NULL },
89 { .code = DHCPV6_OPT_RECONF_ACCEPT, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
90 { .code = DHCPV6_OPT_SIP_SERVER_D, .flags = OPT_DNS_STR | OPT_ORO, .str = "sipserver_d" },
91 { .code = DHCPV6_OPT_SIP_SERVER_A, .flags = OPT_IP6 | OPT_ARRAY | OPT_ORO, .str = "sipserver_a" },
92 { .code = DHCPV6_OPT_DNS_SERVERS, .flags = OPT_IP6 | OPT_ARRAY | OPT_ORO, .str = "dns" },
93 { .code = DHCPV6_OPT_DNS_DOMAIN, .flags = OPT_DNS_STR | OPT_ORO, .str = "search" },
94 { .code = DHCPV6_OPT_IA_PD, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
95 { .code = DHCPV6_OPT_IA_PREFIX, .flags = OPT_INTERNAL, .str = NULL },
96 { .code = DHCPV6_OPT_SNTP_SERVERS, .flags = OPT_IP6 | OPT_ARRAY | OPT_ORO, .str = "sntpservers" },
97 { .code = DHCPV6_OPT_INFO_REFRESH, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU | OPT_ORO | OPT_ORO_STATELESS, .str = NULL },
98 { .code = DHCPV6_OPT_REMOTE_ID, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
99 { .code = DHCPV6_OPT_SUBSCRIBER_ID, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
100 { .code = DHCPV6_OPT_FQDN, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU | OPT_ORO, .str = NULL },
101 { .code = DHCPV6_OPT_ERO, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
102 { .code = DHCPV6_OPT_LQ_QUERY, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
103 { .code = DHCPV6_OPT_CLIENT_DATA, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
104 { .code = DHCPV6_OPT_CLT_TIME, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
105 { .code = DHCPV6_OPT_LQ_RELAY_DATA, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
106 { .code = DHCPV6_OPT_LQ_CLIENT_LINK, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
107 { .code = DHCPV6_OPT_RELAY_ID, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
108 { .code = DHCPV6_OPT_NTP_SERVER, .flags = OPT_U8 | OPT_ORO, .str = "ntpserver" },
109 { .code = DHCPV6_OPT_CLIENT_ARCH_TYPE, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
110 { .code = DHCPV6_OPT_AFTR_NAME, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU | OPT_ORO, .str = NULL },
111 { .code = DHCPV6_OPT_RSOO, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
112 { .code = DHCPV6_OPT_PD_EXCLUDE, .flags = OPT_INTERNAL | OPT_ORO | OPT_ORO_STATEFUL, .str = NULL },
113 { .code = DHCPV6_OPT_VSS, .flags = OPT_U8, .str = "vss" },
114 { .code = DHCPV6_OPT_LINK_LAYER_ADDRESS, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
115 { .code = DHCPV6_OPT_LINK_ADDRESS, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
116 { .code = DHCPV6_OPT_RADIUS, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
117 { .code = DHCPV6_OPT_SOL_MAX_RT, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU | OPT_ORO | OPT_ORO_SOLICIT, .str = NULL },
118 { .code = DHCPV6_OPT_INF_MAX_RT, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU | OPT_ORO | OPT_ORO_STATELESS, .str = NULL },
119 #ifdef EXT_CER_ID
120 { .code = DHCPV6_OPT_CER_ID, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
121 #endif
122 { .code = DHCPV6_OPT_DHCPV4_MSG, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
123 { .code = DHCPV6_OPT_S46_RULE, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
124 { .code = DHCPV6_OPT_S46_BR, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
125 { .code = DHCPV6_OPT_S46_DMR, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
126 { .code = DHCPV6_OPT_S46_V4V6BIND, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
127 { .code = DHCPV6_OPT_S46_PORTPARAMS, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
128 { .code = DHCPV6_OPT_S46_CONT_MAPE, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU | OPT_ORO, .str = NULL },
129 { .code = DHCPV6_OPT_S46_CONT_MAPT, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU | OPT_ORO, .str = NULL },
130 { .code = DHCPV6_OPT_S46_CONT_LW, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU | OPT_ORO, .str = NULL },
131 { .code = DHCPV6_OPT_LQ_BASE_TIME, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
132 { .code = DHCPV6_OPT_LQ_START_TIME, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
133 { .code = DHCPV6_OPT_LQ_END_TIME, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
134 { .code = DHCPV6_OPT_ANI_ATT, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
135 { .code = DHCPV6_OPT_ANI_NETWORK_NAME, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
136 { .code = DHCPV6_OPT_ANI_AP_NAME, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
137 { .code = DHCPV6_OPT_ANI_AP_BSSID, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
138 { .code = DHCPV6_OPT_ANI_OPERATOR_ID, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
139 { .code = DHCPV6_OPT_ANI_OPERATOR_REALM, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
140 { .code = DHCPV6_OPT_MUD_URL_V6, .flags = OPT_STR | OPT_NO_PASSTHRU, .str = "mud_url_v6" },
141 { .code = DHCPV6_OPT_F_BINDING_STATUS, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
142 { .code = DHCPV6_OPT_F_CONNECT_FLAGS, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
143 { .code = DHCPV6_OPT_F_DNS_REMOVAL_INFO, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
144 { .code = DHCPV6_OPT_F_DNS_HOST_NAME, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
145 { .code = DHCPV6_OPT_F_DNS_ZONE_NAME, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
146 { .code = DHCPV6_OPT_F_DNS_FLAGS, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
147 { .code = DHCPV6_OPT_F_EXPIRATION_TIME, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
148 { .code = DHCPV6_OPT_F_MAX_UNACKED_BNDUPD, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
149 { .code = DHCPV6_OPT_F_MCLT, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
150 { .code = DHCPV6_OPT_F_PARTNER_LIFETIME, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
151 { .code = DHCPV6_OPT_F_PARTNER_LIFETIME_SENT, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
152 { .code = DHCPV6_OPT_F_PARTNER_DOWN_TIME, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
153 { .code = DHCPV6_OPT_F_PARTNER_RAW_CLT_TIME, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
154 { .code = DHCPV6_OPT_F_PROTOCOL_VERSION, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
155 { .code = DHCPV6_OPT_F_KEEPALIVE_TIME, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
156 { .code = DHCPV6_OPT_F_RECONFIGURE_DATA, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
157 { .code = DHCPV6_OPT_F_RELATIONSHIP_NAME, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
158 { .code = DHCPV6_OPT_F_SERVER_FLAGS, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
159 { .code = DHCPV6_OPT_F_SERVER_STATE, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
160 { .code = DHCPV6_OPT_F_START_TIME_OF_STATE, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
161 { .code = DHCPV6_OPT_F_STATE_EXPIRATION_TIME, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
162 { .code = DHCPV6_OPT_RELAY_PORT, .flags = OPT_INTERNAL | OPT_NO_PASSTHRU, .str = NULL },
163 { .code = 0, .flags = 0, .str = NULL },
164 };
165
166 int main(_unused int argc, char* const argv[])
167 {
168 static struct in6_addr ifid = IN6ADDR_ANY_INIT;
169 // Allocate resources
170 const char *pidfile = NULL;
171 const char *script = "/usr/sbin/odhcp6c-update";
172 ssize_t l;
173 uint8_t buf[134], *o_data;
174 char *optpos;
175 uint16_t opttype;
176 enum odhcp6c_ia_mode ia_na_mode = IA_MODE_TRY;
177 enum odhcp6c_ia_mode ia_pd_mode = IA_MODE_NONE;
178 bool stateful_only_mode = 0;
179 struct odhcp6c_opt *opt;
180 int ia_pd_iaid_index = 0;
181 int sk_prio = 0;
182 int sol_timeout = DHCPV6_SOL_MAX_RT;
183 int verbosity = 0;
184 bool help = false, daemonize = false;
185 int logopt = LOG_PID;
186 int c, res;
187 unsigned int client_options = DHCPV6_CLIENT_FQDN | DHCPV6_ACCEPT_RECONFIGURE;
188 unsigned int ra_options = RA_RDNSS_DEFAULT_LIFETIME;
189 unsigned int ra_holdoff_interval = RA_MIN_ADV_INTERVAL;
190
191 while ((c = getopt(argc, argv, "S::DN:V:P:FB:c:i:r:Ru:Ux:s:kK:t:m:Lhedp:fav")) != -1) {
192 switch (c) {
193 case 'S':
194 allow_slaac_only = (optarg) ? atoi(optarg) : -1;
195 break;
196
197 case 'D':
198 stateful_only_mode = 1;
199 break;
200
201 case 'N':
202 if (!strcmp(optarg, "force")) {
203 ia_na_mode = IA_MODE_FORCE;
204 allow_slaac_only = -1;
205 } else if (!strcmp(optarg, "none"))
206 ia_na_mode = IA_MODE_NONE;
207 else if (!strcmp(optarg, "try"))
208 ia_na_mode = IA_MODE_TRY;
209 else
210 help = true;
211 break;
212
213 case 'V':
214 opt = odhcp6c_find_opt(DHCPV6_OPT_VENDOR_CLASS);
215 if (!opt) {
216 syslog(LOG_ERR, "Failed to set vendor-class option");
217 return 1;
218 }
219
220 o_data = NULL;
221 res = parse_opt_data(optarg, &o_data, opt->flags & OPT_MASK_SIZE,
222 (opt->flags & OPT_ARRAY) == OPT_ARRAY);
223 if (res > 0) {
224 res = add_opt(opt->code, o_data, res);
225 if (res) {
226 if (res > 0)
227 return 1;
228
229 help = true;
230 }
231 } else
232 help = true;
233
234 free(o_data);
235 break;
236
237 case 'P':
238 if (ia_pd_mode == IA_MODE_NONE)
239 ia_pd_mode = IA_MODE_TRY;
240
241 if (allow_slaac_only >= 0 && allow_slaac_only < 10)
242 allow_slaac_only = 10;
243
244 char *iaid_begin;
245 int iaid_len = 0;
246 int prefix_length = strtoul(optarg, &iaid_begin, 10);
247
248 if (*iaid_begin != '\0' && *iaid_begin != ',' && *iaid_begin != ':') {
249 syslog(LOG_ERR, "invalid argument: '%s'", optarg);
250 return 1;
251 }
252
253 struct odhcp6c_request_prefix prefix = { 0, prefix_length };
254
255 if (*iaid_begin == ',' && (iaid_len = strlen(iaid_begin)) > 1)
256 memcpy(&prefix.iaid, iaid_begin + 1, iaid_len > 4 ? 4 : iaid_len);
257 else if (*iaid_begin == ':')
258 prefix.iaid = htonl((uint32_t)strtoul(&iaid_begin[1], NULL, 16));
259 else
260 prefix.iaid = htonl(++ia_pd_iaid_index);
261
262 if (odhcp6c_add_state(STATE_IA_PD_INIT, &prefix, sizeof(prefix))) {
263 syslog(LOG_ERR, "Failed to set request IPv6-Prefix");
264 return 1;
265 }
266 break;
267
268 case 'F':
269 allow_slaac_only = -1;
270 ia_pd_mode = IA_MODE_FORCE;
271 break;
272
273 case 'c':
274 l = script_unhexlify(&buf[4], sizeof(buf) - 4, optarg);
275 if (l > 0) {
276 buf[0] = 0;
277 buf[1] = DHCPV6_OPT_CLIENTID;
278 buf[2] = 0;
279 buf[3] = l;
280 if (odhcp6c_add_state(STATE_CLIENT_ID, buf, l + 4)) {
281 syslog(LOG_ERR, "Failed to override client-ID");
282 return 1;
283 }
284 } else
285 help = true;
286 break;
287
288 case 'i':
289 if (inet_pton(AF_INET6, optarg, &ifid) != 1)
290 help = true;
291 break;
292
293 case 'r':
294 optpos = optarg;
295 while (optpos[0]) {
296 opttype = htons(strtoul(optarg, &optpos, 10));
297 if (optpos == optarg)
298 break;
299 else if (optpos[0])
300 optarg = &optpos[1];
301
302 if (odhcp6c_add_state(STATE_ORO, &opttype, 2)) {
303 syslog(LOG_ERR, "Failed to add requested option");
304 return 1;
305 }
306 }
307 break;
308
309 case 'R':
310 client_options |= DHCPV6_STRICT_OPTIONS;
311 break;
312
313 case 'u':
314 opt = odhcp6c_find_opt(DHCPV6_OPT_USER_CLASS);
315 if (!opt) {
316 syslog(LOG_ERR, "Failed to set user-class option");
317 return 1;
318 }
319
320 o_data = NULL;
321 res = parse_opt_data(optarg, &o_data, opt->flags & OPT_MASK_SIZE,
322 (opt->flags & OPT_ARRAY) == OPT_ARRAY);
323 if (res > 0) {
324 res = add_opt(opt->code, o_data, res);
325 if (res) {
326 if (res > 0)
327 return 1;
328
329 help = true;
330 }
331 } else
332 help = true;
333
334 free(o_data);
335 break;
336
337 case 'U':
338 client_options |= DHCPV6_IGNORE_OPT_UNICAST;
339 break;
340
341 case 's':
342 script = optarg;
343 break;
344
345 case 'k':
346 release = false;
347 break;
348
349 case 'K':
350 sk_prio = atoi(optarg);
351 break;
352
353 case 't':
354 sol_timeout = atoi(optarg);
355 break;
356
357 case 'm':
358 ra_holdoff_interval = atoi(optarg);
359 break;
360
361 case 'L':
362 ra_options &= ~RA_RDNSS_DEFAULT_LIFETIME;
363 break;
364
365 case 'e':
366 logopt |= LOG_PERROR;
367 break;
368
369 case 'd':
370 daemonize = true;
371 break;
372
373 case 'p':
374 pidfile = optarg;
375 break;
376
377 case 'f':
378 client_options &= ~DHCPV6_CLIENT_FQDN;
379 break;
380
381 case 'a':
382 client_options &= ~DHCPV6_ACCEPT_RECONFIGURE;
383 break;
384
385 case 'v':
386 ++verbosity;
387 break;
388
389 case 'x':
390 res = parse_opt(optarg);
391 if (res) {
392 if (res > 0)
393 return res;
394
395 help = true;
396 }
397 break;
398
399 default:
400 help = true;
401 break;
402 }
403 }
404
405 if (allow_slaac_only > 0)
406 script_sync_delay = allow_slaac_only;
407
408 openlog("odhcp6c", logopt, LOG_DAEMON);
409 if (!verbosity)
410 setlogmask(LOG_UPTO(LOG_WARNING));
411
412 ifname = argv[optind];
413
414 if (help || !ifname)
415 return usage();
416
417 signal(SIGIO, sighandler);
418 signal(SIGHUP, sighandler);
419 signal(SIGINT, sighandler);
420 signal(SIGTERM, sighandler);
421 signal(SIGUSR1, sighandler);
422 signal(SIGUSR2, sighandler);
423
424 if ((urandom_fd = open("/dev/urandom", O_CLOEXEC | O_RDONLY)) < 0 ||
425 init_dhcpv6(ifname, client_options, sk_prio, sol_timeout) ||
426 ra_init(ifname, &ifid, ra_options, ra_holdoff_interval) ||
427 script_init(script, ifname)) {
428 syslog(LOG_ERR, "failed to initialize: %s", strerror(errno));
429 return 3;
430 }
431
432 if (daemonize) {
433 openlog("odhcp6c", LOG_PID, LOG_DAEMON); // Disable LOG_PERROR
434 if (daemon(0, 0)) {
435 syslog(LOG_ERR, "Failed to daemonize: %s",
436 strerror(errno));
437 return 4;
438 }
439
440 if (!pidfile) {
441 snprintf((char*)buf, sizeof(buf), "/var/run/odhcp6c.%s.pid", ifname);
442 pidfile = (char*)buf;
443 }
444
445 FILE *fp = fopen(pidfile, "w");
446 if (fp) {
447 fprintf(fp, "%i\n", getpid());
448 fclose(fp);
449 }
450 }
451
452 script_call("started", 0, false);
453
454 while (!signal_term) { // Main logic
455 odhcp6c_clear_state(STATE_SERVER_ID);
456 odhcp6c_clear_state(STATE_SERVER_ADDR);
457 odhcp6c_clear_state(STATE_IA_NA);
458 odhcp6c_clear_state(STATE_IA_PD);
459 odhcp6c_clear_state(STATE_SNTP_IP);
460 odhcp6c_clear_state(STATE_NTP_IP);
461 odhcp6c_clear_state(STATE_NTP_FQDN);
462 odhcp6c_clear_state(STATE_SIP_IP);
463 odhcp6c_clear_state(STATE_SIP_FQDN);
464 bound = false;
465
466 syslog(LOG_NOTICE, "(re)starting transaction on %s", ifname);
467
468 signal_usr1 = signal_usr2 = false;
469 int mode = dhcpv6_set_ia_mode(ia_na_mode, ia_pd_mode, stateful_only_mode);
470 if (mode != DHCPV6_STATELESS)
471 mode = dhcpv6_request(DHCPV6_MSG_SOLICIT);
472
473 odhcp6c_signal_process();
474
475 if (mode < 0)
476 continue;
477
478 do {
479 res = dhcpv6_request(mode == DHCPV6_STATELESS ?
480 DHCPV6_MSG_INFO_REQ : DHCPV6_MSG_REQUEST);
481 bool signalled = odhcp6c_signal_process();
482
483 if (res > 0)
484 break;
485 else if (signalled) {
486 mode = -1;
487 break;
488 }
489
490 mode = dhcpv6_promote_server_cand();
491 } while (mode > DHCPV6_UNKNOWN);
492
493 if (mode < 0)
494 continue;
495
496 switch (mode) {
497 case DHCPV6_STATELESS:
498 bound = true;
499 syslog(LOG_NOTICE, "entering stateless-mode on %s", ifname);
500
501 while (!signal_usr2 && !signal_term) {
502 signal_usr1 = false;
503 script_call("informed", script_sync_delay, true);
504
505 res = dhcpv6_poll_reconfigure();
506 odhcp6c_signal_process();
507
508 if (res > 0)
509 continue;
510
511 if (signal_usr1) {
512 signal_usr1 = false; // Acknowledged
513 continue;
514 }
515
516 if (signal_usr2 || signal_term)
517 break;
518
519 res = dhcpv6_request(DHCPV6_MSG_INFO_REQ);
520 odhcp6c_signal_process();
521
522 if (signal_usr1)
523 continue;
524 else if (res < 0)
525 break;
526 }
527 break;
528
529 case DHCPV6_STATEFUL:
530 bound = true;
531 script_call("bound", script_sync_delay, true);
532 syslog(LOG_NOTICE, "entering stateful-mode on %s", ifname);
533
534 while (!signal_usr2 && !signal_term) {
535 // Renew Cycle
536 // Wait for T1 to expire or until we get a reconfigure
537 res = dhcpv6_poll_reconfigure();
538 odhcp6c_signal_process();
539 if (res > 0) {
540 script_call("updated", 0, false);
541 continue;
542 }
543
544 // Handle signal, if necessary
545 if (signal_usr1)
546 signal_usr1 = false; // Acknowledged
547
548 if (signal_usr2 || signal_term)
549 break; // Other signal type
550
551 // Send renew as T1 expired
552 res = dhcpv6_request(DHCPV6_MSG_RENEW);
553 odhcp6c_signal_process();
554
555 if (res > 0) { // Renew was succesfull
556 // Publish updates
557 script_call("updated", 0, false);
558 continue; // Renew was successful
559 }
560
561 odhcp6c_clear_state(STATE_SERVER_ID); // Remove binding
562 odhcp6c_clear_state(STATE_SERVER_ADDR);
563
564 size_t ia_pd_len, ia_na_len;
565 odhcp6c_get_state(STATE_IA_PD, &ia_pd_len);
566 odhcp6c_get_state(STATE_IA_NA, &ia_na_len);
567
568 if (ia_pd_len == 0 && ia_na_len == 0)
569 break;
570
571 // If we have IAs, try rebind otherwise restart
572 res = dhcpv6_request(DHCPV6_MSG_REBIND);
573 odhcp6c_signal_process();
574
575 if (res > 0)
576 script_call("rebound", 0, true);
577 else
578 break;
579 }
580 break;
581
582 default:
583 break;
584 }
585
586 odhcp6c_expire(false);
587
588 size_t ia_pd_len, ia_na_len, server_id_len;
589 odhcp6c_get_state(STATE_IA_PD, &ia_pd_len);
590 odhcp6c_get_state(STATE_IA_NA, &ia_na_len);
591 odhcp6c_get_state(STATE_SERVER_ID, &server_id_len);
592
593 // Add all prefixes to lost prefixes
594 bound = false;
595 script_call("unbound", 0, true);
596
597 if (server_id_len > 0 && (ia_pd_len > 0 || ia_na_len > 0) && release)
598 dhcpv6_request(DHCPV6_MSG_RELEASE);
599
600 odhcp6c_clear_state(STATE_IA_NA);
601 odhcp6c_clear_state(STATE_IA_PD);
602 }
603
604 script_call("stopped", 0, true);
605
606 return 0;
607 }
608
609 static int usage(void)
610 {
611 const char buf[] =
612 "Usage: odhcp6c [options] <interface>\n"
613 "\nFeature options:\n"
614 " -S <time> Wait at least <time> sec for a DHCP-server (0)\n"
615 " -D Discard advertisements without any address or prefix proposed\n"
616 " -N <mode> Mode for requesting addresses [try|force|none]\n"
617 " -P <length> Request IPv6-Prefix (0 = auto)\n"
618 " -F Force IPv6-Prefix\n"
619 " -V <class> Set vendor-class option (base-16 encoded)\n"
620 " -u <user-class> Set user-class option string\n"
621 " -x <opt>:<val> Add option opt (with value val) in sent packets (cumulative)\n"
622 " Examples of IPv6 address, string and base-16 encoded options:\n"
623 " -x dns:2001:2001::1,2001:2001::2 - option 23\n"
624 " -x 15:office - option 15 (userclass)\n"
625 " -x 0x1f4:ABBA - option 500\n"
626 " -x 202:'\"file\"' - option 202\n"
627 " -c <clientid> Override client-ID (base-16 encoded 16-bit type + value)\n"
628 " -i <iface-id> Use a custom interface identifier for RA handling\n"
629 " -r <options> Options to be requested (comma-separated)\n"
630 " -R Do not request any options except those specified with -r\n"
631 " -s <script> Status update script (/usr/sbin/odhcp6c-update)\n"
632 " -a Don't send Accept Reconfigure option\n"
633 " -f Don't send Client FQDN option\n"
634 " -k Don't send a RELEASE when stopping\n"
635 " -K <sk-prio> Set packet kernel priority (0)\n"
636 " -t <seconds> Maximum timeout for DHCPv6-SOLICIT (120)\n"
637 " -m <seconds> Minimum time between accepting RA updates (3)\n"
638 " -L Ignore default lifetime for RDNSS records\n"
639 " -U Ignore Server Unicast option\n"
640 "\nInvocation options:\n"
641 " -p <pidfile> Set pidfile (/var/run/odhcp6c.pid)\n"
642 " -d Daemonize\n"
643 " -e Write logmessages to stderr\n"
644 " -v Increase logging verbosity\n"
645 " -h Show this help\n\n";
646 fputs(buf, stderr);
647
648 return 1;
649 }
650
651 // Don't want to pull-in librt and libpthread just for a monotonic clock...
652 uint64_t odhcp6c_get_milli_time(void)
653 {
654 struct timespec t;
655
656 clock_gettime(CLOCK_MONOTONIC, &t);
657
658 return ((uint64_t)t.tv_sec) * 1000 + ((uint64_t)t.tv_nsec) / 1000000;
659 }
660
661 static uint8_t* odhcp6c_resize_state(enum odhcp6c_state state, ssize_t len)
662 {
663 if (len == 0)
664 return state_data[state] + state_len[state];
665 else if (state_len[state] + len > 1024)
666 return NULL;
667
668 uint8_t *n = realloc(state_data[state], state_len[state] + len);
669
670 if (n || state_len[state] + len == 0) {
671 state_data[state] = n;
672 n += state_len[state];
673 state_len[state] += len;
674 }
675
676 return n;
677 }
678
679 bool odhcp6c_signal_process(void)
680 {
681 while (signal_io) {
682 signal_io = false;
683
684 bool ra_updated = ra_process();
685
686 if (ra_link_up()) {
687 signal_usr2 = true;
688 ra = false;
689 }
690
691 if (ra_updated && (bound || allow_slaac_only >= 0)) {
692 script_call("ra-updated", (!ra && !bound) ?
693 script_sync_delay : script_accu_delay, false);
694 ra = true;
695 }
696 }
697
698 return signal_usr1 || signal_usr2 || signal_term;
699 }
700
701 void odhcp6c_clear_state(enum odhcp6c_state state)
702 {
703 state_len[state] = 0;
704 }
705
706 int odhcp6c_add_state(enum odhcp6c_state state, const void *data, size_t len)
707 {
708 uint8_t *n = odhcp6c_resize_state(state, len);
709
710 if (!n)
711 return -1;
712
713 memcpy(n, data, len);
714
715 return 0;
716 }
717
718 int odhcp6c_insert_state(enum odhcp6c_state state, size_t offset, const void *data, size_t len)
719 {
720 ssize_t len_after = state_len[state] - offset;
721 if (len_after < 0)
722 return -1;
723
724 uint8_t *n = odhcp6c_resize_state(state, len);
725
726 if (n) {
727 uint8_t *sdata = state_data[state];
728
729 memmove(sdata + offset + len, sdata + offset, len_after);
730 memcpy(sdata + offset, data, len);
731 }
732
733 return 0;
734 }
735
736 size_t odhcp6c_remove_state(enum odhcp6c_state state, size_t offset, size_t len)
737 {
738 uint8_t *data = state_data[state];
739 ssize_t len_after = state_len[state] - (offset + len);
740
741 if (len_after < 0)
742 return state_len[state];
743
744 memmove(data + offset, data + offset + len, len_after);
745
746 return state_len[state] -= len;
747 }
748
749 void* odhcp6c_move_state(enum odhcp6c_state state, size_t *len)
750 {
751 *len = state_len[state];
752 void *data = state_data[state];
753
754 state_len[state] = 0;
755 state_data[state] = NULL;
756
757 return data;
758 }
759
760 void* odhcp6c_get_state(enum odhcp6c_state state, size_t *len)
761 {
762 *len = state_len[state];
763
764 return state_data[state];
765 }
766
767 static struct odhcp6c_entry* odhcp6c_find_entry(enum odhcp6c_state state, const struct odhcp6c_entry *new)
768 {
769 size_t len, cmplen = offsetof(struct odhcp6c_entry, target) + ((new->length + 7) / 8);
770 uint8_t *start = odhcp6c_get_state(state, &len);
771
772 for (struct odhcp6c_entry *c = (struct odhcp6c_entry*)start;
773 (uint8_t*)c < &start[len] &&
774 (uint8_t*)odhcp6c_next_entry(c) <= &start[len];
775 c = odhcp6c_next_entry(c)) {
776 if (!memcmp(c, new, cmplen) && !memcmp(c->auxtarget, new->auxtarget, new->auxlen))
777 return c;
778 }
779
780 return NULL;
781 }
782
783 bool odhcp6c_update_entry(enum odhcp6c_state state, struct odhcp6c_entry *new,
784 uint32_t safe, unsigned int holdoff_interval)
785 {
786 struct odhcp6c_entry *x = odhcp6c_find_entry(state, new);
787
788 if (x && x->valid > new->valid && new->valid < safe)
789 new->valid = safe;
790
791 if (x) {
792 if (holdoff_interval && new->valid >= x->valid &&
793 new->valid != UINT32_MAX &&
794 new->valid - x->valid < holdoff_interval &&
795 new->preferred >= x->preferred &&
796 new->preferred != UINT32_MAX &&
797 new->preferred - x->preferred < holdoff_interval)
798 return false;
799
800 x->valid = new->valid;
801 x->preferred = new->preferred;
802 x->t1 = new->t1;
803 x->t2 = new->t2;
804 x->iaid = new->iaid;
805 } else if (odhcp6c_add_state(state, new, odhcp6c_entry_size(new)))
806 return false;
807
808 return true;
809 }
810
811 static void odhcp6c_expire_list(enum odhcp6c_state state, uint32_t elapsed, bool remove_expired)
812 {
813 size_t len;
814 uint8_t *start = odhcp6c_get_state(state, &len);
815
816 for (struct odhcp6c_entry *c = (struct odhcp6c_entry*)start;
817 (uint8_t*)c < &start[len] &&
818 (uint8_t*)odhcp6c_next_entry(c) <= &start[len];
819 ) {
820 if (c->t1 < elapsed)
821 c->t1 = 0;
822 else if (c->t1 != UINT32_MAX)
823 c->t1 -= elapsed;
824
825 if (c->t2 < elapsed)
826 c->t2 = 0;
827 else if (c->t2 != UINT32_MAX)
828 c->t2 -= elapsed;
829
830 if (c->preferred < elapsed)
831 c->preferred = 0;
832 else if (c->preferred != UINT32_MAX)
833 c->preferred -= elapsed;
834
835 if (c->valid < elapsed)
836 c->valid = 0;
837 else if (c->valid != UINT32_MAX)
838 c->valid -= elapsed;
839
840 if (!c->valid && remove_expired) {
841 odhcp6c_remove_state(state, ((uint8_t*)c) - start, odhcp6c_entry_size(c));
842 start = odhcp6c_get_state(state, &len);
843 } else
844 c = odhcp6c_next_entry(c);
845 }
846 }
847
848 static uint8_t *odhcp6c_state_find_opt(const uint16_t code)
849 {
850 size_t opts_len;
851 uint8_t *odata, *opts = odhcp6c_get_state(STATE_OPTS, &opts_len);
852 uint16_t otype, olen;
853
854 dhcpv6_for_each_option(opts, &opts[opts_len], otype, olen, odata) {
855 if (otype == code)
856 return &odata[-4];
857 }
858
859 return NULL;
860 }
861
862 void odhcp6c_expire(bool expire_ia_pd)
863 {
864 time_t now = odhcp6c_get_milli_time() / 1000;
865 uint32_t elapsed = (last_update > 0) ? now - last_update : 0;
866
867 last_update = now;
868
869 odhcp6c_expire_list(STATE_RA_PREFIX, elapsed, true);
870 odhcp6c_expire_list(STATE_RA_ROUTE, elapsed, true);
871 odhcp6c_expire_list(STATE_RA_DNS, elapsed, true);
872 odhcp6c_expire_list(STATE_RA_SEARCH, elapsed, true);
873 odhcp6c_expire_list(STATE_IA_NA, elapsed, true);
874 odhcp6c_expire_list(STATE_IA_PD, elapsed, expire_ia_pd);
875 }
876
877 uint32_t odhcp6c_elapsed(void)
878 {
879 return odhcp6c_get_milli_time() / 1000 - last_update;
880 }
881
882 int odhcp6c_random(void *buf, size_t len)
883 {
884 return read(urandom_fd, buf, len);
885 }
886
887 bool odhcp6c_is_bound(void)
888 {
889 return bound;
890 }
891
892 bool odhcp6c_addr_in_scope(const struct in6_addr *addr)
893 {
894 FILE *fd = fopen("/proc/net/if_inet6", "r");
895 int len;
896 bool ret = false;
897 char buf[256];
898
899 if (fd == NULL)
900 return false;
901
902 while (fgets(buf, sizeof(buf), fd)) {
903 struct in6_addr inet6_addr;
904 uint32_t flags, dummy;
905 unsigned int i;
906 char name[IF_NAMESIZE], addr_buf[33];
907
908 len = strlen(buf);
909
910 if ((len <= 0) || buf[len - 1] != '\n')
911 break;
912
913 buf[--len] = '\0';
914
915 if (sscanf(buf, "%s %x %x %x %x %s",
916 addr_buf, &dummy, &dummy, &dummy, &flags, name) != 6)
917 break;
918
919 if (strcmp(name, ifname) ||
920 (flags & (IFA_F_DADFAILED | IFA_F_TENTATIVE | IFA_F_DEPRECATED)))
921 continue;
922
923 for (i = 0; i < strlen(addr_buf); i++) {
924 if (!isxdigit(addr_buf[i]) || isupper(addr_buf[i]))
925 break;
926 }
927
928 memset(&inet6_addr, 0, sizeof(inet6_addr));
929 for (i = 0; i < (strlen(addr_buf) / 2); i++) {
930 unsigned char byte;
931 static const char hex[] = "0123456789abcdef";
932 byte = ((index(hex, addr_buf[i * 2]) - hex) << 4) |
933 (index(hex, addr_buf[i * 2 + 1]) - hex);
934 inet6_addr.s6_addr[i] = byte;
935 }
936
937 if ((IN6_IS_ADDR_LINKLOCAL(&inet6_addr) == IN6_IS_ADDR_LINKLOCAL(addr)) &&
938 (IN6_IS_ADDR_UNIQUELOCAL(&inet6_addr) == IN6_IS_ADDR_UNIQUELOCAL(addr))) {
939 ret = true;
940 break;
941 }
942 }
943
944 fclose(fd);
945 return ret;
946 }
947
948 static void sighandler(int signal)
949 {
950 if (signal == SIGUSR1)
951 signal_usr1 = true;
952 else if (signal == SIGUSR2)
953 signal_usr2 = true;
954 else if (signal == SIGIO)
955 signal_io = true;
956 else
957 signal_term = true;
958 }
959
960 static int add_opt(const uint16_t code, const uint8_t *data, const uint16_t len)
961 {
962 struct {
963 uint16_t code;
964 uint16_t len;
965 } opt_hdr = { htons(code), htons(len) };
966
967 if (odhcp6c_state_find_opt(code))
968 return -1;
969
970 if (odhcp6c_add_state(STATE_OPTS, &opt_hdr, sizeof(opt_hdr)) ||
971 odhcp6c_add_state(STATE_OPTS, data, len)) {
972 syslog(LOG_ERR, "Failed to add option %hu", code);
973 return 1;
974 }
975
976 return 0;
977 }
978
979 struct odhcp6c_opt *odhcp6c_find_opt(const uint16_t code)
980 {
981 struct odhcp6c_opt *opt = opts;
982
983 while (opt->code) {
984 if (opt->code == code)
985 return opt;
986
987 opt++;
988 }
989
990 return NULL;
991 }
992
993 static struct odhcp6c_opt *odhcp6c_find_opt_by_name(const char *name)
994 {
995 struct odhcp6c_opt *opt = opts;
996
997 if (!name || !strlen(name))
998 return NULL;
999
1000 while (opt->code && (!opt->str || strcmp(opt->str, name)))
1001 opt++;
1002
1003 return (opt->code > 0 ? opt : NULL);
1004 }
1005
1006 static int parse_opt_u8(const char *src, uint8_t **dst)
1007 {
1008 int len = strlen(src);
1009
1010 *dst = realloc(*dst, len/2);
1011 if (!*dst)
1012 return -1;
1013
1014 return script_unhexlify(*dst, len, src);
1015 }
1016
1017 static int parse_opt_string(const char *src, uint8_t **dst, const bool array)
1018 {
1019 int o_len = 0;
1020 char *sep = strpbrk(src, ARRAY_SEP);
1021
1022 if (sep && !array)
1023 return -1;
1024
1025 do {
1026 if (sep) {
1027 *sep = 0;
1028 sep++;
1029 }
1030
1031 int len = strlen(src);
1032
1033 *dst = realloc(*dst, o_len + len);
1034 if (!*dst)
1035 return -1;
1036
1037 memcpy(&((*dst)[o_len]), src, len);
1038
1039 o_len += len;
1040 src = sep;
1041
1042 if (sep)
1043 sep = strpbrk(src, ARRAY_SEP);
1044 } while (src);
1045
1046 return o_len;
1047 }
1048
1049 static int parse_opt_dns_string(const char *src, uint8_t **dst, const bool array)
1050 {
1051 int o_len = 0;
1052 char *sep = strpbrk(src, ARRAY_SEP);
1053
1054 if (sep && !array)
1055 return -1;
1056
1057 do {
1058 uint8_t tmp[256];
1059
1060 if (sep) {
1061 *sep = 0;
1062 sep++;
1063 }
1064
1065 int len = dn_comp(src, tmp, sizeof(tmp), NULL, NULL);
1066 if (len < 0)
1067 return -1;
1068
1069 *dst = realloc(*dst, o_len + len);
1070 if (!*dst)
1071 return -1;
1072
1073 memcpy(&((*dst)[o_len]), tmp, len);
1074
1075 o_len += len;
1076 src = sep;
1077
1078 if (sep)
1079 sep = strpbrk(src, ARRAY_SEP);
1080 } while (src);
1081
1082 return o_len;
1083 }
1084
1085 static int parse_opt_ip6(const char *src, uint8_t **dst, const bool array)
1086 {
1087 int o_len = 0;
1088 char *sep = strpbrk(src, ARRAY_SEP);
1089
1090 if (sep && !array)
1091 return -1;
1092
1093 do {
1094 int len = sizeof(struct in6_addr);
1095
1096 if (sep) {
1097 *sep = 0;
1098 sep++;
1099 }
1100
1101 *dst = realloc(*dst, o_len + len);
1102 if (!*dst)
1103 return -1;
1104
1105 if (inet_pton(AF_INET6, src, &((*dst)[o_len])) < 1)
1106 return -1;
1107
1108 o_len += len;
1109 src = sep;
1110
1111 if (sep)
1112 sep = strpbrk(src, ARRAY_SEP);
1113 } while (src);
1114
1115 return o_len;
1116 }
1117
1118 static int parse_opt_user_class(const char *src, uint8_t **dst, const bool array)
1119 {
1120 int o_len = 0;
1121 char *sep = strpbrk(src, ARRAY_SEP);
1122
1123 if (sep && !array)
1124 return -1;
1125
1126 do {
1127 if (sep) {
1128 *sep = 0;
1129 sep++;
1130 }
1131 uint16_t str_len = strlen(src);
1132
1133 *dst = realloc(*dst, o_len + str_len + 2);
1134 if (!*dst)
1135 return -1;
1136
1137 struct user_class {
1138 uint16_t len;
1139 uint8_t data[];
1140 } *e = (struct user_class *)&((*dst)[o_len]);
1141
1142 e->len = ntohs(str_len);
1143 memcpy(e->data, src, str_len);
1144
1145 o_len += str_len + 2;
1146 src = sep;
1147
1148 if (sep)
1149 sep = strpbrk(src, ARRAY_SEP);
1150 } while (src);
1151
1152 return o_len;
1153 }
1154
1155 static int parse_opt_data(const char *data, uint8_t **dst, const unsigned int type,
1156 const bool array)
1157 {
1158 int ret = 0;
1159
1160 switch (type) {
1161 case OPT_U8:
1162 ret = parse_opt_u8(data, dst);
1163 break;
1164
1165 case OPT_STR:
1166 ret = parse_opt_string(data, dst, array);
1167 break;
1168
1169 case OPT_DNS_STR:
1170 ret = parse_opt_dns_string(data, dst, array);
1171 break;
1172
1173 case OPT_IP6:
1174 ret = parse_opt_ip6(data, dst, array);
1175 break;
1176
1177 case OPT_USER_CLASS:
1178 ret = parse_opt_user_class(data, dst, array);
1179 break;
1180
1181 default:
1182 ret = -1;
1183 break;
1184 }
1185
1186 return ret;
1187 }
1188
1189 static int parse_opt(const char *opt)
1190 {
1191 uint32_t optn;
1192 char *data;
1193 uint8_t *payload = NULL;
1194 int payload_len;
1195 unsigned int type = OPT_U8;
1196 bool array = false;
1197 struct odhcp6c_opt *dopt = NULL;
1198 int ret = -1;
1199
1200 data = strpbrk(opt, ":");
1201 if (!data)
1202 return -1;
1203
1204 *data = '\0';
1205 data++;
1206
1207 if (strlen(opt) == 0 || strlen(data) == 0)
1208 return -1;
1209
1210 dopt = odhcp6c_find_opt_by_name(opt);
1211 if (!dopt) {
1212 char *e;
1213 optn = strtoul(opt, &e, 0);
1214 if (*e || e == opt || optn > USHRT_MAX)
1215 return -1;
1216
1217 dopt = odhcp6c_find_opt(optn);
1218 } else
1219 optn = dopt->code;
1220
1221 /* Check if the type for the content is well-known */
1222 if (dopt) {
1223 /* Refuse internal options */
1224 if (dopt->flags & OPT_INTERNAL)
1225 return -1;
1226
1227 type = dopt->flags & OPT_MASK_SIZE;
1228 array = ((dopt->flags & OPT_ARRAY) == OPT_ARRAY) ? true : false;
1229 } else if (data[0] == '"' || data[0] == '\'') {
1230 char *end = strrchr(data + 1, data[0]);
1231
1232 if (end && (end == (data + strlen(data) - 1))) {
1233 /* Raw option is specified as a string */
1234 type = OPT_STR;
1235 data++;
1236 *end = '\0';
1237 }
1238
1239 }
1240
1241 payload_len = parse_opt_data(data, &payload, type, array);
1242 if (payload_len > 0)
1243 ret = add_opt(optn, payload, payload_len);
1244
1245 free(payload);
1246
1247 return ret;
1248 }
Openwrt DHCPv6 Client