networking/udhcp/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 "common.h"
  33 #include "options.h"
  34 #include "dhcpd.h"
  35 #include "dhcpc.h"
  36 #include "script.h"
  37
  38 /* get a rough idea of how long an option will be (rounding up...) */
  39 static const int max_option_length[] = {
  40         [OPTION_IP] =           sizeof("255.255.255.255 "),
  41         [OPTION_IP_PAIR] =      sizeof("255.255.255.255 ") * 2,
  42         [OPTION_STRING] =       1,
  43         [OPTION_BOOLEAN] =      sizeof("yes "),
  44         [OPTION_U8] =           sizeof("255 "),
  45         [OPTION_U16] =          sizeof("65535 "),
  46         [OPTION_S16] =          sizeof("-32768 "),
  47         [OPTION_U32] =          sizeof("4294967295 "),
  48         [OPTION_S32] =          sizeof("-2147483684 "),
  49 };
  50
  51
  52 static inline int upper_length(int length, int opt_index)
  53 {
  54         return max_option_length[opt_index] *
  55                 (length / option_lengths[opt_index]);
  56 }
  57
  58
  59 static int sprintip(char *dest, char *pre, uint8_t *ip)
  60 {
  61         return sprintf(dest, "%s%d.%d.%d.%d", pre, ip[0], ip[1], ip[2], ip[3]);
  62 }
  63
  64
  65 /* really simple implementation, just count the bits */
  66 static int mton(struct in_addr *mask)
  67 {
  68         int i;
  69         unsigned long bits = ntohl(mask->s_addr);
  70         /* too bad one can't check the carry bit, etc in c bit
  71          * shifting */
  72         for (i = 0; i < 32 && !((bits >> i) & 1); i++);
  73         return 32 - i;
  74 }
  75
  76
  77 /* Fill dest with the text of option 'option'. */
  78 static void fill_options(char *dest, uint8_t *option, struct dhcp_option *type_p)
  79 {
  80         int type, optlen;
  81         uint16_t val_u16;
  82         int16_t val_s16;
  83         uint32_t val_u32;
  84         int32_t val_s32;
  85         int len = option[OPT_LEN - 2];
  86
  87         dest += sprintf(dest, "%s=", type_p->name);
  88
  89         type = type_p->flags & TYPE_MASK;
  90         optlen = option_lengths[type];
  91         for(;;) {
  92                 switch (type) {
  93                 case OPTION_IP_PAIR:
  94                         dest += sprintip(dest, "", option);
  95                         *(dest++) = '/';
  96                         option += 4;
  97                         optlen = 4;
  98                 case OPTION_IP: /* Works regardless of host byte order. */
  99                         dest += sprintip(dest, "", option);
 100                         break;
 101                 case OPTION_BOOLEAN:
 102                         dest += sprintf(dest, *option ? "yes" : "no");
 103                         break;
 104                 case OPTION_U8:
 105                         dest += sprintf(dest, "%u", *option);
 106                         break;
 107                 case OPTION_U16:
 108                         memcpy(&val_u16, option, 2);
 109                         dest += sprintf(dest, "%u", ntohs(val_u16));
 110                         break;
 111                 case OPTION_S16:
 112                         memcpy(&val_s16, option, 2);
 113                         dest += sprintf(dest, "%d", ntohs(val_s16));
 114                         break;
 115                 case OPTION_U32:
 116                         memcpy(&val_u32, option, 4);
 117                         dest += sprintf(dest, "%lu", (unsigned long) ntohl(val_u32));
 118                         break;
 119                 case OPTION_S32:
 120                         memcpy(&val_s32, option, 4);
 121                         dest += sprintf(dest, "%ld", (long) ntohl(val_s32));
 122                         break;
 123                 case OPTION_STRING:
 124                         memcpy(dest, option, len);
 125                         dest[len] = '\0';
 126                         return;  /* Short circuit this case */
 127                 }
 128                 option += optlen;
 129                 len -= optlen;
 130                 if (len <= 0) break;
 131                 dest += sprintf(dest, " ");
 132         }
 133 }
 134
 135
 136 /* put all the parameters into an environment */
 137 static char **fill_envp(struct dhcpMessage *packet)
 138 {
 139         int num_options = 0;
 140         int i, j;
 141         char **envp;
 142         uint8_t *temp;
 143         struct in_addr subnet;
 144         char over = 0;
 145
 146         if (packet == NULL)
 147                 num_options = 0;
 148         else {
 149                 for (i = 0; dhcp_options[i].code; i++)
 150                         if (get_option(packet, dhcp_options[i].code)) {
 151                                 num_options++;
 152                                 if (dhcp_options[i].code == DHCP_SUBNET)
 153                                         num_options++; /* for mton */
 154                         }
 155                 if (packet->siaddr) num_options++;
 156                 if ((temp = get_option(packet, DHCP_OPTION_OVER)))
 157                         over = *temp;
 158                 if (!(over & FILE_FIELD) && packet->file[0]) num_options++;
 159                 if (!(over & SNAME_FIELD) && packet->sname[0]) num_options++;
 160         }
 161
 162         envp = xcalloc(sizeof(char *), num_options + 5);
 163         j = 0;
 164         asprintf(&envp[j++], "interface=%s", client_config.interface);
 165         asprintf(&envp[j++], "%s=%s", "PATH",
 166                 getenv("PATH") ? : "/bin:/usr/bin:/sbin:/usr/sbin");
 167         asprintf(&envp[j++], "%s=%s", "HOME", getenv("HOME") ? : "/");
 168
 169         if (packet == NULL) return envp;
 170
 171         envp[j] = xmalloc(sizeof("ip=255.255.255.255"));
 172         sprintip(envp[j++], "ip=", (uint8_t *) &packet->yiaddr);
 173
 174
 175         for (i = 0; dhcp_options[i].code; i++) {
 176                 if (!(temp = get_option(packet, dhcp_options[i].code)))
 177                         continue;
 178                 envp[j] = xmalloc(upper_length(temp[OPT_LEN - 2],
 179                         dhcp_options[i].flags & TYPE_MASK) + strlen(dhcp_options[i].name) + 2);
 180                 fill_options(envp[j++], temp, &dhcp_options[i]);
 181
 182                 /* Fill in a subnet bits option for things like /24 */
 183                 if (dhcp_options[i].code == DHCP_SUBNET) {
 184                         memcpy(&subnet, temp, 4);
 185                         asprintf(&envp[j++], "mask=%d", mton(&subnet));
 186                 }
 187         }
 188         if (packet->siaddr) {
 189                 envp[j] = xmalloc(sizeof("siaddr=255.255.255.255"));
 190                 sprintip(envp[j++], "siaddr=", (uint8_t *) &packet->siaddr);
 191         }
 192         if (!(over & FILE_FIELD) && packet->file[0]) {
 193                 /* watch out for invalid packets */
 194                 packet->file[sizeof(packet->file) - 1] = '\0';
 195                 asprintf(&envp[j++], "boot_file=%s", packet->file);
 196         }
 197         if (!(over & SNAME_FIELD) && packet->sname[0]) {
 198                 /* watch out for invalid packets */
 199                 packet->sname[sizeof(packet->sname) - 1] = '\0';
 200                 asprintf(&envp[j++], "sname=%s", packet->sname);
 201         }
 202         return envp;
 203 }
 204
 205
 206 /* Call a script with a par file and env vars */
 207 void run_script(struct dhcpMessage *packet, const char *name)
 208 {
 209         int pid;
 210         char **envp, **curr;
 211
 212         if (client_config.script == NULL)
 213                 return;
 214
 215         DEBUG(LOG_INFO, "vforking and execle'ing %s", client_config.script);
 216
 217         envp = fill_envp(packet);
 218         /* call script */
 219         pid = vfork();
 220         if (pid) {
 221                 waitpid(pid, NULL, 0);
 222                 for (curr = envp; *curr; curr++) free(*curr);
 223                 free(envp);
 224                 return;
 225         } else if (pid == 0) {
 226                 /* close fd's? */
 227
 228                 /* exec script */
 229                 execle(client_config.script, client_config.script,
 230                        name, NULL, envp);
 231                 LOG(LOG_ERR, "script %s failed: %m", client_config.script);
 232                 exit(1);
 233         }
 234 }