src/getdata.c

   1 /* http://dhcpd-pools.sourceforge.net/
   2 ** Copyright 2006- Sami Kerola <kerolasa@iki.fi>
   3 **
   4 ** This program is free software: you can redistribute it and/or modify
   5 ** it under the terms of the GNU General Public License as published by
   6 ** the Free Software Foundation, either version 3 of the License, or
   7 ** (at your option) any later version.
   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 ** You should have received a copy of the GNU General Public License
  15 ** along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 #ifdef HAVE_CONFIG_H
  19 #include <config.h>
  20 #endif
  21
  22 #ifdef HAVE_UNISTD_H
  23 #include <unistd.h>
  24 #endif
  25
  26 #ifdef  HAVE_STDLIB_H
  27 #include <stdlib.h>
  28 #else                           /* Not STDC_HEADERS */
  29 extern char *malloc();
  30 #define EXIT_FAILURE    1       /* Failing exit status.  */
  31 #define EXIT_SUCCESS    0       /* Successful exit status.  */
  32 #endif                          /* STDC_HEADERS */
  33
  34 #ifdef  HAVE_STRING_H
  35 #include <string.h>
  36 #else
  37 #include <strings.h>
  38 #endif
  39
  40 #include <stdio.h>
  41 #include <arpa/inet.h>
  42 #include <netinet/in.h>
  43 #include <sys/socket.h>
  44 #include <sys/stat.h>
  45 #include <sys/types.h>
  46 #ifndef _XOPEN_SOURCE
  47 #define _XOPEN_SOURCE 600
  48 #endif
  49 #include <fcntl.h>
  50 #include <errno.h>
  51 #include <err.h>
  52 #include <ctype.h>
  53 #include <assert.h>
  54
  55 #include "dhcpd-pools.h"
  56 #include "defaults.h"
  57
  58 /* Parse dhcpd.leases file. All performance boosts for this function are
  59  * wellcome */
  60 int parse_leases(void)
  61 {
  62         FILE *dhcpd_leases;
  63         char *line, *ipstring, *macstring;
  64         struct in_addr inp;
  65         struct stat lease_file_stats;
  66         struct macaddr_t *macaddr_p;
  67         unsigned long leasesmallocsize;
  68         unsigned long touchesmallocsize;
  69         unsigned long backupsmallocsize;
  70         int sw_active_lease = 0;
  71
  72         num_touches = num_leases = num_backups = 0;
  73
  74         dhcpd_leases = fopen(config.dhcpdlease_file, "r");
  75         if (dhcpd_leases == NULL) {
  76                 err(EXIT_FAILURE, "parse_leases: %s",
  77                     config.dhcpdlease_file);
  78         }
  79 #ifdef POSIX_FADV_WILLNEED
  80         posix_fadvise((long) dhcpd_leases, 0, 0, POSIX_FADV_WILLNEED);
  81         if (errno) {
  82                 err(EXIT_FAILURE, "parse_leases: fadvise %s",
  83                     config.dhcpdlease_file);
  84         }
  85 #endif                          /* POSIX_FADV_WILLNEED */
  86 #ifdef POSIX_FADV_SEQUENTIAL
  87         posix_fadvise((long) dhcpd_leases, 0, 0, POSIX_FADV_SEQUENTIAL);
  88         if (errno) {
  89                 err(EXIT_FAILURE, "parse_leases: fadvise %s",
  90                     config.dhcpdlease_file);
  91         }
  92 #endif                          /* POSIX_FADV_SEQUENTIAL */
  93
  94         /* I found out that there's one lease address per 300 bytes in
  95          * dhcpd.leases file. Malloc is little bit pessimistic and uses 250.
  96          * If someone has higher density in lease file I'm interested to
  97          * hear about that. */
  98         if (stat(config.dhcpdlease_file, &lease_file_stats)) {
  99                 err(EXIT_FAILURE, "parse_leases: %s",
 100                     config.dhcpdlease_file);
 101         }
 102         leasesmallocsize = (lease_file_stats.st_size / 250) + MAXLEN - 2;
 103         touchesmallocsize = (lease_file_stats.st_size / 250) + MAXLEN - 2;
 104         backupsmallocsize = (lease_file_stats.st_size / 120) + MAXLEN - 2;
 105         leases = safe_malloc(sizeof(long int) * leasesmallocsize);
 106         touches =
 107             safe_malloc((size_t) sizeof(long int) * touchesmallocsize);
 108
 109         line = safe_malloc(sizeof(long int) * MAXLEN);
 110         ipstring = safe_malloc(sizeof(long int) * MAXLEN);
 111         if (config.output_format[0] == 'X') {
 112                 macstring = safe_malloc(sizeof(char) * 18);
 113                 macaddr = safe_malloc(sizeof(struct macaddr_t));
 114                 macaddr_p = macaddr;
 115                 macaddr_p->next = NULL;
 116         }
 117
 118         while (!feof(dhcpd_leases)) {
 119                 fgets(line, MAXLEN, dhcpd_leases);
 120                 /* It's a lease, save IP */
 121                 if (strstr(line, "lease") == line) {
 122                         strncpy(ipstring, line, (size_t) MAXLEN);
 123                         nth_field(2, ipstring, ipstring);
 124                         inet_aton(ipstring, &inp);
 125                         sw_active_lease = 0;
 126                 }
 127                 /* Copy IP to correct array */
 128                 else if (strstr(line, "binding state active")) {
 129                         leases[num_leases] = htonl(inp.s_addr);
 130                         num_leases++;
 131                         assert(!(leasesmallocsize < num_leases));
 132                         sw_active_lease = 1;
 133                 } else if (strstr(line, "  binding state free")) {
 134                         touches[num_touches] = htonl(inp.s_addr);
 135                         num_touches++;
 136                         assert(!(touchesmallocsize < num_touches));
 137                 } else if (strstr(line, "  binding state backup")) {
 138                         if (num_backups == 0) {
 139                                 backups =
 140                                     safe_malloc((size_t) sizeof(long int) *
 141                                                 backupsmallocsize);
 142                         }
 143                         backups[num_backups] = htonl(inp.s_addr);
 144                         num_backups++;
 145                         assert(!(backupsmallocsize < num_backups));
 146                 }
 147
 148                 if ((macaddr != NULL)
 149                     && (sw_active_lease == 1)
 150                     && (strstr(line, "hardware ethernet"))) {
 151                         nth_field(3, macstring, line);
 152                         macstring[17] = '\0';
 153                         macaddr_p->ethernet = safe_strdup(macstring);
 154                         macaddr_p->ip = safe_strdup(ipstring);
 155                         macaddr_p->next =
 156                             safe_malloc(sizeof(struct macaddr_t));
 157                         macaddr_p = macaddr_p->next;
 158                         macaddr_p->next = NULL;
 159                 }
 160         }
 161         free(line);
 162         free(ipstring);
 163         if (macaddr != NULL) {
 164                 free(macstring);
 165         }
 166         return 0;
 167 }
 168
 169 /* Like strcpy but for field which is separated by white spaces. Number of
 170  * first field is 1 and not 0 like C programs should have. Question of
 171  * semantics, send mail to author if this annoys. All performance boosts for
 172  * this function are well come. */
 173 int nth_field(int n, char *dest, const char *src)
 174 {
 175         int i, j = 0, wordn = 0, len;
 176
 177         len = strlen(src);
 178
 179         for (i = 0; i < len; i++) {
 180                 if (isspace(src[i])) {
 181                         if (!(wordn < n)) {
 182                                 dest[j] = '\0';
 183                                 break;
 184                         }
 185                         j = 0;
 186                 } else {
 187                         if (j == 0) {
 188                                 wordn++;
 189                         }
 190                         if (wordn == n) {
 191                                 dest[j] = src[i];
 192                         }
 193                         j++;
 194                 }
 195         }
 196         return 0;
 197 }
 198
 199 /* dhcpd.conf interesting words */
 200 int is_interesting_config_clause(char *s)
 201 {
 202         if (strstr(s, "range")) {
 203                 return 3;
 204         } else if (strstr(s, "shared-network")) {
 205                 return 1;
 206         } else if (strstr(s, "include")) {
 207                 return 4;
 208         } else {
 209                 return 0;
 210         }
 211 }
 212
 213 /* FIXME: This spagetti monster function need to be rewrote at least ones. */
 214 char *parse_config(int is_include, char *config_file,
 215                    char *current_shared_name,
 216                    char *next_free_shared_name,
 217                    struct shared_network_t *shared_p)
 218 {
 219         FILE *dhcpd_config;
 220         int i = 0, newclause = true, argument = false, comment =
 221             false, braces = 0, quote = false;
 222         char *word, c;
 223         int braces_shared = 1000;
 224         struct in_addr inp;
 225         struct range_t *range_p;
 226
 227         char *last_shared_name;
 228         last_shared_name = SHARED_NETWORKS_NAMES + shared_net_names;
 229
 230         word = safe_malloc(sizeof(char) * MAXLEN);
 231
 232         if (is_include) {
 233                 /* Default place holder for ranges "All networks". */
 234                 shared_p->name = current_shared_name;
 235         }
 236
 237         /* Open configuration file */
 238         dhcpd_config = fopen(config_file, "r");
 239         if (dhcpd_config == NULL) {
 240                 err(EXIT_FAILURE, "parse_config: %s", config_file);
 241         }
 242 #ifdef POSIX_FADV_WILLNEED
 243         posix_fadvise((long) dhcpd_config, 0, 0, POSIX_FADV_WILLNEED);
 244         if (errno) {
 245                 err(EXIT_FAILURE, "parse_config: fadvise %s", config_file);
 246         }
 247 #endif                          /* POSIX_FADV_WILLNEED */
 248 #ifdef POSIX_FADV_SEQUENTIAL
 249         posix_fadvise((long) dhcpd_config, 0, 0, POSIX_FADV_SEQUENTIAL);
 250         if (errno) {
 251                 err(EXIT_FAILURE, "parse_config: fadvise %s", config_file);
 252         }
 253 #endif                          /* POSIX_FADV_SEQUENTIAL */
 254
 255         /* Very hairy stuff begins. */
 256         while (!feof(dhcpd_config)) {
 257                 c = fgetc(dhcpd_config);
 258                 /* Certain characters are magical */
 259                 switch (c) {
 260                         /* Handle comments if they are not quoted */
 261                 case '#':
 262                         if (quote == false) {
 263                                 comment = true;
 264                         }
 265                         continue;
 266                 case '"':
 267                         if (comment == false) {
 268                                 quote++;
 269                                 /* Either one or zero */
 270                                 quote = quote % 2;
 271                         }
 272                         continue;
 273                 case '\n':
 274                         /* New line resets comment section, but
 275                          * not if quoted */
 276                         if (quote == false) {
 277                                 comment = false;
 278                         }
 279                         break;
 280                 case ';':
 281                         /* Quoted colon does not mean new clause */
 282                         if (quote == true) {
 283                                 break;
 284                         }
 285                         if (comment == false && argument != 2
 286                             && argument != 4) {
 287                                 newclause = true;
 288                                 i = 0;
 289                         } else if (argument == 2) {
 290                                 /* Range ends to ; and this hair in code
 291                                  * make two ranges wrote to gether like...
 292                                  *
 293                                  * range 10.20.30.40 10.20.30.41;range 10.20.30.42 10.20.30.43;
 294                                  *
 295                                  * ...to be interpreted correctly. */
 296                                 c = ' ';
 297                         }
 298                         continue;
 299                 case '{':
 300                         if (quote == true) {
 301                                 break;
 302                         }
 303                         if (comment == false) {
 304                                 braces++;
 305                         }
 306                         /* i == 0 detects word that ends to brace like:
 307                          *
 308                          * shared-network DSL{ ... */
 309                         if (i == 0) {
 310                                 newclause = true;
 311                         }
 312                         continue;
 313                 case '}':
 314                         if (quote == true) {
 315                                 break;
 316                         }
 317                         if (comment == false) {
 318                                 braces--;
 319                                 /* End of shared-network */
 320                                 if (braces_shared == braces) {
 321                                         current_shared_name =
 322                                             shared_net_names;
 323                                         /* FIXME: Using 1000 is lame, but
 324                                          * works. */
 325                                         braces_shared = 1000;
 326                                         shared_p = shared_networks;
 327                                 }
 328                                 /* Not literally true, but works for this
 329                                  * program */
 330                                 newclause = true;
 331                         }
 332                         continue;
 333                 default:
 334                         break;
 335                 }
 336
 337                 /* Either inside comment or Nth word of clause. */
 338                 if (comment == true
 339                     || (newclause == false && argument == 0)) {
 340                         continue;
 341                 }
 342                 /* Strip white spaces before new clause word. */
 343                 if ((newclause == true || argument != 0) && isspace(c)
 344                     && i == 0) {
 345                         continue;
 346                 }
 347                 /* Save to word which clause this is. */
 348                 if ((newclause == true || argument != 0)
 349                     && (!isspace(c) || quote == true)) {
 350                         word[i] = c;
 351                         i++;
 352                         /* Long word which is almost causing overflow. None
 353                          * of words are this long which the program is
 354                          * searching. */
 355                         if (MAXLEN < i) {
 356                                 newclause = false;
 357                                 i = 0;
 358                                 continue;
 359                         }
 360                 }
 361                 /* See if clause is something that parser is looking for. */
 362                 else if (newclause == true) {
 363                         /* Insert string end & set state */
 364                         word[i] = '\0';
 365                         newclause = false;
 366                         i = 0;
 367
 368                         argument = is_interesting_config_clause(word);
 369                 }
 370                 /* words after range, shared-network or include */
 371                 else if (argument != 0) {
 372                         word[i] = '\0';
 373                         newclause = false;
 374                         i = 0;
 375
 376                         switch (argument) {
 377                         case 2:
 378                                 /* printf ("range 2nd ip: %s\n", word); */
 379                                 range_p = ranges + num_ranges;
 380                                 inet_aton(word, &inp);
 381                                 argument = 0;
 382                                 range_p->last_ip = htonl(inp.s_addr) + 1;
 383                                 range_p->count = 0;
 384                                 range_p->touched = 0;
 385                                 range_p->backups = 0;
 386                                 range_p->shared_net = shared_p;
 387                                 num_ranges++;
 388                                 if (RANGES < num_ranges) {
 389                                         errx(EXIT_FAILURE,
 390                                              "parse_config: Range space full! Increase RANGES and recompile.");
 391                                 }
 392                                 newclause = true;
 393                                 break;
 394                         case 3:
 395                                 /* printf ("range 1nd ip: %s\n", word); */
 396                                 range_p = ranges + num_ranges;
 397                                 if (!(inet_aton(word, &inp))) {
 398                                         /* word was not ip, try
 399                                          * again */
 400                                         break;
 401                                 }
 402                                 range_p->first_ip = htonl(inp.s_addr) - 1;
 403                                 argument = 2;
 404                                 break;
 405                         case 1:
 406                                 /* printf ("shared-network named: %s\n", word); */
 407                                 strcpy(next_free_shared_name, word);
 408                                 shared_p =
 409                                     shared_networks + num_shared_networks;
 410                                 num_shared_networks++;
 411                                 shared_p++;
 412                                 shared_p->name = next_free_shared_name;
 413                                 shared_p->available = 0;
 414                                 shared_p->used = 0;
 415                                 shared_p->touched = 0;
 416                                 shared_p->backups = 0;
 417                                 /* Temporary abuse of argument
 418                                  * variable */
 419                                 argument =
 420                                     strlen(next_free_shared_name) + 1;
 421                                 if (next_free_shared_name + argument <
 422                                     last_shared_name) {
 423                                         next_free_shared_name += argument;
 424                                 } else {
 425                                         /* FIXME: make this go
 426                                          * away by reallocationg
 427                                          * more space. */
 428                                         errx(EXIT_FAILURE,
 429                                              "parse_config: End of shared-network space, increase SHARED_NETWORKS_NAMES and recompile");
 430                                 }
 431                                 argument = 0;
 432                                 braces_shared = braces;
 433                                 break;
 434                         case 4:
 435                                 /* printf ("include file: %s\n", word); */
 436                                 argument = 0;
 437                                 next_free_shared_name =
 438                                     parse_config(false, word,
 439                                                  current_shared_name,
 440                                                  next_free_shared_name,
 441                                                  shared_p);
 442                                 newclause = true;
 443                                 break;
 444                         case 0:
 445                                 /* printf ("nothing interesting: %s\n", word); */
 446                                 argument = 0;
 447                                 break;
 448                         default:
 449                                 warnx("impossible occurred, report a bug");
 450                                 assert(0);
 451                         }
 452                 }
 453         }
 454         free(word);
 455         return next_free_shared_name;
 456 }