commands/dhcpd/tags.c

   1 /*      tags.c - Obtain DHCP tags from the config file
   2  *                                                      Author: Kees J. Bot
   3  *                                                              16 Dec 2000
   4  */
   5 #include <sys/types.h>
   6 #include <stdio.h>
   7 #include <stddef.h>
   8 #include <stdlib.h>
   9 #include <unistd.h>
  10 #include <fcntl.h>
  11 #include <errno.h>
  12 #include <signal.h>
  13 #include <string.h>
  14 #include <time.h>
  15 #include <limits.h>
  16 #include <configfile.h>
  17 #include <sys/ioctl.h>
  18 #include <sys/asynchio.h>
  19 #include <net/hton.h>
  20 #include <net/gen/socket.h>
  21 #include <net/gen/netdb.h>
  22 #include <net/gen/in.h>
  23 #include <net/gen/inet.h>
  24 #include <net/gen/ether.h>
  25 #include <net/gen/if_ether.h>
  26 #include <net/gen/eth_hdr.h>
  27 #include <net/gen/ip_hdr.h>
  28 #include <net/gen/udp.h>
  29 #include <net/gen/udp_hdr.h>
  30 #include <net/gen/dhcp.h>
  31 #include "dhcpd.h"
  32
  33 #define doff(field)             offsetof(dhcp_t, field)
  34
  35 void settag(dhcp_t *dp, int tag, void *data, size_t len)
  36 {
  37     if (!dhcp_settag(dp, tag, data, len)) {
  38         /* Oops, it didn't fit?  Is this really Minix??? */
  39         fprintf(stderr,
  40             "%s: DHCP packet too big, please trim the configuration\n",
  41             program);
  42         exit(1);
  43     }
  44 }
  45
  46 static int name2ip(ipaddr_t *pip, const char *name, ipaddr_t ifip)
  47 {
  48     /* Translate a name to an IP address, preferably from the hosts file,
  49      * but also from the DNS if being a server.  Prefer the address closest
  50      * to the interface with IP address 'ifip' if there are choices..
  51      */
  52     extern struct hostent *_gethostent(void);   /* File reading versions. */
  53     extern void _endhostent(void);
  54     struct hostent *he;
  55     size_t len= strlen(name);
  56     u32_t d, distance= -1;
  57     ipaddr_t ip;
  58     int i;
  59     char *hn;
  60
  61     /* Already an IP address? */
  62     if (inet_aton(name, pip)) return 1;
  63
  64     /* In the hosts file? */
  65     while ((he= _gethostent()) != nil) {
  66         hn= he->h_name;
  67         i= -1;
  68         do {
  69             if (strncasecmp(name, hn, len) == 0
  70                 && (hn[len] == 0 || hn[len] == '.')
  71             ) {
  72                 memcpy(&ip, he->h_addr, sizeof(ip));
  73                 d= ntohl(ip) ^ ntohl(ifip);
  74                 if (d < distance) {
  75                     *pip= ip;
  76                     distance= d;
  77                 }
  78                 break;
  79             }
  80         } while ((hn= he->h_aliases[++i]) != nil);
  81     }
  82     _endhostent();
  83     if (distance < -1) return 1;
  84
  85     /* Nothing?  Try the real DNS if being a server. */
  86     if (serving) {
  87         if ((he= gethostbyname(name)) != nil && he->h_addrtype == AF_INET) {
  88             /* Select the address closest to 'ifip'. */
  89             for (i= 0; he->h_addr_list[i] != nil; i++) {
  90                 memcpy(&ip, he->h_addr_list[i], sizeof(ip));
  91                 d= ntohl(ip) ^ ntohl(ifip);
  92                 if (d < distance) {
  93                     *pip= ip;
  94                     distance= d;
  95                 }
  96             }
  97             return 1;
  98         }
  99     }
 100     return 0;
 101 }
 102
 103 static char *ip2name(ipaddr_t ip)
 104 {
 105     /* Translate an IP address to a name, etc, etc. */
 106     extern struct hostent *_gethostent(void);   /* File reading versions. */
 107     extern void _endhostent(void);
 108     struct hostent *he;
 109
 110     /* In the hosts file? */
 111     while ((he= _gethostent()) != nil) {
 112         if (memcmp(he->h_addr, &ip, sizeof(ip)) == 0) break;
 113     }
 114     _endhostent();
 115
 116     /* Nothing?  Try the real DNS if being a server. */
 117     if (he == nil && serving) {
 118         he= gethostbyaddr((char *) &ip, sizeof(ip), AF_INET);
 119     }
 120     return he != nil ? he->h_name : nil;
 121 }
 122
 123 static int cidr_aton(const char *cidr, ipaddr_t *addr, ipaddr_t *mask)
 124 {
 125     char *slash, *check;
 126     ipaddr_t a;
 127     int ok;
 128     unsigned long len;
 129
 130     if ((slash= strchr(cidr, '/')) == nil) return 0;
 131
 132     *slash++= 0;
 133     ok= inet_aton(cidr, &a);
 134
 135     len= strtoul(slash, &check, 10);
 136     if (check == slash || *check != 0 || len > 32) ok= 0;
 137
 138     *--slash= '/';
 139     if (!ok) return 0;
 140     *addr= a;
 141     *mask= htonl(len == 0 ? 0 : (0xFFFFFFFFUL << (32-len)) & 0xFFFFFFFFUL);
 142     return 1;
 143 }
 144
 145 char *cidr_ntoa(ipaddr_t addr, ipaddr_t mask)
 146 {
 147     ipaddr_t testmask= 0xFFFFFFFFUL;
 148     int n;
 149     static char result[sizeof("255.255.255.255/255.255.255.255")];
 150
 151     for (n= 32; n >= 0; n--) {
 152         if (mask == htonl(testmask)) break;
 153         testmask= (testmask << 1) & 0xFFFFFFFFUL;
 154     }
 155
 156     sprintf(result, "%s/%-2d", inet_ntoa(addr), n);
 157     if (n == -1) strcpy(strchr(result, '/')+1, inet_ntoa(mask));
 158     return result;
 159 }
 160
 161 static size_t ascii2octet(u8_t *b, size_t size, const char *a)
 162 {
 163     /* Convert a series of hex digit pairs to an octet (binary) array at
 164      * 'b' with length 'size'.  Return the number of octets in 'a' or
 165      * -1 on error.
 166      */
 167     size_t len;
 168     int n, c;
 169
 170     len= 0;
 171     n= 0;
 172     while ((c= *a++) != 0) {
 173         if (between('0', c, '9')) c= (c - '0') + 0x0;
 174         else
 175         if (between('a', c, 'f')) c= (c - 'a') + 0xa;
 176         else
 177         if (between('A', c, 'F')) c= (c - 'A') + 0xA;
 178         else {
 179             return -1;
 180         }
 181
 182         if (n == 0) {
 183             if (len < size) b[len] = c << 4;
 184         } else {
 185             if (len < size) b[len] |= c;
 186             len++;
 187         }
 188         n ^= 1;
 189     }
 190     return n == 0 ? len : -1;
 191 }
 192
 193 void ether2clid(u8_t *clid, ether_addr_t *eth)
 194 {
 195     /* Convert an Ethernet address to the default client ID form. */
 196     clid[0]= DHCP_HTYPE_ETH;
 197     memcpy(clid+1, eth, DHCP_HLEN_ETH);
 198 }
 199
 200 static size_t ascii2clid(u8_t *clid, const char *a)
 201 {
 202     /* Convert an ethernet address, or a series of hex digits to a client ID.
 203      * Return its length if ok, otherwise -1.
 204      */
 205     size_t len;
 206     ether_addr_t *eth;
 207
 208     if ((eth= ether_aton(a)) != nil) {
 209         ether2clid(clid, eth);
 210         len= 1+DHCP_HLEN_ETH;
 211     } else {
 212         len= ascii2octet(clid, CLID_MAX, a);
 213     }
 214     return len;
 215 }
 216
 217 static config_t *dhcpconf;              /* In-core DHCP configuration. */
 218
 219 /* DHCP tag types. */
 220 typedef enum { TT_ASCII, TT_BOOLEAN, TT_IP, TT_NUMBER, TT_OCTET } tagtype_t;
 221
 222 /* DHCP/BOOTP tag definitions. */
 223 typedef struct tagdef {
 224         u8_t            tag;            /* Tag number. */
 225         u8_t            type;           /* Type and flags. */
 226         u8_t            gran;           /* Granularity. */
 227         u8_t            max;            /* Maximum number of arguments. */
 228         const char      *name;          /* Defined name. */
 229 } tagdef_t;
 230
 231 #define TF_TYPE         0x07            /* To mask out the type. */
 232 #define TF_STATIC       0x08            /* "Static", i.e. a struct field. */
 233 #define TF_RO           0x10            /* Read-only, user can't set. */
 234
 235 /* List of static DHCP fields.  The tag field is misused here as an offset
 236  * into the DHCP structure.
 237  */
 238 static tagdef_t statictag[] = {
 239     { doff(op),     TT_NUMBER|TF_STATIC|TF_RO,  1,   1, "op"            },
 240     { doff(htype),  TT_NUMBER|TF_STATIC|TF_RO,  1,   1, "htype"         },
 241     { doff(hlen),   TT_NUMBER|TF_STATIC|TF_RO,  1,   1, "hlen"          },
 242     { doff(hops),   TT_NUMBER|TF_STATIC|TF_RO,  1,   1, "hops"          },
 243     { doff(xid),    TT_NUMBER|TF_STATIC|TF_RO,  4,   1, "xid"           },
 244     { doff(secs),   TT_NUMBER|TF_STATIC|TF_RO,  2,   1, "secs"          },
 245     { doff(flags),  TT_NUMBER|TF_STATIC|TF_RO,  2,   1, "flags"         },
 246     { doff(ciaddr), TT_IP|TF_STATIC|TF_RO,      1,   1, "ciaddr"        },
 247     { doff(yiaddr), TT_IP|TF_STATIC|TF_RO,      1,   1, "yiaddr"        },
 248     { doff(siaddr), TT_IP|TF_STATIC,            1,   1, "siaddr"        },
 249     { doff(giaddr), TT_IP|TF_STATIC|TF_RO,      1,   1, "giaddr"        },
 250     { doff(chaddr), TT_OCTET|TF_STATIC|TF_RO,   1,  16, "chaddr"        },
 251     { doff(sname),  TT_ASCII|TF_STATIC,         1,  64, "sname"         },
 252     { doff(file),   TT_ASCII|TF_STATIC,         1, 128, "file"          },
 253 };
 254 #define N_STATIC        arraysize(statictag)
 255
 256 static tagdef_t alltagdef[N_STATIC + 254];      /* List of tag definitions. */
 257 #define tagdef  (alltagdef+N_STATIC-1)          /* Just the optional ones. */
 258
 259 #define tagdefined(tp)          ((tp)->name != nil)
 260
 261 static void inittagdef(void)
 262 {
 263     /* Initialize the tag definitions from the "tag" commands in the config
 264      * file.
 265      */
 266     int t;
 267     tagdef_t *tp;
 268     static tagdef_t predef[] = {
 269         { DHCP_TAG_NETMASK,     TT_IP,     1,     1,    "netmask"       },
 270         { DHCP_TAG_GATEWAY,     TT_IP,     1,   255,    "gateway"       },
 271         { DHCP_TAG_DNS,         TT_IP,     1,   255,    "DNSserver"     },
 272     };
 273     static char *typenames[] = { "ascii", "boolean", "ip", "number", "octet" };
 274     config_t *cfg;
 275     static u8_t rotags[] = {
 276         DHCP_TAG_REQIP, DHCP_TAG_OVERLOAD, DHCP_TAG_TYPE, DHCP_TAG_SERVERID,
 277         DHCP_TAG_REQPAR, DHCP_TAG_MESSAGE, DHCP_TAG_MAXDHCP
 278     };
 279
 280     for (t= 1; t <= 254; t++) {
 281         tp= &tagdef[t];
 282         tp->tag= t;
 283         tp->type= TT_OCTET;
 284         tp->name= nil;
 285     }
 286
 287     /* Set the static and "all Minix needs" tags. */
 288     memcpy(alltagdef, statictag, sizeof(statictag));
 289     for (tp= predef; tp < arraylimit(predef); tp++) tagdef[tp->tag] = *tp;
 290
 291     /* Search for tag definitions in the config file. */
 292     for (cfg= dhcpconf; cfg != nil; cfg= cfg->next) {
 293         config_t *cmd= cfg->list;
 294
 295         if (strcasecmp(cmd->word, "tag") == 0) {
 296             if (config_length(cmd) == 6
 297                 && (cmd->next->flags & CFG_DULONG)
 298                 && config_isatom(cmd->next->next)
 299                 && config_isatom(cmd->next->next->next)
 300                 && (cmd->next->next->next->next->flags & CFG_DULONG)
 301                 && (cmd->next->next->next->next->next->flags & CFG_DULONG)
 302             ) {
 303                 unsigned long tag, gran, max;
 304                 const char *name, *typename;
 305                 unsigned type;
 306
 307                 tag= strtoul(cmd->next->word, nil, 10);
 308                 name= cmd->next->next->word;
 309                 typename= cmd->next->next->next->word;
 310                 gran= strtoul(cmd->next->next->next->next->word, nil, 10);
 311                 max= strtoul(cmd->next->next->next->next->next->word, nil, 10);
 312
 313                 for (type= 0; type < arraysize(typenames); type++) {
 314                     if (strcasecmp(typename, typenames[type]) == 0) break;
 315                 }
 316
 317                 if (!(1 <= tag && tag <= 254)
 318                     || !(type < arraysize(typenames))
 319                     || !((type == TT_NUMBER
 320                             && (gran == 1 || gran == 2 || gran == 4))
 321                         || (type != TT_NUMBER && 1 <= gran && gran <= 16))
 322                     || !(max <= 255)
 323                 ) {
 324                     fprintf(stderr,
 325                         "\"%s\", line %u: Tag definition is incorrect\n",
 326                         cmd->file, cmd->line);
 327                     exit(1);
 328                 }
 329
 330                 tp= &tagdef[(int)tag];
 331                 tp->type= type;
 332                 tp->name= name;
 333                 tp->gran= gran;
 334                 tp->max= max;
 335             } else {
 336                 fprintf(stderr,
 337             "\"%s\", line %u: Usage: tag number name type granularity max\n",
 338                     cmd->file, cmd->line);
 339                 exit(1);
 340             }
 341         }
 342     }
 343
 344     /* Many DHCP tags are not for the user to play with. */
 345     for (t= 0; t < arraysize(rotags); t++) tagdef[rotags[t]].type |= TF_RO;
 346 }
 347
 348 static tagdef_t *tagdefbyname(const char *name)
 349 {
 350     /* Find a tag definition by the name of the tag.  Return null if not
 351      * defined.
 352      */
 353     tagdef_t *tp;
 354
 355     for (tp= alltagdef; tp < arraylimit(alltagdef); tp++) {
 356         if (tagdefined(tp) && strcasecmp(tp->name, name) == 0) return tp;
 357     }
 358     return nil;
 359 }
 360
 361 void initdhcpconf(void)
 362 {
 363     /* Read/refresh configuration from the DHCP configuration file. */
 364     dhcpconf= config_read(configfile, 0, dhcpconf);
 365     if (config_renewed(dhcpconf)) inittagdef();
 366 }
 367
 368 static void configtag(dhcp_t *dp, config_t *cmd, ipaddr_t ifip)
 369 {
 370     /* Add a tag to a DHCP packet from the config file. */
 371     tagdef_t *tp;
 372     u8_t data[260], *d;
 373     size_t i;
 374     int delete= 0;
 375
 376     if (strcasecmp(cmd->word, "no") == 0) {
 377         if (config_length(cmd) != 2 || !config_isatom(cmd->next)) {
 378             fprintf(stderr, "\"%s\", line %u: Usage: no tag-name\n",
 379                 cmd->file, cmd->line);
 380             exit(1);
 381         }
 382         cmd= cmd->next;
 383         delete= 1;
 384     }
 385
 386     if ((tp= tagdefbyname(cmd->word)) == nil) {
 387         fprintf(stderr, "\"%s\", line %u: Unknown tag '%s'\n",
 388             cmd->file, cmd->line, cmd->word);
 389         exit(1);
 390     }
 391
 392     if (tp->type & TF_RO) {
 393         fprintf(stderr, "\"%s\", line %u: Tag '%s' can't be configured\n",
 394             cmd->file, cmd->line, cmd->word);
 395         exit(1);
 396     }
 397
 398     i= 0;
 399     d= data;
 400     if (!delete) {
 401         config_t *arg= cmd->next;
 402         do {
 403             switch (tp->type & TF_TYPE) {
 404             case TT_ASCII: {
 405                 if (arg == nil || !config_isatom(arg) || arg->next != nil) {
 406                     fprintf(stderr, "\"%s\", line %u: Usage: %s string\n",
 407                         cmd->file, cmd->line, cmd->word);
 408                     exit(1);
 409                 }
 410                 strncpy((char *) data, arg->word, sizeof(data));
 411                 d += i = strnlen((char *) data, sizeof(data));
 412                 break;}
 413             case TT_BOOLEAN: {
 414                 if (arg == nil || !config_isatom(arg)
 415                     || !(strcasecmp(arg->word, "false") == 0
 416                             || strcasecmp(arg->word, "true") == 0)
 417                 ) {
 418                     fprintf(stderr,
 419                         "\"%s\", line %u: Usage: %s false|true ...\n",
 420                         cmd->file, cmd->line, cmd->word);
 421                     exit(1);
 422                 }
 423                 if (d < arraylimit(data)) {
 424                     *d++ = (arg->word[0] != 'f' && arg->word[0] != 'F');
 425                 }
 426                 i++;
 427                 break;}
 428             case TT_IP: {
 429                 ipaddr_t ip;
 430                 unsigned long len;
 431                 char *end;
 432
 433                 if (arg == nil || !config_isatom(arg)) {
 434                     fprintf(stderr, "\"%s\", line %u: Usage: %s host ...\n",
 435                         cmd->file, cmd->line, cmd->word);
 436                     exit(1);
 437                 }
 438                 if (arg->word[0] == '/'
 439                         && between(1, len= strtoul(arg->word+1, &end, 10), 31)
 440                         && *end == 0
 441                 ) {
 442                     ip= htonl((0xFFFFFFFFUL << (32-len)) & 0xFFFFFFFFUL);
 443                 } else
 444                 if (!name2ip(&ip, arg->word, ifip)) {
 445                     fprintf(stderr,
 446                     "\"%s\", line %u: Can't translate %s to an IP address\n",
 447                         arg->file, arg->line, arg->word);
 448                     exit(1);
 449                 }
 450                 if (d <= arraylimit(data) - sizeof(ip)) {
 451                     memcpy(d, &ip, sizeof(ip));
 452                     d += sizeof(ip);
 453                 }
 454                 i++;
 455                 break;}
 456             case TT_NUMBER: {
 457                 unsigned long n;
 458                 int g;
 459
 460                 if (arg == nil || !(arg->flags & CFG_CLONG)) {
 461                     fprintf(stderr, "\"%s\", line %u: Usage: %s number ...\n",
 462                         cmd->file, cmd->line, cmd->word);
 463                     exit(1);
 464                 }
 465                 n= strtoul(arg->word, nil, 0);
 466                 g= tp->gran;
 467                 do {
 468                     if (d <= arraylimit(data)) *d++ = (n >> (--g * 8)) & 0xFF;
 469                 } while (g != 0);
 470                 i++;
 471                 break;}
 472             case TT_OCTET: {
 473                 if (arg == nil || !config_isatom(arg) || arg->next != nil) {
 474                     fprintf(stderr, "\"%s\", line %u: Usage: %s hexdigits\n",
 475                         cmd->file, cmd->line, cmd->word);
 476                     exit(1);
 477                 }
 478                 i= ascii2octet(data, sizeof(data), arg->word);
 479                 if (i == -1) {
 480                     fprintf(stderr,
 481                         "\"%s\", line %u: %s: Bad hexdigit string\n",
 482                         arg->file, arg->line, arg->word);
 483                     exit(1);
 484                 }
 485                 d= data + i;
 486                 break;}
 487             }
 488         } while ((arg= arg->next) != nil);
 489
 490         if (d > data + 255) {
 491             fprintf(stderr, "\"%s\", line %u: Tag value is way too big\n",
 492                 cmd->file, cmd->line);
 493             exit(1);
 494         }
 495         if ((tp->type & TF_TYPE) != TT_NUMBER && (i % tp->gran) != 0) {
 496             fprintf(stderr,
 497                 "\"%s\", line %u: Expected a multiple of %d initializers\n",
 498                 cmd->file, cmd->line, tp->gran);
 499             exit(1);
 500         }
 501         if (tp->max != 0 && i > tp->max) {
 502             fprintf(stderr,
 503                 "\"%s\", line %u: Got %d initializers, can have only %d\n",
 504                 cmd->file, cmd->line, (int) i, tp->max);
 505             exit(1);
 506         }
 507     }
 508     if (tp->type & TF_STATIC) {
 509         size_t len= tp->gran * tp->max;
 510         if ((tp->type & TF_TYPE) == TT_IP) len *= sizeof(ipaddr_t);
 511         memset(B(dp) + tp->tag, 0, len);
 512         memcpy(B(dp) + tp->tag, data, (d - data));
 513     } else {
 514         settag(dp, tp->tag, data, (d - data));
 515     }
 516 }
 517
 518 int makedhcp(dhcp_t *dp, u8_t *class, size_t calen, u8_t *client, size_t cilen,
 519                                 ipaddr_t ip, ipaddr_t ifip, network_t *np)
 520 {
 521     /* Fill in a DHCP packet at 'dp' for the host identified by the
 522      * (class, client, ip) combination.  Makedhcp is normally called twice,
 523      * once to find the IP address (so ip == 0) and once again to find all
 524      * data that goes with that IP address (ip != 0).  On the first call the
 525      * return value of this function should be ignored and only 'yiaddr'
 526      * checked and used as 'ip' on the next pass.  True is returned iff there
 527      * is information for the client on the network at interface address
 528      * 'ifip', by checking if the 'ip' and 'ifip' are on the same network.
 529      * If np is nonnull then we are working for one of our own interfaces, so
 530      * options can be set and adjourning interfaces can be programmed.
 531      */
 532     config_t *todo[16];
 533     size_t ntodo= 0;
 534     ipaddr_t hip, mask;
 535     u8_t *pmask;
 536     char *hostname;
 537     u32_t distance= -1;
 538
 539     initdhcpconf();
 540
 541     /* Start creating a packet. */
 542     dhcp_init(dp);
 543     dp->op= DHCP_BOOTREPLY;
 544
 545     /* The initial TODO list is the whole DHCP config. */
 546     todo[ntodo++]= dhcpconf;
 547
 548     while (ntodo > 0) {
 549         config_t *cmd, *follow;
 550
 551         if (todo[ntodo-1] == nil) { ntodo--; continue; }
 552         cmd= todo[ntodo-1]->list;
 553         todo[ntodo-1]= todo[ntodo-1]->next;
 554
 555         follow= nil;    /* Macro or list to follow next? */
 556
 557         if (strcasecmp(cmd->word, "client") == 0) {
 558             u8_t cfgid[CLID_MAX];
 559             size_t cfglen;
 560             char *name;
 561             int ifno;
 562             u32_t d;
 563
 564             if (between(3, config_length(cmd), 5)
 565                 && config_isatom(cmd->next)
 566                 && (cfglen= ascii2clid(cfgid, cmd->next->word)) != -1
 567                 && config_isatom(cmd->next->next)
 568                 && (((ifno= ifname2if(cmd->next->next->word)) == -1
 569                         && config_length(cmd) <= 4)
 570                     || ((ifno= ifname2if(cmd->next->next->word)) != -1
 571                         && config_length(cmd) >= 4
 572                         && config_isatom(cmd->next->next->next)))
 573             ) {
 574                 if (cilen == cfglen && memcmp(client, cfgid, cilen) == 0
 575                     && (ifno == -1 || np == nil || ifno == np->n)
 576                 ) {
 577                     config_t *atname= cmd->next->next;
 578                     if (ifno != -1) atname= atname->next;
 579                     name= atname->word;
 580
 581                     if (name2ip(&hip, name, ifip) && (ip == 0 || ip == hip)) {
 582                         d= ntohl(hip) ^ ntohl(ifip);
 583                         if (d < distance) {
 584                             dp->yiaddr= hip;
 585                             follow= atname->next;
 586                             distance= d;
 587                         }
 588                     }
 589                 }
 590             } else {
 591                 fprintf(stderr,
 592             "\"%s\", line %u: Usage: client ID [ip#] host [macro|{params}]\n",
 593                     cmd->file, cmd->line);
 594                 exit(1);
 595             }
 596         } else
 597         if (strcasecmp(cmd->word, "class") == 0) {
 598             config_t *clist;
 599             int match;
 600
 601             match= 0;
 602             for (clist= cmd->next; clist != nil
 603                                 && clist->next != nil
 604                                 && config_isatom(clist); clist= clist->next) {
 605                 if (calen > 0
 606                     && strncmp(clist->word, (char *) class, calen) == 0
 607                 ) {
 608                     match= 1;
 609                 }
 610             }
 611             if (clist == cmd->next || clist->next != nil) {
 612                 fprintf(stderr,
 613                 "\"%s\", line %u: Usage: class class-name ... macro|{params}\n",
 614                     cmd->file, cmd->line);
 615             }
 616             if (match) follow= clist;
 617         } else
 618         if (strcasecmp(cmd->word, "host") == 0) {
 619             if (config_length(cmd) == 3
 620                 && config_isatom(cmd->next)
 621             ) {
 622                 if (ip != 0) {
 623                     if (cidr_aton(cmd->next->word, &hip, &mask)) {
 624                         if (((hip ^ ip) & mask) == 0) {
 625                             if (!gettag(dp, DHCP_TAG_NETMASK, nil, nil)) {
 626                                 settag(dp, DHCP_TAG_NETMASK,
 627                                                 &mask, sizeof(mask));
 628                             }
 629                             dp->yiaddr= ip;
 630                             follow= cmd->next->next;
 631                         }
 632                     } else
 633                     if (name2ip(&hip, cmd->next->word, ifip)) {
 634                         if (hip == ip) {
 635                             dp->yiaddr= ip;
 636                             follow= cmd->next->next;
 637                         }
 638                     }
 639                 }
 640             } else {
 641                 fprintf(stderr,
 642                 "\"%s\", line %u: Usage: host host-spec macro|{params}\n",
 643                     cmd->file, cmd->line);
 644                 exit(1);
 645             }
 646         } else
 647         if (strcasecmp(cmd->word, "interface") == 0) {
 648             if (between(3, config_length(cmd), 4)
 649                 && config_isatom(cmd->next)
 650                 && config_isatom(cmd->next->next)
 651             ) {
 652                 network_t *ifnp;
 653
 654                 if (np != nil) {
 655                     if ((ifnp= if2net(ifname2if(cmd->next->word))) == nil) {
 656                         fprintf(stderr,
 657                             "\"%s\", line %u: Can't find interface %s\n",
 658                             cmd->next->file, cmd->next->line, cmd->next->word);
 659                         exit(1);
 660                     }
 661                     if (!name2ip(&hip, cmd->next->next->word, 0)) {
 662                         fprintf(stderr,
 663                             "\"%s\", line %u: Can't find IP address of %s\n",
 664                             cmd->next->next->file, cmd->next->next->line,
 665                             cmd->next->next->word);
 666                         exit(1);
 667                     }
 668                     ifnp->ip= hip;
 669                     if (ifnp == np) {
 670                         dp->yiaddr= hip;
 671                         follow= cmd->next->next->next;
 672                     }
 673                 }
 674             } else {
 675                 fprintf(stderr,
 676                 "\"%s\", line %u: Usage: interface ip# host%s\n",
 677                     cmd->file, cmd->line, ntodo==1 ? " [macro|{params}]" : "");
 678                 exit(1);
 679             }
 680         } else
 681         if (strcasecmp(cmd->word, "macro") == 0) {
 682             if (config_length(cmd) == 2 && config_isatom(cmd->next)) {
 683                 follow= cmd->next;
 684             } else
 685             if (ntodo > 1) {
 686                 fprintf(stderr, "\"%s\", line %u: Usage: macro macro-name\n",
 687                     cmd->file, cmd->line);
 688                 exit(1);
 689             }
 690         } else
 691         if (strcasecmp(cmd->word, "tag") == 0) {
 692             if (ntodo > 1) {
 693                 fprintf(stderr,
 694                     "\"%s\", line %u: A %s can't be defined here\n",
 695                     cmd->file, cmd->line, cmd->word);
 696                 exit(1);
 697             }
 698         } else
 699         if (strcasecmp(cmd->word, "option") == 0) {
 700             int ifno;
 701             network_t *ifnp;
 702             config_t *opt;
 703
 704             if ((opt= cmd->next) != nil
 705                 && config_isatom(opt)
 706                 && (ifno= ifname2if(opt->word)) != -1
 707             ) {
 708                 if ((ifnp= if2net(ifno)) == nil) {
 709                     fprintf(stderr,
 710                         "\"%s\", line %u: Interface %s is not enabled\n",
 711                         opt->file, opt->line, opt->word);
 712                     exit(1);
 713                 }
 714                 opt= opt->next;
 715             } else {
 716                 ifnp= np;
 717             }
 718
 719             if (between(1, config_length(opt), 2)
 720                 && config_isatom(opt)
 721                 && strcasecmp(opt->word, "server") == 0
 722                 && (opt->next == nil
 723                     || strcasecmp(opt->next->word, "inform") == 0)
 724             ) {
 725                 if (np != nil) {
 726                     ifnp->flags |= NF_SERVING;
 727                     if (opt->next != nil) ifnp->flags |= NF_INFORM;
 728                 }
 729             } else
 730             if (config_length(opt) == 2
 731                 && config_isatom(opt)
 732                 && strcasecmp(opt->word, "relay") == 0
 733                 && config_isatom(opt->next)
 734             ) {
 735                 if (np != nil) {
 736                     if (!name2ip(&hip, opt->next->word, ifip)) {
 737                         fprintf(stderr,
 738                             "\"%s\", line %u: Can't find IP address of %s\n",
 739                             opt->next->file, opt->next->line,
 740                             opt->next->word);
 741                         exit(1);
 742                     }
 743                     ifnp->flags |= NF_RELAYING;
 744                     ifnp->server= hip;
 745                 }
 746             } else
 747             if (config_length(opt) == 1
 748                 && config_isatom(opt)
 749                 && strcasecmp(opt->word, "possessive") == 0
 750             ) {
 751                 if (np != nil) ifnp->flags |= NF_POSSESSIVE;
 752             } else
 753             if (config_length(opt) == 2
 754                 && config_isatom(opt)
 755                 && strcasecmp(opt->word, "hostname") == 0
 756                 && config_isatom(opt->next)
 757             ) {
 758                 if (np != nil) np->hostname= opt->next->word;
 759             } else {
 760                 fprintf(stderr, "\"%s\", line %u: Unknown option\n",
 761                     cmd->file, cmd->line);
 762                 exit(1);
 763             }
 764         } else {
 765             /* Must be an actual data carrying tag. */
 766             configtag(dp, cmd, ifip);
 767         }
 768
 769         if (follow != nil) {
 770             /* A client/class/host entry selects a macro or list that must
 771              * be followed next.
 772              */
 773             config_t *macro;
 774
 775             if (config_isatom(follow)) {        /* Macro name */
 776                 config_t *cfg;
 777
 778                 for (cfg= dhcpconf; cfg != nil; cfg= cfg->next) {
 779                     macro= cfg->list;
 780
 781                     if (strcasecmp(macro->word, "macro") == 0) {
 782                         if (config_length(macro) == 3
 783                             && config_isatom(macro->next)
 784                             && config_issub(macro->next->next)
 785                         ) {
 786                             if (strcasecmp(macro->next->word, follow->word) == 0
 787                             ) {
 788                                 break;
 789                             }
 790                         } else {
 791                             fprintf(stderr,
 792                         "\"%s\", line %u: Usage: macro macro-name {params}\n",
 793                                 macro->file, macro->line);
 794                         }
 795                     }
 796                 }
 797                 follow= cfg == nil ? nil : macro->next->next->list;
 798             } else {
 799                 /* Simply a list of more tags and stuff. */
 800                 follow= follow->list;
 801             }
 802
 803             if (ntodo == arraysize(todo)) {
 804                 fprintf(stderr, "\"%s\", line %u: Nesting is too deep\n",
 805                     follow->file, follow->line);
 806                 exit(1);
 807             }
 808             todo[ntodo++]= follow;
 809         }
 810     }
 811
 812     /* Check if the IP and netmask are OK for the interface. */
 813     if (!gettag(dp, DHCP_TAG_NETMASK, &pmask, nil)) return 0;
 814     memcpy(&mask, pmask, sizeof(mask));
 815     if (((ip ^ ifip) & mask) != 0) return 0;
 816
 817     /* Fill in the hostname and/or domain. */
 818     if ((hostname= ip2name(ip)) != nil) {
 819         char *domain;
 820
 821         if ((domain= strchr(hostname, '.')) != nil) *domain++ = 0;
 822
 823         if (!gettag(dp, DHCP_TAG_HOSTNAME, nil, nil)) {
 824             settag(dp, DHCP_TAG_HOSTNAME, hostname, strlen(hostname));
 825         }
 826
 827         if (domain != nil && !gettag(dp, DHCP_TAG_DOMAIN, nil, nil)) {
 828             settag(dp, DHCP_TAG_DOMAIN, domain, strlen(domain));
 829         }
 830     }
 831
 832     return 1;
 833 }
 834
 835 static char *dhcpopname(int op)
 836 {
 837     static char *onames[] = { "??\?", "REQUEST", "REPLY" };
 838     return onames[op < arraysize(onames) ? op : 0];
 839 }
 840
 841 char *dhcptypename(int type)
 842 {
 843     static char *tnames[] = {
 844         "??\?", "DISCOVER", "OFFER", "REQUEST", "DECLINE",
 845         "ACK", "NAK", "RELEASE", "INFORM"
 846     };
 847     return tnames[type < arraysize(tnames) ? type : 0];
 848 }
 849
 850 void printdhcp(dhcp_t *dp)
 851 {
 852     /* Print the contents of a DHCP packet, usually for debug purposes. */
 853     tagdef_t *tp;
 854     u8_t *data, *ovld;
 855     size_t i, len;
 856
 857     for (tp= alltagdef; tp < arraylimit(alltagdef); tp++) {
 858         if (tp->type & TF_STATIC) {
 859             data= B(dp) + tp->tag;
 860             len= tp->gran * tp->max;
 861             if ((tp->type & TF_TYPE) == TT_IP) len *= sizeof(ipaddr_t);
 862             if (tp->tag == doff(chaddr)) len= dp->hlen;
 863
 864             /* Don't show uninteresting stuff. */
 865             if (tp->tag == doff(htype) && dp->htype == DHCP_HTYPE_ETH) continue;
 866
 867             if (tp->tag == doff(hlen) && dp->hlen == DHCP_HLEN_ETH) continue;
 868
 869             if ((tp->tag == doff(file) || tp->tag == doff(sname))
 870                 && gettag(dp, DHCP_TAG_OVERLOAD, &ovld, nil)
 871                 && (ovld[0] & (tp->tag == doff(file) ? 1 : 2))
 872             ) {
 873                 continue;
 874             }
 875             for (i= 0; i < len && data[i] == 0; i++) {}
 876             if (i == len) continue;
 877         } else {
 878             if (!gettag(dp, tp->tag, &data, &len)) continue;
 879         }
 880
 881         if (tagdefined(tp)) {
 882             printf("\t%s =", tp->name);
 883         } else {
 884             printf("\tT%d =", tp->tag);
 885         }
 886
 887         i= 0;
 888         while (i < len) {
 889             switch (tp->type & TF_TYPE) {
 890             case TT_ASCII: {
 891                 printf(" \"%.*s\"", (int) len, data);
 892                 i= len;
 893                 break;}
 894             case TT_BOOLEAN: {
 895                 printf(data[i++] == 0 ? " false" : " true");
 896                 break;}
 897             case TT_IP: {
 898                 ipaddr_t ip;
 899                 memcpy(&ip, data+i, sizeof(ip));
 900                 printf(" %s", inet_ntoa(ip));
 901                 i += sizeof(ip);
 902                 break;}
 903             case TT_NUMBER: {
 904                 u32_t n= 0;
 905                 int g= tp->gran;
 906
 907                 do n= (n << 8) | data[i++]; while (--g != 0);
 908                 printf(" %lu", (unsigned long) n);
 909                 if ((tp->type & TF_STATIC) && tp->tag == doff(op)) {
 910                     printf(" (%s)", dhcpopname(n));
 911                 }
 912                 if (!(tp->type & TF_STATIC) && tp->tag == DHCP_TAG_TYPE) {
 913                     printf(" (%s)", dhcptypename(n));
 914                 }
 915                 break;}
 916             case TT_OCTET: {
 917                 if (i == 0) fputc(' ', stdout);
 918                 printf("%02X", data[i++]);
 919                 break;}
 920             }
 921         }
 922         fputc('\n', stdout);
 923     }
 924 }