sharpetronics/strongswan
1
0
Fork 0
mirror of https://github.com/strongswan/strongswan.git synced 2025-10-15 00:00:16 -04:00
Code Issues Projects Releases Wiki Activity

starter: Use new parser to read config file

Browse Source
This commit is contained in:
Tobias Brunner 2014-05-21 14:51:44 +02:00
parent 640c75bb2e
commit 81ba3c1a5e
4 changed files with 507 additions and 783 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

207
src/starter/args.c
View File

@ -1,6 +1,7 @@
/* automatic handling of confread struct arguments
/*
* Copyright (C) 2014 Tobias Brunner
* Copyright (C) 2006 Andreas Steffen
* Hochschule fuer Technik Rapperswil, Switzerland
* Hochschule fuer Technik Rapperswil
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
@ -20,7 +21,6 @@
#include <library.h>
#include <utils/debug.h>
#include "keywords.h"
#include "confread.h"
#include "args.h"
@ -221,37 +221,16 @@ static const token_info_t token_info[] =
/*
* assigns an argument value to a struct field
*/
bool assign_arg(kw_token_t token, kw_token_t first, kw_list_t *kw, char *base,
bool *assigned)
bool assign_arg(kw_token_t token, kw_token_t first, char *key, char *value,
void *base, bool *assigned)
{
char *p = base + token_info[token].offset;
char *p = (char*)base + token_info[token].offset;
const char **list = token_info[token].list;
int index = -1; /* used for enumeration arguments */
seen_t *seen = (seen_t*)base; /* seen flags are at the top of the struct */
*assigned = FALSE;
DBG3(DBG_APP, " %s=%s", kw->entry->name, kw->value);
if (*seen & SEEN_KW(token, first))
{
DBG1(DBG_APP, "# duplicate '%s' option", kw->entry->name);
return FALSE;
}
if (token == KW_ESP || token == KW_AH)
{
if (*seen & (SEEN_KW(KW_ESP, first) | SEEN_KW(KW_AH, first)))
{
DBG1(DBG_APP, "# can't have both 'ah' and 'esp' options");
return FALSE;
}
}
/* set flag that this argument has been seen */
*seen |= SEEN_KW(token, first);
DBG3(DBG_APP, " %s=%s", key, value);
/* is there a keyword list? */
if (list != NULL)
@ -261,26 +240,26 @@ bool assign_arg(kw_token_t token, kw_token_t first, kw_list_t *kw, char *base,
while (*list != NULL && !match)
{
index++;
match = streq(kw->value, *list++);
match = streq(value, *list++);
}
if (!match)
{
DBG1(DBG_APP, "# bad value: %s=%s", kw->entry->name, kw->value);
DBG1(DBG_APP, "# bad value: %s=%s", key, value);
return FALSE;
}
}
switch (token_info[token].type)
{
case ARG_NONE:
DBG1(DBG_APP, "# option '%s' not supported yet", kw->entry->name);
return FALSE;
case ARG_ENUM:
case ARG_NONE:
DBG1(DBG_APP, "# option '%s' not supported yet", key);
return FALSE;
case ARG_ENUM:
{
if (index < 0)
{
DBG1(DBG_APP, "# bad enumeration value: %s=%s (%d)",
kw->entry->name, kw->value, index);
key, value, index);
return FALSE;
}
@ -290,93 +269,86 @@ bool assign_arg(kw_token_t token, kw_token_t first, kw_list_t *kw, char *base,
*b = (index > 0);
}
else
{
{ /* FIXME: this is not entirely correct as the args are enums */
int *i = (int *)p;
*i = index;
}
break;
}
break;
case ARG_UINT:
case ARG_UINT:
{
char *endptr;
u_int *u = (u_int *)p;
*u = strtoul(kw->value, &endptr, 10);
*u = strtoul(value, &endptr, 10);
if (*endptr != '\0')
{
DBG1(DBG_APP, "# bad integer value: %s=%s", kw->entry->name,
kw->value);
DBG1(DBG_APP, "# bad integer value: %s=%s", key, value);
return FALSE;
}
break;
}
break;
case ARG_ULNG:
case ARG_PCNT:
case ARG_ULNG:
case ARG_PCNT:
{
char *endptr;
unsigned long *l = (unsigned long *)p;
*l = strtoul(kw->value, &endptr, 10);
*l = strtoul(value, &endptr, 10);
if (token_info[token].type == ARG_ULNG)
{
if (*endptr != '\0')
{
DBG1(DBG_APP, "# bad integer value: %s=%s", kw->entry->name,
kw->value);
DBG1(DBG_APP, "# bad integer value: %s=%s", key, value);
return FALSE;
}
}
else
{
if ((*endptr != '%') || (endptr[1] != '\0') || endptr == kw->value)
if ((*endptr != '%') || (endptr[1] != '\0') || endptr == value)
{
DBG1(DBG_APP, "# bad percent value: %s=%s", kw->entry->name,
kw->value);
DBG1(DBG_APP, "# bad percent value: %s=%s", key, value);
return FALSE;
}
}
break;
}
break;
case ARG_ULLI:
case ARG_ULLI:
{
char *endptr;
unsigned long long *ll = (unsigned long long *)p;
*ll = strtoull(kw->value, &endptr, 10);
*ll = strtoull(value, &endptr, 10);
if (*endptr != '\0')
{
DBG1(DBG_APP, "# bad integer value: %s=%s", kw->entry->name,
kw->value);
DBG1(DBG_APP, "# bad integer value: %s=%s", key, value);
return FALSE;
}
break;
}
break;
case ARG_UBIN:
case ARG_UBIN:
{
char *endptr;
u_int *u = (u_int *)p;
*u = strtoul(kw->value, &endptr, 2);
*u = strtoul(value, &endptr, 2);
if (*endptr != '\0')
{
DBG1(DBG_APP, "# bad binary value: %s=%s", kw->entry->name,
kw->value);
DBG1(DBG_APP, "# bad binary value: %s=%s", key, value);
return FALSE;
}
break;
}
break;
case ARG_TIME:
case ARG_TIME:
{
char *endptr;
time_t *t = (time_t *)p;
*t = strtoul(kw->value, &endptr, 10);
*t = strtoul(value, &endptr, 10);
/* time in seconds? */
if (*endptr == '\0' || (*endptr == 's' && endptr[1] == '\0'))
@ -401,8 +373,7 @@ bool assign_arg(kw_token_t token, kw_token_t first, kw_list_t *kw, char *base,
break;
}
}
DBG1(DBG_APP, "# bad duration value: %s=%s", kw->entry->name,
kw->value);
DBG1(DBG_APP, "# bad duration value: %s=%s", key, value);
return FALSE;
}
case ARG_STR:
@ -411,9 +382,8 @@ bool assign_arg(kw_token_t token, kw_token_t first, kw_list_t *kw, char *base,
/* free any existing string */
free(*cp);
/* assign the new string */
*cp = strdupnull(kw->value);
*cp = strdupnull(value);
break;
}
default:
@ -427,45 +397,26 @@ bool assign_arg(kw_token_t token, kw_token_t first, kw_list_t *kw, char *base,
/*
* frees all dynamically allocated arguments in a struct
*/
void free_args(kw_token_t first, kw_token_t last, char *base)
void free_args(kw_token_t first, kw_token_t last, void *base)
{
kw_token_t token;
for (token = first; token <= last; token++)
{
char *p = base + token_info[token].offset;
char *p = (char*)base + token_info[token].offset;
switch (token_info[token].type)
{
case ARG_STR:
case ARG_STR:
{
char **cp = (char **)p;
free(*cp);
*cp = NULL;
break;
}
break;
default:
break;
}
}
}
/*
* clone all dynamically allocated arguments in a struct
*/
void clone_args(kw_token_t first, kw_token_t last, char *base1, char *base2)
{
kw_token_t token;
for (token = first; token <= last; token++)
{
if (token_info[token].type == ARG_STR)
{
char **cp1 = (char **)(base1 + token_info[token].offset);
char **cp2 = (char **)(base2 + token_info[token].offset);
*cp1 = strdupnull(*cp2);
default:
break;
}
}
}
@ -473,40 +424,42 @@ void clone_args(kw_token_t first, kw_token_t last, char *base1, char *base2)
/*
* compare all arguments in a struct
*/
bool cmp_args(kw_token_t first, kw_token_t last, char *base1, char *base2)
bool cmp_args(kw_token_t first, kw_token_t last, void *base1, void *base2)
{
kw_token_t token;
for (token = first; token <= last; token++)
{
char *p1 = base1 + token_info[token].offset;
char *p2 = base2 + token_info[token].offset;
char *p1 = (char*)base1 + token_info[token].offset;
char *p2 = (char*)base2 + token_info[token].offset;
switch (token_info[token].type)
{
case ARG_ENUM:
if (token_info[token].list == LST_bool)
case ARG_ENUM:
{
bool *b1 = (bool *)p1;
bool *b2 = (bool *)p2;
if (*b1 != *b2)
if (token_info[token].list == LST_bool)
{
return FALSE;
}
}
else
{
int *i1 = (int *)p1;
int *i2 = (int *)p2;
bool *b1 = (bool *)p1;
bool *b2 = (bool *)p2;
if (*i1 != *i2)
{
return FALSE;
if (*b1 != *b2)
{
return FALSE;
}
}
else
{
int *i1 = (int *)p1;
int *i2 = (int *)p2;
if (*i1 != *i2)
{
return FALSE;
}
}
break;
}
break;
case ARG_UINT:
case ARG_UINT:
{
u_int *u1 = (u_int *)p1;
u_int *u2 = (u_int *)p2;
@ -515,10 +468,10 @@ bool cmp_args(kw_token_t first, kw_token_t last, char *base1, char *base2)
{
return FALSE;
}
break;
}
break;
case ARG_ULNG:
case ARG_PCNT:
case ARG_ULNG:
case ARG_PCNT:
{
unsigned long *l1 = (unsigned long *)p1;
unsigned long *l2 = (unsigned long *)p2;
@ -527,9 +480,9 @@ bool cmp_args(kw_token_t first, kw_token_t last, char *base1, char *base2)
{
return FALSE;
}
break;
}
break;
case ARG_ULLI:
case ARG_ULLI:
{
unsigned long long *ll1 = (unsigned long long *)p1;
unsigned long long *ll2 = (unsigned long long *)p2;
@ -538,9 +491,9 @@ bool cmp_args(kw_token_t first, kw_token_t last, char *base1, char *base2)
{
return FALSE;
}
break;
}
break;
case ARG_TIME:
case ARG_TIME:
{
time_t *t1 = (time_t *)p1;
time_t *t2 = (time_t *)p2;
@ -549,9 +502,9 @@ bool cmp_args(kw_token_t first, kw_token_t last, char *base1, char *base2)
{
return FALSE;
}
break;
}
break;
case ARG_STR:
case ARG_STR:
{
char **cp1 = (char **)p1;
char **cp2 = (char **)p2;
@ -564,10 +517,10 @@ bool cmp_args(kw_token_t first, kw_token_t last, char *base1, char *base2)
{
return FALSE;
}
break;
}
break;
default:
break;
default:
break;
}
}
return TRUE;

16
src/starter/args.h
View File

@ -1,6 +1,6 @@
/* automatic handling of confread struct arguments
/*
* Copyright (C) 2006 Andreas Steffen
* Hochschule fuer Technik Rapperswil, Switzerland
* Hochschule fuer Technik Rapperswil
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
@ -17,15 +17,11 @@
#define _ARGS_H_
#include "keywords.h"
#include "ipsec-parser.h"
extern bool assign_arg(kw_token_t token, kw_token_t first, kw_list_t *kw
, char *base, bool *assigned);
extern void free_args(kw_token_t first, kw_token_t last, char *base);
extern void clone_args(kw_token_t first, kw_token_t last, char *base1
, char *base2);
extern bool cmp_args(kw_token_t first, kw_token_t last, char *base1
, char *base2);
bool assign_arg(kw_token_t token, kw_token_t first, char *key, char *value,
void *base, bool *assigned);
void free_args(kw_token_t first, kw_token_t last, void *base);
bool cmp_args(kw_token_t first, kw_token_t last, void *base1, void *base2);
#endif /* _ARGS_H_ */

1025
src/starter/confread.c
View File

File diff suppressed because it is too large Load Diff

42
src/starter/confread.h
View File

@ -18,13 +18,6 @@
#include <kernel/kernel_ipsec.h>
#include "ipsec-parser.h"
/** to mark seen keywords */
typedef u_int64_t seen_t;
#define SEEN_NONE 0;
#define SEEN_KW(kw, base) ((seen_t)1 << ((kw) - (base)))
typedef enum {
STARTUP_NO,
STARTUP_ADD,
@ -92,7 +85,6 @@ typedef enum {
typedef struct starter_end starter_end_t;
struct starter_end {
seen_t seen;
char *auth;
char *auth2;
char *id;
@ -121,22 +113,10 @@ struct starter_end {
char *dns;
};
typedef struct also also_t;
struct also {
char *name;
bool included;
also_t *next;
};
typedef struct starter_conn starter_conn_t;
struct starter_conn {
seen_t seen;
char *name;
also_t *also;
kw_list_t *kw;
u_int visit;
startup_t startup;
starter_state_t state;
@ -193,11 +173,7 @@ struct starter_conn {
typedef struct starter_ca starter_ca_t;
struct starter_ca {
seen_t seen;
char *name;
also_t *also;
kw_list_t *kw;
u_int visit;
startup_t startup;
starter_state_t state;
@ -217,7 +193,6 @@ typedef struct starter_config starter_config_t;
struct starter_config {
struct {
seen_t seen;
bool charonstart;
char *charondebug;
bool uniqueids;
@ -229,23 +204,14 @@ struct starter_config {
u_int err;
u_int non_fatal_err;
/* do we parse also statements */
bool parse_also;
/* ca %default */
starter_ca_t ca_default;
/* connections list (without %default) */
/* connections list */
starter_ca_t *ca_first, *ca_last;
/* conn %default */
starter_conn_t conn_default;
/* connections list (without %default) */
/* connections list */
starter_conn_t *conn_first, *conn_last;
};
extern starter_config_t *confread_load(const char *file);
extern void confread_free(starter_config_t *cfg);
starter_config_t *confread_load(const char *file);
void confread_free(starter_config_t *cfg);
#endif /* _IPSEC_CONFREAD_H_ */