src/starter/args.c

   1 /* automatic handling of confread struct arguments
   2  * Copyright (C) 2006 Andreas Steffen
   3  * Hochschule fuer Technik Rapperswil, Switzerland
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; either version 2 of the License, or (at your
   8  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * for more details.
  14  *
  15  * RCSID $Id$
  16  */
  17
  18 #include <stddef.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21
  22 #include <freeswan.h>
  23
  24 #include "../pluto/constants.h"
  25 #include "../pluto/defs.h"
  26 #include "../pluto/log.h"
  27
  28 #include "keywords.h"
  29 #include "parser.h"
  30 #include "confread.h"
  31 #include "args.h"
  32
  33 /* argument types */
  34
  35 typedef enum {
  36     ARG_NONE,
  37     ARG_ENUM,
  38     ARG_UINT,
  39     ARG_TIME,
  40     ARG_ULNG,
  41     ARG_PCNT,
  42     ARG_STR,
  43     ARG_LST,
  44     ARG_MISC
  45 } arg_t;
  46
  47 /* various keyword lists */
  48
  49 static const char *LST_bool[] = {
  50     "no",
  51     "yes",
  52      NULL
  53 };
  54
  55 static const char *LST_sendcert[] = {
  56     "always",
  57     "ifasked",
  58     "never",
  59     "yes",
  60     "no",
  61      NULL
  62 };
  63
  64 static const char *LST_unique[] = {
  65     "no",
  66     "yes",
  67     "replace",
  68     "keep",
  69      NULL
  70 };
  71
  72 static const char *LST_strict[] = {
  73     "no",
  74     "yes",
  75     "ifuri",
  76      NULL
  77 };
  78 static const char *LST_dpd_action[] = {
  79     "none",
  80     "clear",
  81     "hold",
  82     "restart",
  83      NULL
  84 };
  85
  86 static const char *LST_startup[] = {
  87     "ignore",
  88     "add",
  89     "route",
  90     "start",
  91      NULL
  92 };
  93
  94 static const char *LST_packetdefault[] = {
  95     "drop",
  96     "reject",
  97     "pass",
  98      NULL
  99 };
 100
 101 static const char *LST_keyexchange[] = {
 102     "ike",
 103     "ikev1",
 104     "ikev2",
 105      NULL
 106 };
 107
 108 static const char *LST_pfsgroup[] = {
 109     "modp1024",
 110     "modp1536",
 111     "modp2048",
 112     "modp3072",
 113     "modp4096",
 114     "modp6144",
 115     "modp8192",
 116      NULL
 117 };
 118
 119 static const char *LST_plutodebug[] = {
 120     "none",
 121     "all",
 122     "raw",
 123     "crypt",
 124     "parsing",
 125     "emitting",
 126     "control",
 127     "lifecycle",
 128     "klips",
 129     "dns",
 130     "natt",
 131     "oppo",
 132     "controlmore",
 133     "private",
 134      NULL
 135 };
 136
 137 static const char *LST_klipsdebug[] = {
 138     "tunnel",
 139     "tunnel-xmit",
 140     "pfkey",
 141     "xform",
 142     "eroute",
 143     "spi",
 144     "radij",
 145     "esp",
 146     "ah",
 147     "ipcomp",
 148     "verbose",
 149     "all",
 150     "none",
 151      NULL
 152 };
 153
 154 typedef struct {
 155     arg_t       type;
 156     size_t      offset;
 157     const char  **list;
 158 } token_info_t;
 159
 160 static const token_info_t token_info[] =
 161 {
 162     /* config setup keywords */
 163     { ARG_LST,  offsetof(starter_config_t, setup.interfaces), NULL                 },
 164     { ARG_STR,  offsetof(starter_config_t, setup.dumpdir), NULL                    },
 165     { ARG_ENUM, offsetof(starter_config_t, setup.charonstart), LST_bool            },
 166     { ARG_ENUM, offsetof(starter_config_t, setup.plutostart), LST_bool             },
 167
 168     /* pluto/charon keywords */
 169     { ARG_LST,  offsetof(starter_config_t, setup.plutodebug), LST_plutodebug       },
 170     { ARG_STR,  offsetof(starter_config_t, setup.charondebug),  NULL               },
 171     { ARG_STR,  offsetof(starter_config_t, setup.prepluto), NULL                   },
 172     { ARG_STR,  offsetof(starter_config_t, setup.postpluto), NULL                  },
 173     { ARG_ENUM, offsetof(starter_config_t, setup.uniqueids), LST_unique            },
 174     { ARG_UINT, offsetof(starter_config_t, setup.overridemtu), NULL                },
 175     { ARG_TIME, offsetof(starter_config_t, setup.crlcheckinterval), NULL           },
 176     { ARG_ENUM, offsetof(starter_config_t, setup.cachecrls), LST_bool              },
 177     { ARG_ENUM, offsetof(starter_config_t, setup.strictcrlpolicy), LST_strict      },
 178     { ARG_ENUM, offsetof(starter_config_t, setup.nocrsend), LST_bool               },
 179     { ARG_ENUM, offsetof(starter_config_t, setup.nat_traversal), LST_bool          },
 180     { ARG_TIME, offsetof(starter_config_t, setup.keep_alive), NULL                 },
 181     { ARG_ENUM, offsetof(starter_config_t, setup.force_keepalive), LST_bool        },
 182     { ARG_STR,  offsetof(starter_config_t, setup.virtual_private), NULL            },
 183     { ARG_STR,  offsetof(starter_config_t, setup.pkcs11module), NULL               },
 184     { ARG_STR,  offsetof(starter_config_t, setup.pkcs11initargs), NULL             },
 185     { ARG_ENUM, offsetof(starter_config_t, setup.pkcs11keepstate), LST_bool        },
 186     { ARG_ENUM, offsetof(starter_config_t, setup.pkcs11proxy), LST_bool            },
 187
 188     /* KLIPS keywords */
 189     { ARG_LST,  offsetof(starter_config_t, setup.klipsdebug), LST_klipsdebug       },
 190     { ARG_ENUM, offsetof(starter_config_t, setup.fragicmp), LST_bool               },
 191     { ARG_STR,  offsetof(starter_config_t, setup.packetdefault), LST_packetdefault },
 192     { ARG_ENUM, offsetof(starter_config_t, setup.hidetos), LST_bool                },
 193
 194     /* conn section keywords */
 195     { ARG_STR,  offsetof(starter_conn_t, name), NULL                               },
 196     { ARG_ENUM, offsetof(starter_conn_t, startup), LST_startup                     },
 197     { ARG_ENUM, offsetof(starter_conn_t, keyexchange), LST_keyexchange             },
 198     { ARG_MISC, 0, NULL  /* KW_TYPE */                                             },
 199     { ARG_MISC, 0, NULL  /* KW_PFS */                                              },
 200     { ARG_MISC, 0, NULL  /* KW_COMPRESS */                                         },
 201     { ARG_MISC, 0, NULL  /* KW_AUTH */                                             },
 202     { ARG_MISC, 0, NULL  /* KW_AUTHBY */                                           },
 203     { ARG_MISC, 0, NULL  /* KW_EAP */                                              },
 204     { ARG_MISC, 0, NULL  /* KW_MOBIKE */                                           },
 205     { ARG_MISC, 0, NULL  /* KW_FORCEENCAPS */                                      },
 206     { ARG_TIME, offsetof(starter_conn_t, sa_ike_life_seconds), NULL                },
 207     { ARG_TIME, offsetof(starter_conn_t, sa_ipsec_life_seconds), NULL              },
 208     { ARG_TIME, offsetof(starter_conn_t, sa_rekey_margin), NULL                    },
 209     { ARG_MISC, 0, NULL  /* KW_KEYINGTRIES */                                      },
 210     { ARG_PCNT, offsetof(starter_conn_t, sa_rekey_fuzz), NULL                      },
 211     { ARG_MISC, 0, NULL  /* KW_REKEY */                                            },
 212     { ARG_MISC, 0, NULL  /* KW_REAUTH */                                           },
 213     { ARG_STR,  offsetof(starter_conn_t, ike), NULL                                },
 214     { ARG_STR,  offsetof(starter_conn_t, esp), NULL                                },
 215     { ARG_STR,  offsetof(starter_conn_t, pfsgroup), LST_pfsgroup                   },
 216     { ARG_TIME, offsetof(starter_conn_t, dpd_delay), NULL                          },
 217     { ARG_TIME, offsetof(starter_conn_t, dpd_timeout), NULL                        },
 218     { ARG_ENUM, offsetof(starter_conn_t, dpd_action), LST_dpd_action               },
 219     { ARG_MISC, 0, NULL  /* KW_MODECONFIG */                                       },
 220     { ARG_MISC, 0, NULL  /* KW_XAUTH */                                            },
 221     { ARG_ENUM, offsetof(starter_conn_t, me_mediation), LST_bool                   },
 222     { ARG_STR,  offsetof(starter_conn_t, me_mediated_by), NULL                     },
 223     { ARG_STR,  offsetof(starter_conn_t, me_peerid), NULL                          },
 224
 225     /* ca section keywords */
 226     { ARG_STR,  offsetof(starter_ca_t, name), NULL                                 },
 227     { ARG_ENUM, offsetof(starter_ca_t, startup), LST_startup                       },
 228     { ARG_STR,  offsetof(starter_ca_t, cacert), NULL                               },
 229     { ARG_STR,  offsetof(starter_ca_t, ldaphost), NULL                             },
 230     { ARG_STR,  offsetof(starter_ca_t, ldapbase), NULL                             },
 231     { ARG_STR,  offsetof(starter_ca_t, crluri), NULL                               },
 232     { ARG_STR,  offsetof(starter_ca_t, crluri2), NULL                              },
 233     { ARG_STR,  offsetof(starter_ca_t, ocspuri), NULL                              },
 234     { ARG_STR,  offsetof(starter_ca_t, ocspuri2), NULL                             },
 235     { ARG_STR,  offsetof(starter_ca_t, certuribase), NULL                          },
 236
 237     /* end keywords */
 238     { ARG_MISC, 0, NULL  /* KW_HOST */                                             },
 239     { ARG_MISC, 0, NULL  /* KW_NEXTHOP */                                          },
 240     { ARG_STR, offsetof(starter_end_t, subnet), NULL                               },
 241     { ARG_MISC, 0, NULL  /* KW_SUBNETWITHIN */                                     },
 242     { ARG_MISC, 0, NULL  /* KW_PROTOPORT */                                        },
 243     { ARG_STR, offsetof(starter_end_t, srcip), NULL                                },
 244     { ARG_MISC, 0, NULL  /* KW_NATIP */                                            },
 245     { ARG_ENUM, offsetof(starter_end_t, firewall), LST_bool                        },
 246     { ARG_ENUM, offsetof(starter_end_t, hostaccess), LST_bool                      },
 247     { ARG_ENUM, offsetof(starter_end_t, allow_any), LST_bool                       },
 248     { ARG_STR,  offsetof(starter_end_t, updown), NULL                              },
 249     { ARG_STR,  offsetof(starter_end_t, id), NULL                                  },
 250     { ARG_STR,  offsetof(starter_end_t, rsakey), NULL                              },
 251     { ARG_STR,  offsetof(starter_end_t, cert), NULL                                },
 252     { ARG_ENUM, offsetof(starter_end_t, sendcert), LST_sendcert                    },
 253     { ARG_STR,  offsetof(starter_end_t, ca), NULL                                  },
 254     { ARG_STR,  offsetof(starter_end_t, groups), NULL                              },
 255     { ARG_STR,  offsetof(starter_end_t, iface), NULL                               }
 256 };
 257
 258 static void
 259 free_list(char **list)
 260 {
 261     char **s;
 262
 263     for (s = list; *s; s++)
 264         pfree(*s);
 265     pfree(list);
 266 }
 267
 268 char **
 269 new_list(char *value)
 270 {
 271     char *val, *b, *e, *end, **ret;
 272     int count;
 273
 274     val = value ? clone_str(value, "list value") : NULL;
 275     if (!val)
 276         return NULL;
 277     end = val + strlen(val);
 278     for (b = val, count = 0; b < end;)
 279     {
 280         for (e = b; ((*e != ' ') && (*e != '\0')); e++);
 281         *e = '\0';
 282         if (e != b)
 283             count++;
 284         b = e + 1;
 285     }
 286     if (count == 0)
 287     {
 288         pfree(val);
 289         return NULL;
 290     }
 291     ret = (char **)alloc_bytes((count+1) * sizeof(char *), "list");
 292
 293     for (b = val, count = 0; b < end; )
 294     {
 295         for (e = b; (*e != '\0'); e++);
 296         if (e != b)
 297             ret[count++] = clone_str(b, "list value");
 298         b = e + 1;
 299     }
 300     ret[count] = NULL;
 301     pfree(val);
 302     return ret;
 303 }
 304
 305
 306 /*
 307  * assigns an argument value to a struct field
 308  */
 309 bool
 310 assign_arg(kw_token_t token, kw_token_t first, kw_list_t *kw, char *base
 311     , bool *assigned)
 312 {
 313     char *p = base + token_info[token].offset;
 314     const char **list = token_info[token].list;
 315
 316     int index = -1;  /* used for enumeration arguments */
 317
 318     lset_t *seen = (lset_t *)base;    /* seen flags are at the top of the struct */
 319     lset_t f = LELEM(token - first);  /* compute flag position of argument */
 320
 321     *assigned = FALSE;
 322
 323     DBG(DBG_CONTROLMORE,
 324         DBG_log("  %s=%s", kw->entry->name, kw->value)
 325     )
 326
 327     if (*seen & f)
 328     {
 329         plog("# duplicate '%s' option", kw->entry->name);
 330         return FALSE;
 331     }
 332
 333     /* set flag that this argument has been seen */
 334     *seen |= f;
 335
 336     /* is there a keyword list? */
 337     if (list != NULL && token_info[token].type != ARG_LST)
 338     {
 339         bool match = FALSE;
 340
 341         while (*list != NULL && !match)
 342         {
 343             index++;
 344             match = streq(kw->value, *list++);
 345         }
 346         if (!match)
 347         {
 348             plog("# bad value: %s=%s", kw->entry->name, kw->value);
 349             return FALSE;
 350         }
 351     }
 352
 353     switch (token_info[token].type)
 354     {
 355     case ARG_NONE:
 356         plog("# option '%s' not supported yet", kw->entry->name);
 357         return FALSE;
 358     case ARG_ENUM:
 359         {
 360             int *i = (int *)p;
 361
 362             if (index < 0)
 363             {
 364                 plog("# bad enumeration value: %s=%s (%d)"
 365                     , kw->entry->name, kw->value, index);
 366                 return FALSE;
 367             }
 368             *i = index;
 369         }
 370         break;
 371
 372     case ARG_UINT:
 373         {
 374             char *endptr;
 375             u_int *u = (u_int *)p;
 376
 377             *u = strtoul(kw->value, &endptr, 10);
 378
 379             if (*endptr != '\0')
 380             {
 381                 plog("# bad integer value: %s=%s", kw->entry->name, kw->value);
 382                 return FALSE;
 383             }
 384         }
 385         break;
 386     case ARG_ULNG:
 387     case ARG_PCNT:
 388         {
 389             char *endptr;
 390             unsigned long *l = (unsigned long *)p;
 391
 392             *l = strtoul(kw->value, &endptr, 10);
 393
 394             if (token_info[token].type == ARG_ULNG)
 395             {
 396                 if (*endptr != '\0')
 397                 {
 398                     plog("# bad integer value: %s=%s", kw->entry->name, kw->value);
 399                     return FALSE;
 400                 }
 401             }
 402             else
 403             {
 404                 if ((*endptr != '%') || (endptr[1] != '\0') || endptr == kw->value)
 405                 {
 406                     plog("# bad percent value: %s=%s", kw->entry->name, kw->value);
 407                     return FALSE;
 408                 }
 409             }
 410
 411         }
 412         break;
 413     case ARG_TIME:
 414         {
 415             char *endptr;
 416             time_t *t = (time_t *)p;
 417
 418             *t = strtoul(kw->value, &endptr, 10);
 419
 420             /* time in seconds? */
 421             if (*endptr == '\0' || (*endptr == 's' && endptr[1] == '\0'))
 422                 break;
 423
 424             if (endptr[1] == '\0')
 425             {
 426                 if (*endptr == 'm')  /* time in minutes? */
 427                 {
 428                     *t *= 60;
 429                     break;
 430                 }
 431                 if (*endptr == 'h')  /* time in hours? */
 432                 {
 433                     *t *= 3600;
 434                     break;
 435                 }
 436                 if (*endptr == 'd')  /* time in days? */
 437                 {
 438                     *t *= 3600*24;
 439                     break;
 440                 }
 441             }
 442             plog("# bad duration value: %s=%s", kw->entry->name, kw->value);
 443             return FALSE;
 444         }
 445     case ARG_STR:
 446         {
 447             char **cp = (char **)p;
 448
 449             /* free any existing string */
 450             pfreeany(*cp);
 451
 452             /* assign the new string */
 453             *cp = clone_str(kw->value, "str_value");
 454         }
 455         break;
 456     case ARG_LST:
 457         {
 458             char ***listp = (char ***)p;
 459
 460             /* free any existing list */
 461             if (*listp != NULL)
 462                 free_list(*listp);
 463
 464             /* create a new list and assign values */
 465             *listp = new_list(kw->value);
 466
 467             /* is there a keyword list? */
 468             if (list != NULL)
 469             {
 470                 char ** lst;
 471
 472                 for (lst = *listp; lst && *lst; lst++)
 473                 {
 474                     bool match = FALSE;
 475
 476                     list = token_info[token].list;
 477
 478                     while (*list != NULL && !match)
 479                     {
 480                         match = streq(*lst, *list++);
 481                     }
 482                     if (!match)
 483                     {
 484                         plog("# bad value: %s=%s", kw->entry->name, *lst);
 485                         return FALSE;
 486                     }
 487                 }
 488             }
 489         }
 490     default:
 491         return TRUE;
 492     }
 493
 494     *assigned = TRUE;
 495     return TRUE;
 496 }
 497
 498 /*
 499  *  frees all dynamically allocated arguments in a struct
 500  */
 501 void
 502 free_args(kw_token_t first, kw_token_t last, char *base)
 503 {
 504     kw_token_t token;
 505
 506     for (token = first; token <= last; token++)
 507     {
 508         char *p = base + token_info[token].offset;
 509
 510         switch (token_info[token].type)
 511         {
 512         case ARG_STR:
 513             {
 514                 char **cp = (char **)p;
 515
 516                 pfreeany(*cp);
 517                 *cp = NULL;
 518             }
 519             break;
 520         case ARG_LST:
 521             {
 522                 char ***listp = (char ***)p;
 523
 524                 if (*listp != NULL)
 525                 {
 526                     free_list(*listp);
 527                     *listp = NULL;
 528                  }
 529             }
 530             break;
 531         default:
 532             break;
 533         }
 534     }
 535 }
 536
 537 /*
 538  *  clone all dynamically allocated arguments in a struct
 539  */
 540 void
 541 clone_args(kw_token_t first, kw_token_t last, char *base1, char *base2)
 542 {
 543     kw_token_t token;
 544
 545     for (token = first; token <= last; token++)
 546     {
 547         if (token_info[token].type == ARG_STR)
 548         {
 549             char **cp1 = (char **)(base1 + token_info[token].offset);
 550             char **cp2 = (char **)(base2 + token_info[token].offset);
 551
 552             *cp1 = clone_str(*cp2, "cloned str");
 553         }
 554     }
 555 }
 556
 557 static bool
 558 cmp_list(char **list1, char **list2)
 559 {
 560     if ((list1 == NULL) && (list2 == NULL))
 561         return TRUE;
 562     if ((list1 == NULL) || (list2 == NULL))
 563         return FALSE;
 564
 565     for ( ; *list1 && *list2; list1++, list2++)
 566     {
 567         if (strcmp(*list1,*list2) != 0)
 568             return FALSE;
 569     }
 570
 571     if ((*list1 != NULL) || (*list2 != NULL))
 572         return FALSE;
 573
 574     return TRUE;
 575 }
 576
 577 /*
 578  *  compare all arguments in a struct
 579  */
 580 bool
 581 cmp_args(kw_token_t first, kw_token_t last, char *base1, char *base2)
 582 {
 583     kw_token_t token;
 584
 585     for (token = first; token <= last; token++)
 586     {
 587         char *p1 = base1 + token_info[token].offset;
 588         char *p2 = base2 + token_info[token].offset;
 589
 590         switch (token_info[token].type)
 591         {
 592         case ARG_ENUM:
 593             {
 594                 int *i1 = (int *)p1;
 595                 int *i2 = (int *)p2;
 596
 597                 if (*i1 != *i2)
 598                     return FALSE;
 599             }
 600             break;
 601         case ARG_UINT:
 602             {
 603                 u_int *u1 = (u_int *)p1;
 604                 u_int *u2 = (u_int *)p2;
 605
 606                 if (*u1 != *u2)
 607                     return FALSE;
 608             }
 609             break;
 610         case ARG_ULNG:
 611         case ARG_PCNT:
 612             {
 613                 unsigned long *l1 = (unsigned long *)p1;
 614                 unsigned long *l2 = (unsigned long *)p2;
 615
 616                 if (*l1 != *l2)
 617                     return FALSE;
 618             }
 619             break;
 620         case ARG_TIME:
 621             {
 622                 time_t *t1 = (time_t *)p1;
 623                 time_t *t2 = (time_t *)p2;
 624
 625                 if (*t1 != *t2)
 626                     return FALSE;
 627             }
 628             break;
 629         case ARG_STR:
 630             {
 631                 char **cp1 = (char **)p1;
 632                 char **cp2 = (char **)p2;
 633
 634                 if (*cp1 == NULL && *cp2 == NULL)
 635                     break;
 636                 if (*cp1 == NULL || *cp2 == NULL || strcmp(*cp1, *cp2) != 0)
 637                     return FALSE;
 638             }
 639             break;
 640         case ARG_LST:
 641             {
 642                 char ***listp1 = (char ***)p1;
 643                 char ***listp2 = (char ***)p2;
 644
 645                 if (!cmp_list(*listp1, *listp2))
 646                     return FALSE;
 647             }
 648             break;
 649         default:
 650             break;
 651         }
 652     }
 653     return TRUE;
 654 }