"Robert P. J. Day" | 63fc1a9 | 2006-07-02 19:47:05 +0000 | [diff] [blame] | 1 | /* vi: set sw=4 ts=4: */ |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 2 | /* script.c |
| 3 | * |
| 4 | * Functions to call the DHCP client notification scripts |
| 5 | * |
| 6 | * Russ Dill <Russ.Dill@asu.edu> July 2001 |
| 7 | * |
Rob Landley | 3f78561 | 2006-05-28 01:06:36 +0000 | [diff] [blame] | 8 | * Licensed under GPLv2 or later, see file LICENSE in this tarball for details. |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 9 | */ |
| 10 | |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 11 | #include "common.h" |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 12 | #include "dhcpc.h" |
Denis Vlasenko | 5a3395b | 2006-11-18 19:51:32 +0000 | [diff] [blame] | 13 | #include "options.h" |
| 14 | |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 15 | |
| 16 | /* get a rough idea of how long an option will be (rounding up...) */ |
Denis Vlasenko | 3f11231 | 2007-08-19 21:21:16 +0000 | [diff] [blame] | 17 | static const uint8_t max_option_length[] = { |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 18 | [OPTION_IP] = sizeof("255.255.255.255 "), |
| 19 | [OPTION_IP_PAIR] = sizeof("255.255.255.255 ") * 2, |
| 20 | [OPTION_STRING] = 1, |
Denis Vlasenko | 5066473 | 2007-02-27 21:15:08 +0000 | [diff] [blame] | 21 | #if ENABLE_FEATURE_RFC3397 |
| 22 | [OPTION_STR1035] = 1, |
| 23 | #endif |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 24 | [OPTION_BOOLEAN] = sizeof("yes "), |
| 25 | [OPTION_U8] = sizeof("255 "), |
| 26 | [OPTION_U16] = sizeof("65535 "), |
| 27 | [OPTION_S16] = sizeof("-32768 "), |
| 28 | [OPTION_U32] = sizeof("4294967295 "), |
| 29 | [OPTION_S32] = sizeof("-2147483684 "), |
| 30 | }; |
| 31 | |
| 32 | |
| 33 | static inline int upper_length(int length, int opt_index) |
| 34 | { |
| 35 | return max_option_length[opt_index] * |
Denis Vlasenko | b539c84 | 2007-11-29 08:17:45 +0000 | [diff] [blame] | 36 | (length / dhcp_option_lengths[opt_index]); |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 37 | } |
| 38 | |
| 39 | |
Denis Vlasenko | b6aae0f | 2007-01-29 22:51:25 +0000 | [diff] [blame] | 40 | static int sprintip(char *dest, const char *pre, const uint8_t *ip) |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 41 | { |
| 42 | return sprintf(dest, "%s%d.%d.%d.%d", pre, ip[0], ip[1], ip[2], ip[3]); |
| 43 | } |
| 44 | |
| 45 | |
| 46 | /* really simple implementation, just count the bits */ |
Denis Vlasenko | 35ff746 | 2007-11-28 19:23:12 +0000 | [diff] [blame] | 47 | static int mton(uint32_t mask) |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 48 | { |
Denis Vlasenko | 35ff746 | 2007-11-28 19:23:12 +0000 | [diff] [blame] | 49 | int i = 0; |
| 50 | mask = ntohl(mask); /* 111110000-like bit pattern */ |
| 51 | while (mask) { |
| 52 | i++; |
| 53 | mask <<= 1; |
| 54 | } |
| 55 | return i; |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 56 | } |
| 57 | |
| 58 | |
Denis Vlasenko | 5066473 | 2007-02-27 21:15:08 +0000 | [diff] [blame] | 59 | /* Allocate and fill with the text of option 'option'. */ |
Denis Vlasenko | b539c84 | 2007-11-29 08:17:45 +0000 | [diff] [blame] | 60 | static char *alloc_fill_opts(uint8_t *option, const struct dhcp_option *type_p, const char *opt_name) |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 61 | { |
Denis Vlasenko | 5066473 | 2007-02-27 21:15:08 +0000 | [diff] [blame] | 62 | int len, type, optlen; |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 63 | uint16_t val_u16; |
| 64 | int16_t val_s16; |
| 65 | uint32_t val_u32; |
| 66 | int32_t val_s32; |
Denis Vlasenko | 5066473 | 2007-02-27 21:15:08 +0000 | [diff] [blame] | 67 | char *dest, *ret; |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 68 | |
Denis Vlasenko | 5066473 | 2007-02-27 21:15:08 +0000 | [diff] [blame] | 69 | len = option[OPT_LEN - 2]; |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 70 | type = type_p->flags & TYPE_MASK; |
Denis Vlasenko | b539c84 | 2007-11-29 08:17:45 +0000 | [diff] [blame] | 71 | optlen = dhcp_option_lengths[type]; |
Denis Vlasenko | 5066473 | 2007-02-27 21:15:08 +0000 | [diff] [blame] | 72 | |
Denis Vlasenko | b539c84 | 2007-11-29 08:17:45 +0000 | [diff] [blame] | 73 | dest = ret = xmalloc(upper_length(len, type) + strlen(opt_name) + 2); |
| 74 | dest += sprintf(ret, "%s=", opt_name); |
Denis Vlasenko | 5066473 | 2007-02-27 21:15:08 +0000 | [diff] [blame] | 75 | |
Denis Vlasenko | 5a3395b | 2006-11-18 19:51:32 +0000 | [diff] [blame] | 76 | for (;;) { |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 77 | switch (type) { |
| 78 | case OPTION_IP_PAIR: |
| 79 | dest += sprintip(dest, "", option); |
Denis Vlasenko | fbd2918 | 2007-04-07 01:05:47 +0000 | [diff] [blame] | 80 | *dest++ = '/'; |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 81 | option += 4; |
| 82 | optlen = 4; |
| 83 | case OPTION_IP: /* Works regardless of host byte order. */ |
| 84 | dest += sprintip(dest, "", option); |
| 85 | break; |
| 86 | case OPTION_BOOLEAN: |
| 87 | dest += sprintf(dest, *option ? "yes" : "no"); |
| 88 | break; |
| 89 | case OPTION_U8: |
| 90 | dest += sprintf(dest, "%u", *option); |
| 91 | break; |
| 92 | case OPTION_U16: |
| 93 | memcpy(&val_u16, option, 2); |
| 94 | dest += sprintf(dest, "%u", ntohs(val_u16)); |
| 95 | break; |
| 96 | case OPTION_S16: |
| 97 | memcpy(&val_s16, option, 2); |
| 98 | dest += sprintf(dest, "%d", ntohs(val_s16)); |
| 99 | break; |
| 100 | case OPTION_U32: |
| 101 | memcpy(&val_u32, option, 4); |
| 102 | dest += sprintf(dest, "%lu", (unsigned long) ntohl(val_u32)); |
| 103 | break; |
| 104 | case OPTION_S32: |
| 105 | memcpy(&val_s32, option, 4); |
| 106 | dest += sprintf(dest, "%ld", (long) ntohl(val_s32)); |
| 107 | break; |
| 108 | case OPTION_STRING: |
| 109 | memcpy(dest, option, len); |
| 110 | dest[len] = '\0'; |
Denis Vlasenko | 5066473 | 2007-02-27 21:15:08 +0000 | [diff] [blame] | 111 | return ret; /* Short circuit this case */ |
| 112 | #if ENABLE_FEATURE_RFC3397 |
| 113 | case OPTION_STR1035: |
| 114 | /* unpack option into dest; use ret for prefix (i.e., "optname=") */ |
| 115 | dest = dname_dec(option, len, ret); |
| 116 | free(ret); |
| 117 | return dest; |
| 118 | #endif |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 119 | } |
| 120 | option += optlen; |
| 121 | len -= optlen; |
| 122 | if (len <= 0) break; |
| 123 | dest += sprintf(dest, " "); |
| 124 | } |
Denis Vlasenko | 5066473 | 2007-02-27 21:15:08 +0000 | [diff] [blame] | 125 | return ret; |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 126 | } |
| 127 | |
| 128 | |
| 129 | /* put all the parameters into an environment */ |
| 130 | static char **fill_envp(struct dhcpMessage *packet) |
| 131 | { |
| 132 | int num_options = 0; |
| 133 | int i, j; |
| 134 | char **envp; |
Denis Vlasenko | fbd2918 | 2007-04-07 01:05:47 +0000 | [diff] [blame] | 135 | char *var; |
Denis Vlasenko | b539c84 | 2007-11-29 08:17:45 +0000 | [diff] [blame] | 136 | const char *opt_name; |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 137 | uint8_t *temp; |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 138 | char over = 0; |
| 139 | |
Denis Vlasenko | fbd2918 | 2007-04-07 01:05:47 +0000 | [diff] [blame] | 140 | if (packet) { |
| 141 | for (i = 0; dhcp_options[i].code; i++) { |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 142 | if (get_option(packet, dhcp_options[i].code)) { |
| 143 | num_options++; |
| 144 | if (dhcp_options[i].code == DHCP_SUBNET) |
| 145 | num_options++; /* for mton */ |
| 146 | } |
Denis Vlasenko | fbd2918 | 2007-04-07 01:05:47 +0000 | [diff] [blame] | 147 | } |
| 148 | if (packet->siaddr) |
| 149 | num_options++; |
| 150 | temp = get_option(packet, DHCP_OPTION_OVER); |
| 151 | if (temp) |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 152 | over = *temp; |
Denis Vlasenko | fbd2918 | 2007-04-07 01:05:47 +0000 | [diff] [blame] | 153 | if (!(over & FILE_FIELD) && packet->file[0]) |
| 154 | num_options++; |
| 155 | if (!(over & SNAME_FIELD) && packet->sname[0]) |
| 156 | num_options++; |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 157 | } |
| 158 | |
Rob Landley | 9ffd423 | 2006-05-21 18:30:35 +0000 | [diff] [blame] | 159 | envp = xzalloc(sizeof(char *) * (num_options + 5)); |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 160 | j = 0; |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 161 | envp[j++] = xasprintf("interface=%s", client_config.interface); |
Denis Vlasenko | fbd2918 | 2007-04-07 01:05:47 +0000 | [diff] [blame] | 162 | var = getenv("PATH"); |
| 163 | if (var) |
| 164 | envp[j++] = xasprintf("PATH=%s", var); |
| 165 | var = getenv("HOME"); |
| 166 | if (var) |
| 167 | envp[j++] = xasprintf("HOME=%s", var); |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 168 | |
Denis Vlasenko | fbd2918 | 2007-04-07 01:05:47 +0000 | [diff] [blame] | 169 | if (packet == NULL) |
| 170 | return envp; |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 171 | |
| 172 | envp[j] = xmalloc(sizeof("ip=255.255.255.255")); |
| 173 | sprintip(envp[j++], "ip=", (uint8_t *) &packet->yiaddr); |
| 174 | |
Denis Vlasenko | b539c84 | 2007-11-29 08:17:45 +0000 | [diff] [blame] | 175 | opt_name = dhcp_option_strings; |
| 176 | i = 0; |
| 177 | while (*opt_name) { |
Denis Vlasenko | c90c3f3 | 2006-11-23 12:57:49 +0000 | [diff] [blame] | 178 | temp = get_option(packet, dhcp_options[i].code); |
Denis Vlasenko | c2f5b02 | 2006-11-28 00:21:46 +0000 | [diff] [blame] | 179 | if (!temp) |
Denis Vlasenko | b539c84 | 2007-11-29 08:17:45 +0000 | [diff] [blame] | 180 | goto next; |
| 181 | envp[j++] = alloc_fill_opts(temp, &dhcp_options[i], opt_name); |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 182 | |
| 183 | /* Fill in a subnet bits option for things like /24 */ |
| 184 | if (dhcp_options[i].code == DHCP_SUBNET) { |
Denis Vlasenko | 35ff746 | 2007-11-28 19:23:12 +0000 | [diff] [blame] | 185 | uint32_t subnet; |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 186 | memcpy(&subnet, temp, 4); |
Denis Vlasenko | 35ff746 | 2007-11-28 19:23:12 +0000 | [diff] [blame] | 187 | envp[j++] = xasprintf("mask=%d", mton(subnet)); |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 188 | } |
Denis Vlasenko | b539c84 | 2007-11-29 08:17:45 +0000 | [diff] [blame] | 189 | next: |
| 190 | opt_name += strlen(opt_name) + 1; |
| 191 | i++; |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 192 | } |
| 193 | if (packet->siaddr) { |
| 194 | envp[j] = xmalloc(sizeof("siaddr=255.255.255.255")); |
| 195 | sprintip(envp[j++], "siaddr=", (uint8_t *) &packet->siaddr); |
| 196 | } |
| 197 | if (!(over & FILE_FIELD) && packet->file[0]) { |
| 198 | /* watch out for invalid packets */ |
| 199 | packet->file[sizeof(packet->file) - 1] = '\0'; |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 200 | envp[j++] = xasprintf("boot_file=%s", packet->file); |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 201 | } |
| 202 | if (!(over & SNAME_FIELD) && packet->sname[0]) { |
| 203 | /* watch out for invalid packets */ |
| 204 | packet->sname[sizeof(packet->sname) - 1] = '\0'; |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 205 | envp[j++] = xasprintf("sname=%s", packet->sname); |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 206 | } |
| 207 | return envp; |
| 208 | } |
| 209 | |
| 210 | |
| 211 | /* Call a script with a par file and env vars */ |
Rob Landley | 3f78561 | 2006-05-28 01:06:36 +0000 | [diff] [blame] | 212 | void udhcp_run_script(struct dhcpMessage *packet, const char *name) |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 213 | { |
| 214 | int pid; |
| 215 | char **envp, **curr; |
| 216 | |
| 217 | if (client_config.script == NULL) |
| 218 | return; |
| 219 | |
Denis Vlasenko | 3538b9a | 2006-09-06 18:36:50 +0000 | [diff] [blame] | 220 | DEBUG("vfork'ing and execle'ing %s", client_config.script); |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 221 | |
| 222 | envp = fill_envp(packet); |
Denis Vlasenko | fbd2918 | 2007-04-07 01:05:47 +0000 | [diff] [blame] | 223 | |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 224 | /* call script */ |
Denis Vlasenko | fbd2918 | 2007-04-07 01:05:47 +0000 | [diff] [blame] | 225 | // can we use wait4pid(spawn(...)) here? |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 226 | pid = vfork(); |
Denis Vlasenko | fbd2918 | 2007-04-07 01:05:47 +0000 | [diff] [blame] | 227 | if (pid < 0) return; |
| 228 | if (pid == 0) { |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 229 | /* close fd's? */ |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 230 | /* exec script */ |
| 231 | execle(client_config.script, client_config.script, |
| 232 | name, NULL, envp); |
Denis Vlasenko | fbd2918 | 2007-04-07 01:05:47 +0000 | [diff] [blame] | 233 | bb_perror_msg_and_die("script %s failed", client_config.script); |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 234 | } |
Denis Vlasenko | fb0eba7 | 2008-01-02 19:55:04 +0000 | [diff] [blame^] | 235 | safe_waitpid(pid, NULL, 0); |
Denis Vlasenko | fbd2918 | 2007-04-07 01:05:47 +0000 | [diff] [blame] | 236 | for (curr = envp; *curr; curr++) |
| 237 | free(*curr); |
| 238 | free(envp); |
Mike Frysinger | 7031f62 | 2006-05-08 03:20:50 +0000 | [diff] [blame] | 239 | } |