• source navigation  • diff markup  • identifier search  • freetext search  • 

Sources/odhcp6c/src/script.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 <stdio.h>
 17 #include <netdb.h>
 18 #include <resolv.h>
 19 #include <stdlib.h>
 20 #include <string.h>
 21 #include <syslog.h>
 22 #include <signal.h>
 23 #include <unistd.h>
 24 #include <inttypes.h>
 25 #include <arpa/inet.h>
 26 #include <sys/wait.h>
 27 #include <netinet/in.h>
 28 
 29 #include "odhcp6c.h"
 30 
 31 static const char hexdigits[] = "0123456789abcdef";
 32 static const int8_t hexvals[] = {
 33     -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -2, -1, -1, -2, -1, -1,
 34     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 35     -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 36      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,
 37     -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 38     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 39     -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 40     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 41 };
 42 
 43 static char action[16] = "";
 44 static char *argv[4] = {NULL, NULL, action, NULL};
 45 static volatile pid_t running = 0;
 46 static time_t started;
 47 
 48 static void script_sighandle(int signal)
 49 {
 50         if (signal == SIGCHLD) {
 51                 pid_t child;
 52 
 53                 while ((child = waitpid(-1, NULL, WNOHANG)) > 0)
 54                         if (running == child)
 55                                 running = 0;
 56         }
 57 }
 58 
 59 int script_init(const char *path, const char *ifname)
 60 {
 61         argv[0] = (char*)path;
 62         argv[1] = (char*)ifname;
 63         signal(SIGCHLD, script_sighandle);
 64 
 65         return 0;
 66 }
 67 
 68 ssize_t script_unhexlify(uint8_t *dst, size_t len, const char *src)
 69 {
 70         size_t c;
 71 
 72         for (c = 0; c < len && src[0] && src[1]; ++c) {
 73                 int8_t x = (int8_t)*src++;
 74                 int8_t y = (int8_t)*src++;
 75                 if (x < 0 || (x = hexvals[x]) < 0
 76                                 || y < 0 || (y = hexvals[y]) < 0)
 77                         return -1;
 78                 dst[c] = x << 4 | y;
 79                 while (((int8_t)*src) < 0 ||
 80                                 (*src && hexvals[(uint8_t)*src] < 0))
 81                         src++;
 82         }
 83 
 84         return c;
 85 }
 86 
 87 static void script_hexlify(char *dst, const uint8_t *src, size_t len)
 88 {
 89         for (size_t i = 0; i < len; ++i) {
 90                 *dst++ = hexdigits[src[i] >> 4];
 91                 *dst++ = hexdigits[src[i] & 0x0f];
 92         }
 93 
 94         *dst = 0;
 95 }
 96 
 97 static void ipv6_to_env(const char *name,
 98                 const struct in6_addr *addr, size_t cnt)
 99 {
100         size_t buf_len = strlen(name);
101         char *buf = realloc(NULL, cnt * INET6_ADDRSTRLEN + buf_len + 2);
102 
103         memcpy(buf, name, buf_len);
104         buf[buf_len++] = '=';
105 
106         for (size_t i = 0; i < cnt; ++i) {
107                 inet_ntop(AF_INET6, &addr[i], &buf[buf_len], INET6_ADDRSTRLEN);
108                 buf_len += strlen(&buf[buf_len]);
109                 buf[buf_len++] = ' ';
110         }
111 
112         if (buf[buf_len - 1] == ' ')
113                 buf_len--;
114 
115         buf[buf_len] = '\0';
116         putenv(buf);
117 }
118 
119 static void fqdn_to_env(const char *name, const uint8_t *fqdn, size_t len)
120 {
121         size_t buf_len = strlen(name);
122         size_t buf_size = len + buf_len + 2;
123         const uint8_t *fqdn_end = fqdn + len;
124         char *buf = realloc(NULL, len + buf_len + 2);
125 
126         memcpy(buf, name, buf_len);
127         buf[buf_len++] = '=';
128 
129         while (fqdn < fqdn_end) {
130                 int l = dn_expand(fqdn, fqdn_end, fqdn, &buf[buf_len], buf_size - buf_len);
131                 if (l <= 0)
132                         break;
133                 fqdn += l;
134                 buf_len += strlen(&buf[buf_len]);
135                 buf[buf_len++] = ' ';
136         }
137 
138         if (buf[buf_len - 1] == ' ')
139                 buf_len--;
140 
141         buf[buf_len] = '\0';
142         putenv(buf);
143 }
144 
145 static void bin_to_env(uint8_t *opts, size_t len)
146 {
147         uint8_t *oend = opts + len, *odata;
148         uint16_t otype, olen;
149 
150         dhcpv6_for_each_option(opts, oend, otype, olen, odata) {
151                 char *buf = realloc(NULL, 14 + (olen * 2));
152                 size_t buf_len = 0;
153 
154                 snprintf(buf, 14, "OPTION_%hu=", otype);
155                 buf_len += strlen(buf);
156 
157                 script_hexlify(&buf[buf_len], odata, olen);
158                 putenv(buf);
159         }
160 }
161 
162 enum entry_type {
163         ENTRY_ADDRESS,
164         ENTRY_HOST,
165         ENTRY_ROUTE,
166         ENTRY_PREFIX
167 };
168 
169 static void entry_to_env(const char *name, const void *data, size_t len, enum entry_type type)
170 {
171         size_t buf_len = strlen(name);
172         const struct odhcp6c_entry *e = data;
173         // Worst case: ENTRY_PREFIX with iaid != 1 and exclusion
174         const size_t max_entry_len = (INET6_ADDRSTRLEN-1 + 5 + 22 + 15 + 10 +
175                                       INET6_ADDRSTRLEN-1 + 11 + 1);
176         char *buf = realloc(NULL, buf_len + 2 + (len / sizeof(*e)) * max_entry_len);
177 
178         memcpy(buf, name, buf_len);
179         buf[buf_len++] = '=';
180 
181         for (size_t i = 0; i < len / sizeof(*e); ++i) {
182                 inet_ntop(AF_INET6, &e[i].target, &buf[buf_len], INET6_ADDRSTRLEN);
183                 buf_len += strlen(&buf[buf_len]);
184 
185                 if (type != ENTRY_HOST) {
186                         snprintf(&buf[buf_len], 6, "/%"PRIu16, e[i].length);
187                         buf_len += strlen(&buf[buf_len]);
188 
189                         if (type == ENTRY_ROUTE) {
190                                 buf[buf_len++] = ',';
191 
192                                 if (!IN6_IS_ADDR_UNSPECIFIED(&e[i].router)) {
193                                         inet_ntop(AF_INET6, &e[i].router, &buf[buf_len], INET6_ADDRSTRLEN);
194                                         buf_len += strlen(&buf[buf_len]);
195                                 }
196 
197                                 snprintf(&buf[buf_len], 23, ",%u,%u", e[i].valid, e[i].priority);
198                                 buf_len += strlen(&buf[buf_len]);
199                         } else {
200                                 snprintf(&buf[buf_len], 23, ",%u,%u", e[i].preferred, e[i].valid);
201                                 buf_len += strlen(&buf[buf_len]);
202                         }
203 
204                         if (type == ENTRY_PREFIX && ntohl(e[i].iaid) != 1) {
205                                 snprintf(&buf[buf_len], 16, ",class=%08x", ntohl(e[i].iaid));
206                                 buf_len += strlen(&buf[buf_len]);
207                         }
208 
209                         if (type == ENTRY_PREFIX && e[i].priority) {
210                                 // priority and router are abused for prefix exclusion
211                                 snprintf(&buf[buf_len], 11, ",excluded=");
212                                 buf_len += strlen(&buf[buf_len]);
213                                 inet_ntop(AF_INET6, &e[i].router, &buf[buf_len], INET6_ADDRSTRLEN);
214                                 buf_len += strlen(&buf[buf_len]);
215                                 snprintf(&buf[buf_len], 12, "/%u", e[i].priority);
216                                 buf_len += strlen(&buf[buf_len]);
217                         }
218                 }
219 
220                 buf[buf_len++] = ' ';
221         }
222 
223         if (buf[buf_len - 1] == ' ')
224                 buf_len--;
225 
226         buf[buf_len] = '\0';
227         putenv(buf);
228 }
229 
230 static void search_to_env(const char *name, const uint8_t *start, size_t len)
231 {
232         size_t buf_len = strlen(name);
233         char *buf = realloc(NULL, buf_len + 2 + len);
234         char *c = mempcpy(buf, name, buf_len);
235         *c++ = '=';
236 
237         for (struct odhcp6c_entry *e = (struct odhcp6c_entry*)start;
238                                 (uint8_t*)e < &start[len] &&
239                                 (uint8_t*)odhcp6c_next_entry(e) <= &start[len];
240                                 e = odhcp6c_next_entry(e)) {
241                 c = mempcpy(c, e->auxtarget, e->auxlen);
242                 *c++ = ' ';
243         }
244 
245         if (c[-1] == ' ')
246                 c--;
247 
248         *c = '\0';
249         putenv(buf);
250 }
251 
252 static void int_to_env(const char *name, int value)
253 {
254         size_t len = 13 + strlen(name);
255         char *buf = realloc(NULL, len);
256 
257         snprintf(buf, len, "%s=%d", name, value);
258         putenv(buf);
259 }
260 
261 static void s46_to_env_portparams(const uint8_t *data, size_t len, FILE *fp)
262 {
263         uint8_t *odata;
264         uint16_t otype, olen;
265 
266         dhcpv6_for_each_option(data, &data[len], otype, olen, odata) {
267                 if (otype == DHCPV6_OPT_S46_PORTPARAMS &&
268                                 olen == sizeof(struct dhcpv6_s46_portparams)) {
269                         struct dhcpv6_s46_portparams *params = (void*)odata;
270                         fprintf(fp, "offset=%d,psidlen=%d,psid=%d,",
271                                         params->offset, params->psid_len, ntohs(params->psid));
272                 }
273         }
274 }
275 
276 static void s46_to_env(enum odhcp6c_state state, const uint8_t *data, size_t len)
277 {
278         const char *name = (state == STATE_S46_MAPE) ? "MAPE" :
279                         (state == STATE_S46_MAPT) ? "MAPT" : "LW4O6";
280 
281         if (len == 0)
282                 return;
283 
284         char *str;
285         size_t strsize;
286 
287         FILE *fp = open_memstream(&str, &strsize);
288         fputs(name, fp);
289         fputc('=', fp);
290 
291         const char *type = (state == STATE_S46_MAPE) ? "map-e" :
292                         (state == STATE_S46_MAPT) ? "map-t" : "lw4o6";
293 
294         uint8_t *odata;
295         uint16_t otype, olen;
296 
297         dhcpv6_for_each_option(data, &data[len], otype, olen, odata) {
298                 struct dhcpv6_s46_rule *rule = (struct dhcpv6_s46_rule*)odata;
299                 struct dhcpv6_s46_v4v6bind *bind = (struct dhcpv6_s46_v4v6bind*)odata;
300 
301                 if (state != STATE_S46_LW && otype == DHCPV6_OPT_S46_RULE &&
302                                 olen >= sizeof(struct dhcpv6_s46_rule)) {
303                         char buf4[INET_ADDRSTRLEN];
304                         char buf6[INET6_ADDRSTRLEN];
305                         struct in6_addr in6 = IN6ADDR_ANY_INIT;
306 
307                         size_t prefix6len = rule->prefix6_len;
308                         prefix6len = (prefix6len % 8 == 0) ? prefix6len / 8 : prefix6len / 8 + 1;
309 
310                         if (prefix6len > sizeof(in6) ||
311                             olen < sizeof(struct dhcpv6_s46_rule) + prefix6len)
312                                 continue;
313 
314                         memcpy(&in6, rule->ipv6_prefix, prefix6len);
315 
316                         inet_ntop(AF_INET, &rule->ipv4_prefix, buf4, sizeof(buf4));
317                         inet_ntop(AF_INET6, &in6, buf6, sizeof(buf6));
318 
319                         if (rule->flags & 1)
320                                 fputs("fmr,", fp);
321 
322                         fprintf(fp, "type=%s,ealen=%d,prefix4len=%d,prefix6len=%d,ipv4prefix=%s,ipv6prefix=%s,",
323                                         type, rule->ea_len, rule->prefix4_len, rule->prefix6_len, buf4, buf6);
324 
325                         s46_to_env_portparams(&rule->ipv6_prefix[prefix6len],
326                                         olen - sizeof(*rule) - prefix6len, fp);
327 
328                         dhcpv6_for_each_option(data, &data[len], otype, olen, odata) {
329                                 if (state != STATE_S46_MAPT && otype == DHCPV6_OPT_S46_BR &&
330                                                 olen == sizeof(struct in6_addr)) {
331                                         inet_ntop(AF_INET6, odata, buf6, sizeof(buf6));
332                                         fprintf(fp, "br=%s,", buf6);
333                                 } else if (state == STATE_S46_MAPT && otype == DHCPV6_OPT_S46_DMR &&
334                                                 olen >= sizeof(struct dhcpv6_s46_dmr)) {
335                                         struct dhcpv6_s46_dmr *dmr = (struct dhcpv6_s46_dmr*)odata;
336                                         memset(&in6, 0, sizeof(in6));
337                                         size_t prefix6len = dmr->dmr_prefix6_len;
338                                         prefix6len = (prefix6len % 8 == 0) ? prefix6len / 8 : prefix6len / 8 + 1;
339 
340                                         if (prefix6len > sizeof(in6) ||
341                                             olen < sizeof(struct dhcpv6_s46_dmr) + prefix6len)
342                                                 continue;
343 
344                                         memcpy(&in6, dmr->dmr_ipv6_prefix, prefix6len);
345                                         inet_ntop(AF_INET6, &in6, buf6, sizeof(buf6));
346                                         fprintf(fp, "dmr=%s/%d,", buf6, dmr->dmr_prefix6_len);
347                                 }
348                         }
349 
350                         fputc(' ', fp);
351                 } else if (state == STATE_S46_LW && otype == DHCPV6_OPT_S46_V4V6BIND &&
352                                 olen >= sizeof(struct dhcpv6_s46_v4v6bind)) {
353                         char buf4[INET_ADDRSTRLEN];
354                         char buf6[INET6_ADDRSTRLEN];
355                         struct in6_addr in6 = IN6ADDR_ANY_INIT;
356 
357                         size_t prefix6len = bind->bindprefix6_len;
358                         prefix6len = (prefix6len % 8 == 0) ? prefix6len / 8 : prefix6len / 8 + 1;
359 
360                         if (prefix6len > sizeof(in6) ||
361                             olen < sizeof(struct dhcpv6_s46_v4v6bind) + prefix6len)
362                                 continue;
363 
364                         memcpy(&in6, bind->bind_ipv6_prefix, prefix6len);
365 
366                         inet_ntop(AF_INET, &bind->ipv4_address, buf4, sizeof(buf4));
367                         inet_ntop(AF_INET6, &in6, buf6, sizeof(buf6));
368 
369                         fprintf(fp, "type=%s,prefix4len=32,prefix6len=%d,ipv4prefix=%s,ipv6prefix=%s,",
370                                         type, bind->bindprefix6_len, buf4, buf6);
371 
372                         s46_to_env_portparams(&bind->bind_ipv6_prefix[prefix6len],
373                                         olen - sizeof(*bind) - prefix6len, fp);
374 
375                         dhcpv6_for_each_option(data, &data[len], otype, olen, odata) {
376                                 if (otype == DHCPV6_OPT_S46_BR && olen == sizeof(struct in6_addr)) {
377                                         inet_ntop(AF_INET6, odata, buf6, sizeof(buf6));
378                                         fprintf(fp, "br=%s,", buf6);
379                                 }
380                         }
381 
382                         fputc(' ', fp);
383                 }
384         }
385 
386         fclose(fp);
387         putenv(str);
388 }
389 
390 void script_call(const char *status, int delay, bool resume)
391 {
392         time_t now = odhcp6c_get_milli_time() / 1000;
393         bool running_script = false;
394 
395         if (running) {
396                 time_t diff = now - started;
397 
398                 kill(running, SIGTERM);
399 
400                 if (diff > delay)
401                         delay -= diff;
402                 else
403                         delay = 0;
404 
405                 running_script = true;
406         }
407 
408         if (resume || !running_script || !action[0])
409                 strncpy(action, status, sizeof(action) - 1);
410 
411         pid_t pid = fork();
412 
413         if (pid > 0) {
414                 running = pid;
415                 started = now;
416 
417                 if (!resume)
418                         action[0] = 0;
419 
420         } else if (pid == 0) {
421                 size_t dns_len, search_len, custom_len, sntp_ip_len, ntp_ip_len, ntp_dns_len;
422                 size_t sip_ip_len, sip_fqdn_len, aftr_name_len, cer_len, addr_len;
423                 size_t s46_mapt_len, s46_mape_len, s46_lw_len, passthru_len;
424 
425                 signal(SIGTERM, SIG_DFL);
426                 if (delay > 0) {
427                         sleep(delay);
428                         odhcp6c_expire();
429                 }
430 
431                 struct in6_addr *addr = odhcp6c_get_state(STATE_SERVER_ADDR, &addr_len);
432                 struct in6_addr *dns = odhcp6c_get_state(STATE_DNS, &dns_len);
433                 uint8_t *search = odhcp6c_get_state(STATE_SEARCH, &search_len);
434                 uint8_t *custom = odhcp6c_get_state(STATE_CUSTOM_OPTS, &custom_len);
435                 struct in6_addr *sntp = odhcp6c_get_state(STATE_SNTP_IP, &sntp_ip_len);
436                 struct in6_addr *ntp = odhcp6c_get_state(STATE_NTP_IP, &ntp_ip_len);
437                 uint8_t *ntp_dns = odhcp6c_get_state(STATE_NTP_FQDN, &ntp_dns_len);
438                 struct in6_addr *sip = odhcp6c_get_state(STATE_SIP_IP, &sip_ip_len);
439                 uint8_t *sip_fqdn = odhcp6c_get_state(STATE_SIP_FQDN, &sip_fqdn_len);
440                 uint8_t *aftr_name = odhcp6c_get_state(STATE_AFTR_NAME, &aftr_name_len);
441                 struct in6_addr *cer = odhcp6c_get_state(STATE_CER, &cer_len);
442                 uint8_t *s46_mapt = odhcp6c_get_state(STATE_S46_MAPT, &s46_mapt_len);
443                 uint8_t *s46_mape = odhcp6c_get_state(STATE_S46_MAPE, &s46_mape_len);
444                 uint8_t *s46_lw = odhcp6c_get_state(STATE_S46_LW, &s46_lw_len);
445                 uint8_t *passthru = odhcp6c_get_state(STATE_PASSTHRU, &passthru_len);
446 
447                 size_t prefix_len, address_len, ra_pref_len,
448                         ra_route_len, ra_dns_len, ra_search_len;
449                 uint8_t *prefix = odhcp6c_get_state(STATE_IA_PD, &prefix_len);
450                 uint8_t *address = odhcp6c_get_state(STATE_IA_NA, &address_len);
451                 uint8_t *ra_pref = odhcp6c_get_state(STATE_RA_PREFIX, &ra_pref_len);
452                 uint8_t *ra_route = odhcp6c_get_state(STATE_RA_ROUTE, &ra_route_len);
453                 uint8_t *ra_dns = odhcp6c_get_state(STATE_RA_DNS, &ra_dns_len);
454                 uint8_t *ra_search = odhcp6c_get_state(STATE_RA_SEARCH, &ra_search_len);
455 
456                 ipv6_to_env("SERVER", addr, addr_len / sizeof(*addr));
457                 ipv6_to_env("RDNSS", dns, dns_len / sizeof(*dns));
458                 ipv6_to_env("SNTP_IP", sntp, sntp_ip_len / sizeof(*sntp));
459                 ipv6_to_env("NTP_IP", ntp, ntp_ip_len / sizeof(*ntp));
460                 fqdn_to_env("NTP_FQDN", ntp_dns, ntp_dns_len);
461                 ipv6_to_env("SIP_IP", sip, sip_ip_len / sizeof(*sip));
462                 fqdn_to_env("DOMAINS", search, search_len);
463                 fqdn_to_env("SIP_DOMAIN", sip_fqdn, sip_fqdn_len);
464                 fqdn_to_env("AFTR", aftr_name, aftr_name_len);
465                 ipv6_to_env("CER", cer, cer_len / sizeof(*cer));
466                 s46_to_env(STATE_S46_MAPE, s46_mape, s46_mape_len);
467                 s46_to_env(STATE_S46_MAPT, s46_mapt, s46_mapt_len);
468                 s46_to_env(STATE_S46_LW, s46_lw, s46_lw_len);
469                 bin_to_env(custom, custom_len);
470 
471                 if (odhcp6c_is_bound()) {
472                         entry_to_env("PREFIXES", prefix, prefix_len, ENTRY_PREFIX);
473                         entry_to_env("ADDRESSES", address, address_len, ENTRY_ADDRESS);
474                 }
475 
476                 entry_to_env("RA_ADDRESSES", ra_pref, ra_pref_len, ENTRY_ADDRESS);
477                 entry_to_env("RA_ROUTES", ra_route, ra_route_len, ENTRY_ROUTE);
478                 entry_to_env("RA_DNS", ra_dns, ra_dns_len, ENTRY_HOST);
479                 search_to_env("RA_DOMAINS", ra_search, ra_search_len);
480 
481                 int_to_env("RA_HOPLIMIT", ra_get_hoplimit());
482                 int_to_env("RA_MTU", ra_get_mtu());
483                 int_to_env("RA_REACHABLE", ra_get_reachable());
484                 int_to_env("RA_RETRANSMIT", ra_get_retransmit());
485 
486                 char *buf = malloc(10 + passthru_len * 2);
487                 strncpy(buf, "PASSTHRU=", 10);
488                 script_hexlify(&buf[9], passthru, passthru_len);
489                 putenv(buf);
490 
491                 execv(argv[0], argv);
492                 _exit(128);
493         }
494 }
495 

This page was automatically generated by LXR 0.3.1.  •  OpenWrt