git.maemo.org Git - udhcp/blob - script.c

   1 /* script.c
   2  *
   3  * Functions to call the DHCP client notification scripts
   4  *
   5  * Russ Dill <Russ.Dill@asu.edu> July 2001
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include <string.h>
  23 #include <unistd.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <sys/socket.h>
  27 #include <netinet/in.h>
  28 #include <arpa/inet.h>
  29 #include <sys/types.h>
  30 #include <sys/wait.h>
  31
  32 #include "options.h"
  33 #include "dhcpd.h"
  34 #include "dhcpc.h"
  35 #include "common.h"
  36
  37 /* get a rough idea of how long an option will be (rounding up...) */
  38 static const int max_option_length[] = {
  39         [OPTION_IP] =           sizeof("255.255.255.255 "),
  40         [OPTION_IP_PAIR] =      sizeof("255.255.255.255 ") * 2,
  41         [OPTION_STRING] =       1,
  42         [OPTION_BOOLEAN] =      sizeof("yes "),
  43         [OPTION_U8] =           sizeof("255 "),
  44         [OPTION_U16] =          sizeof("65535 "),
  45         [OPTION_S16] =          sizeof("-32768 "),
  46         [OPTION_U32] =          sizeof("4294967295 "),
  47         [OPTION_S32] =          sizeof("-2147483684 "),
  48 };
  49
  50
  51 static inline int upper_length(int length, int opt_index)
  52 {
  53         return max_option_length[opt_index] *
  54                 (length / option_lengths[opt_index]);
  55 }
  56
  57
  58 static int sprintip(char *dest, char *pre, uint8_t *ip)
  59 {
  60         return sprintf(dest, "%s%d.%d.%d.%d", pre, ip[0], ip[1], ip[2], ip[3]);
  61 }
  62
  63
  64 /* really simple implementation, just count the bits */
  65 static int mton(struct in_addr *mask)
  66 {
  67         int i;
  68         unsigned long bits = ntohl(mask->s_addr);
  69         /* too bad one can't check the carry bit, etc in c bit
  70          * shifting */
  71         for (i = 0; i < 32 && !((bits >> i) & 1); i++);
  72         return 32 - i;
  73 }
  74
  75
  76 /* Fill dest with the text of option 'option'. */
  77 static void fill_options(char *dest, uint8_t *option, struct dhcp_option *type_p)
  78 {
  79         int type, optlen;
  80         uint16_t val_u16;
  81         int16_t val_s16;
  82         uint32_t val_u32;
  83         int32_t val_s32;
  84         int len = option[OPT_LEN - 2];
  85
  86         dest += sprintf(dest, "%s=", type_p->name);
  87
  88         type = type_p->flags & TYPE_MASK;
  89         optlen = option_lengths[type];
  90         for(;;) {
  91                 switch (type) {
  92                 case OPTION_IP_PAIR:
  93                         dest += sprintip(dest, "", option);
  94                         *(dest++) = '/';
  95                         option += 4;
  96                         optlen = 4;
  97                 case OPTION_IP: /* Works regardless of host byte order. */
  98                         dest += sprintip(dest, "", option);
  99                         break;
 100                 case OPTION_BOOLEAN:
 101                         dest += sprintf(dest, *option ? "yes" : "no");
 102                         break;
 103                 case OPTION_U8:
 104                         dest += sprintf(dest, "%u", *option);
 105                         break;
 106                 case OPTION_U16:
 107                         memcpy(&val_u16, option, 2);
 108                         dest += sprintf(dest, "%u", ntohs(val_u16));
 109                         break;
 110                 case OPTION_S16:
 111                         memcpy(&val_s16, option, 2);
 112                         dest += sprintf(dest, "%d", ntohs(val_s16));
 113                         break;
 114                 case OPTION_U32:
 115                         memcpy(&val_u32, option, 4);
 116                         dest += sprintf(dest, "%lu", (unsigned long) ntohl(val_u32));
 117                         break;
 118                 case OPTION_S32:
 119                         memcpy(&val_s32, option, 4);
 120                         dest += sprintf(dest, "%ld", (long) ntohl(val_s32));
 121                         break;
 122                 case OPTION_STRING:
 123                         memcpy(dest, option, len);
 124                         dest[len] = '\0';
 125                         return;  /* Short circuit this case */
 126                 }
 127                 option += optlen;
 128                 len -= optlen;
 129                 if (len <= 0) break;
 130                 dest += sprintf(dest, " ");
 131         }
 132 }
 133
 134
 135 /* put all the parameters into an environment */
 136 static char **fill_envp(struct dhcpMessage *packet)
 137 {
 138         int num_options = 0;
 139         int i, j;
 140         char **envp;
 141         uint8_t *temp;
 142         struct in_addr subnet;
 143         char over = 0;
 144
 145         if (packet == NULL)
 146                 num_options = 0;
 147         else {
 148                 for (i = 0; dhcp_options[i].code; i++)
 149                         if (get_option(packet, dhcp_options[i].code)) {
 150                                 num_options++;
 151                                 if (dhcp_options[i].code == DHCP_SUBNET)
 152                                         num_options++; /* for mton */
 153                         }
 154                 if (packet->siaddr) num_options++;
 155                 if ((temp = get_option(packet, DHCP_OPTION_OVER)))
 156                         over = *temp;
 157                 if (!(over & FILE_FIELD) && packet->file[0]) num_options++;
 158                 if (!(over & SNAME_FIELD) && packet->sname[0]) num_options++;
 159         }
 160
 161         envp = xcalloc(sizeof(char *), num_options + 5);
 162         j = 0;
 163         asprintf(&envp[j++], "interface=%s", client_config.interface);
 164         asprintf(&envp[j++], "%s=%s", "PATH",
 165                 getenv("PATH") ? : "/bin:/usr/bin:/sbin:/usr/sbin");
 166         asprintf(&envp[j++], "%s=%s", "HOME", getenv("HOME") ? : "/");
 167
 168         if (packet == NULL) return envp;
 169
 170         envp[j] = xmalloc(sizeof("ip=255.255.255.255"));
 171         sprintip(envp[j++], "ip=", (uint8_t *) &packet->yiaddr);
 172
 173
 174         for (i = 0; dhcp_options[i].code; i++) {
 175                 if (!(temp = get_option(packet, dhcp_options[i].code)))
 176                         continue;
 177                 envp[j] = xmalloc(upper_length(temp[OPT_LEN - 2],
 178                         dhcp_options[i].flags & TYPE_MASK) + strlen(dhcp_options[i].name) + 2);
 179                 fill_options(envp[j++], temp, &dhcp_options[i]);
 180
 181                 /* Fill in a subnet bits option for things like /24 */
 182                 if (dhcp_options[i].code == DHCP_SUBNET) {
 183                         memcpy(&subnet, temp, 4);
 184                         asprintf(&envp[j++], "mask=%d", mton(&subnet));
 185                 }
 186         }
 187         if (packet->siaddr) {
 188                 envp[j] = xmalloc(sizeof("siaddr=255.255.255.255"));
 189                 sprintip(envp[j++], "siaddr=", (uint8_t *) &packet->siaddr);
 190         }
 191         if (!(over & FILE_FIELD) && packet->file[0]) {
 192                 /* watch out for invalid packets */
 193                 packet->file[sizeof(packet->file) - 1] = '\0';
 194                 asprintf(&envp[j++], "boot_file=%s", packet->file);
 195         }
 196         if (!(over & SNAME_FIELD) && packet->sname[0]) {
 197                 /* watch out for invalid packets */
 198                 packet->sname[sizeof(packet->sname) - 1] = '\0';
 199                 asprintf(&envp[j++], "sname=%s", packet->sname);
 200         }
 201         return envp;
 202 }
 203
 204
 205 /* Call a script with a par file and env vars */
 206 void run_script(struct dhcpMessage *packet, const char *name)
 207 {
 208         int pid;
 209         char **envp, **curr;
 210
 211         if (client_config.script == NULL)
 212                 return;
 213
 214         DEBUG(LOG_INFO, "vforking and execle'ing %s", client_config.script);
 215
 216         envp = fill_envp(packet);
 217         /* call script */
 218         pid = vfork();
 219         if (pid) {
 220                 waitpid(pid, NULL, 0);
 221                 for (curr = envp; *curr; curr++) free(*curr);
 222                 free(envp);
 223                 return;
 224         } else if (pid == 0) {
 225                 /* close fd's? */
 226
 227                 /* exec script */
 228                 execle(client_config.script, client_config.script,
 229                        name, NULL, envp);
 230                 LOG(LOG_ERR, "script %s failed: %m", client_config.script);
 231                 exit(1);
 232         }
 233 }