#ifndef lint
static char copyright[] =
-"$Id: clparse.c,v 1.57 2001/03/01 18:16:57 mellon Exp $ Copyright (c) 1996-2001 The Internet Software Consortium. All rights reserved.\n";
+"$Id: clparse.c,v 1.58 2001/03/17 00:47:30 mellon Exp $ Copyright (c) 1996-2001 The Internet Software Consortium. All rights reserved.\n";
#endif /* not lint */
#include "dhcpd.h"
new_parse (&cfile, file, (char *)0, 0, path_dhclient_conf);
do {
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == END_OF_FILE)
break;
parse_client_statement (cfile,
(struct interface_info *)0,
&top_level_config);
} while (1);
- token = next_token (&val, cfile); /* Clear the peek buffer */
+ token = next_token (&val, (unsigned *)0, cfile); /* Clear the peek buffer */
status = (cfile -> warnings_occurred
? ISC_R_BADPARSE
: ISC_R_SUCCESS);
new_parse (&cfile, file, (char *)0, 0, path_dhclient_db);
do {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token == END_OF_FILE)
break;
if (token != LEASE) {
int known;
int tmp, i;
- switch (peek_token (&val, cfile)) {
+ switch (peek_token (&val, (unsigned *)0, cfile)) {
case KEY:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
if (ip) {
/* This may seem arbitrary, but there's a reason for
doing it: the authentication key database is not
/* REQUIRE can either start a policy statement or a
comma-seperated list of names of required options. */
case REQUIRE:
- next_token (&val, cfile);
- token = peek_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == AUTHENTICATION) {
policy = P_REQUIRE;
goto do_policy;
return;
case IGNORE:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
policy = P_IGNORE;
goto do_policy;
case ACCEPT:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
policy = P_ACCEPT;
goto do_policy;
case PREFER:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
policy = P_PREFER;
goto do_policy;
case DONT:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
policy = P_DONT;
goto do_policy;
do_policy:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token == AUTHENTICATION) {
if (policy != P_PREFER &&
policy != P_REQUIRE &&
break;
case OPTION:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == SPACE) {
if (ip) {
parse_warn (cfile,
if (!option)
return;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != CODE) {
parse_warn (cfile, "expecting \"code\" keyword.");
skip_to_semi (cfile);
return;
case MEDIA:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
parse_string_list (cfile, &config -> media, 1);
return;
case HARDWARE:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (ip) {
parse_hardware_param (cfile, &ip -> hw_address);
} else {
return;
case REQUEST:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (config -> requested_options == default_requested_options)
config -> requested_options = (u_int32_t *)0;
parse_option_list (cfile, &config -> requested_options);
return;
case TIMEOUT:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
parse_lease_time (cfile, &config -> timeout);
return;
case RETRY:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
parse_lease_time (cfile, &config -> retry_interval);
return;
case SELECT_TIMEOUT:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
parse_lease_time (cfile, &config -> select_interval);
return;
case OMAPI:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != PORT) {
parse_warn (cfile,
"unexpected omapi subtype: %s", val);
skip_to_semi (cfile);
return;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NUMBER) {
parse_warn (cfile, "invalid port number: `%s'", val);
skip_to_semi (cfile);
return;
case REBOOT:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
parse_lease_time (cfile, &config -> reboot_timeout);
return;
case BACKOFF_CUTOFF:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
parse_lease_time (cfile, &config -> backoff_cutoff);
return;
case INITIAL_INTERVAL:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
parse_lease_time (cfile, &config -> initial_interval);
return;
case SCRIPT:
- token = next_token (&val, cfile);
- config -> script_name = parse_string (cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
+ parse_string (cfile, &config -> script_name, (unsigned *)0);
return;
case VENDOR:
- token = next_token (&val, cfile);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != OPTION) {
parse_warn (cfile, "expecting 'vendor option space'");
skip_to_semi (cfile);
return;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != SPACE) {
parse_warn (cfile, "expecting 'vendor option space'");
skip_to_semi (cfile);
return;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!is_identifier (token)) {
parse_warn (cfile, "expecting an identifier.");
skip_to_semi (cfile);
return;
case INTERFACE:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (ip)
parse_warn (cfile, "nested interface declaration.");
parse_interface_declaration (cfile, config, (char *)0);
return;
case PSEUDO:
- token = next_token (&val, cfile);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
name = dmalloc (strlen (val) + 1, MDL);
if (!name)
log_fatal ("no memory for pseudo interface name");
return;
case LEASE:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
parse_client_lease_statement (cfile, 1);
return;
case ALIAS:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
parse_client_lease_statement (cfile, 2);
return;
case REJECT:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
parse_reject_statement (cfile, config);
return;
ix = 0;
do {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token == SEMI)
break;
if (!is_identifier (token)) {
p = r;
q = r;
++ix;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
} while (token == COMMA);
if (token != SEMI) {
parse_warn (cfile, "expecting semicolon.");
struct client_state *client, **cp;
struct interface_info *ip = (struct interface_info *)0;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != STRING) {
parse_warn (cfile, "expecting interface name (in quotes).");
skip_to_semi (cfile);
ip -> flags &= ~INTERFACE_AUTOMATIC;
interfaces_requested = 1;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LBRACE) {
parse_warn (cfile, "expecting left brace.");
skip_to_semi (cfile);
}
do {
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == END_OF_FILE) {
parse_warn (cfile,
"unterminated interface declaration.");
break;
parse_client_statement (cfile, ip, client -> config);
} while (1);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
}
int interface_or_dummy (struct interface_info **pi, const char *name)
const char *val;
struct client_state *client = (struct client_state *)0;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LBRACE) {
parse_warn (cfile, "expecting left brace.");
skip_to_semi (cfile);
log_fatal ("no memory for lease options.\n");
do {
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == END_OF_FILE) {
parse_warn (cfile, "unterminated lease declaration.");
return;
break;
parse_client_lease_declaration (cfile, lease, &ip, &client);
} while (1);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
/* If the lease declaration didn't include an interface
declaration that we recognized, it's of no use to us. */
struct client_state *client = (struct client_state *)0;
struct data_string key_id;
- switch (next_token (&val, cfile)) {
+ switch (next_token (&val, (unsigned *)0, cfile)) {
case KEY:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != STRING && !is_identifier (token)) {
parse_warn (cfile, "expecting key name.");
skip_to_semi (cfile);
break;
case INTERFACE:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != STRING) {
parse_warn (cfile,
"expecting interface name (in quotes).");
break;
case NAME:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
ip = *ipp;
if (!ip) {
parse_warn (cfile, "state name precedes interface.");
return;
case FILENAME:
- lease -> filename = parse_string (cfile);
+ parse_string (cfile, &lease -> filename, (unsigned *)0);
return;
case SERVER_NAME:
- lease -> server_name = parse_string (cfile);
+ parse_string (cfile, &lease -> server_name, (unsigned *)0);
return;
case RENEW:
skip_to_semi (cfile);
break;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != SEMI) {
parse_warn (cfile, "expecting semicolon.");
skip_to_semi (cfile);
}
do {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != STRING) {
parse_warn (cfile, "Expecting media options.");
skip_to_semi (cfile);
*lp = tmp;
cur = tmp;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
} while (multiple && token == COMMA);
if (token != SEMI) {
list -> next = config -> reject_list;
config -> reject_list = list;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
} while (token == COMMA);
if (token != SEMI) {
#ifndef lint
static char copyright[] =
-"$Id: parse.c,v 1.101 2001/03/01 18:17:00 mellon Exp $ Copyright (c) 1995-2001 The Internet Software Consortium. All rights reserved.\n";
+"$Id: parse.c,v 1.102 2001/03/17 00:47:33 mellon Exp $ Copyright (c) 1995-2001 The Internet Software Consortium. All rights reserved.\n";
#endif /* not lint */
#include "dhcpd.h"
log_error ("skip_to_rbrace: %d\n", brace_count);
#endif
do {
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == RBRACE) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (brace_count) {
if (!--brace_count)
return;
} else if (token == LBRACE) {
brace_count++;
} else if (token == SEMI && !brace_count) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
return;
} else if (token == EOL) {
/* EOL only happens when parsing /etc/resolv.conf,
and we treat it like a semicolon because the
resolv.conf file is line-oriented. */
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
return;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
} while (token != END_OF_FILE);
}
enum dhcp_token token;
const char *val;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != SEMI) {
parse_warn (cfile, "semicolon expected.");
skip_to_semi (cfile);
/* string-parameter :== STRING SEMI */
-char *parse_string (cfile)
+int parse_string (cfile, sptr, lptr)
struct parse *cfile;
+ char **sptr;
+ unsigned *lptr;
{
const char *val;
enum dhcp_token token;
char *s;
+ unsigned len;
- token = next_token (&val, cfile);
+ token = next_token (&val, &len, cfile);
if (token != STRING) {
parse_warn (cfile, "expecting a string");
skip_to_semi (cfile);
- return (char *)0;
+ return 0;
}
- s = (char *)dmalloc (strlen (val) + 1, MDL);
+ s = (char *)dmalloc (len + 1, MDL);
if (!s)
log_fatal ("no memory for string %s.", val);
- strcpy (s, val);
+ memcpy (s, val, len + 1);
- if (!parse_semi (cfile))
- return (char *)0;
- return s;
+ if (!parse_semi (cfile)) {
+ dfree (s, MDL);
+ return 0;
+ }
+ if (sptr)
+ *sptr = s;
+ else
+ dfree (s, MDL);
+ if (lptr)
+ *lptr = len;
+ return 1;
}
/*
/* Read a dotted hostname... */
do {
/* Read a token, which should be an identifier. */
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (!is_identifier (token) && token != NUMBER)
break;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
/* Store this identifier... */
if (!(s = (char *)dmalloc (strlen (val) + 1, MDL)))
len += strlen (s) + 1;
/* Look for a dot; if it's there, keep going, otherwise
we're done. */
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == DOT) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
ltid = 1;
} else
ltid = 0;
char *name;
struct expression *x = (struct expression *)0;
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (is_identifier (token)) {
name = parse_host_name (cfile);
if (!name)
return make_const_data (expr, addr, len, 0, 1);
} else {
if (token != RBRACE && token != LBRACE)
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
parse_warn (cfile, "%s (%d): expecting IP address or hostname",
val, token);
if (token != SEMI)
unsigned hlen;
unsigned char *t;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
switch (token) {
case ETHERNET:
hardware -> hbuf [0] = HTYPE_ETHER;
that data in the lease file rather than simply failing on such
clients. Yuck. */
hlen = 0;
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == SEMI) {
hardware -> hlen = 1;
goto out;
}
out:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != SEMI) {
parse_warn (cfile, "expecting semicolon.");
skip_to_semi (cfile);
const char *val;
enum dhcp_token token;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NUMBER) {
parse_warn (cfile, "Expecting numeric lease time");
skip_to_semi (cfile);
do {
if (count) {
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token != seperator) {
if (!*max)
break;
if (token != RBRACE && token != LBRACE)
- token = next_token (&val, cfile);
+ token = next_token (&val,
+ (unsigned *)0,
+ cfile);
parse_warn (cfile, "too few numbers.");
if (token != SEMI)
skip_to_semi (cfile);
return (unsigned char *)0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token == END_OF_FILE) {
parse_warn (cfile, "unexpected end of file");
212, 243, 273, 304, 334 };
/* Day of week, or "never"... */
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token == NEVER) {
if (!parse_semi (cfile))
return 0;
wday = atoi (val);
/* Year... */
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NUMBER) {
parse_warn (cfile, "numeric year expected.");
if (token != SEMI)
year -= 1900;
/* Slash seperating year from month... */
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != SLASH) {
parse_warn (cfile,
"expected slash seperating year from month.");
}
/* Month... */
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NUMBER) {
parse_warn (cfile, "numeric month expected.");
if (token != SEMI)
mon = atoi (val) - 1;
/* Slash seperating month from day... */
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != SLASH) {
parse_warn (cfile,
"expected slash seperating month from day.");
}
/* Month... */
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NUMBER) {
parse_warn (cfile, "numeric day of month expected.");
if (token != SEMI)
mday = atoi (val);
/* Hour... */
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NUMBER) {
parse_warn (cfile, "numeric hour expected.");
if (token != SEMI)
hour = atoi (val);
/* Colon seperating hour from minute... */
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COLON) {
parse_warn (cfile,
"expected colon seperating hour from minute.");
}
/* Minute... */
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NUMBER) {
parse_warn (cfile, "numeric minute expected.");
if (token != SEMI)
min = atoi (val);
/* Colon seperating minute from second... */
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COLON) {
parse_warn (cfile,
"expected colon seperating hour from minute.");
}
/* Minute... */
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NUMBER) {
parse_warn (cfile, "numeric minute expected.");
if (token != SEMI)
}
sec = atoi (val);
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == NUMBER) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
tzoff = atoi (val);
} else
tzoff = 0;
struct universe *universe;
struct option *option;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!is_identifier (token)) {
parse_warn (cfile,
"expecting identifier after option keyword.");
if (!uname)
log_fatal ("no memory for uname information.");
strcpy (uname, val);
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == DOT) {
/* Go ahead and take the DOT token... */
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
/* The next token should be an identifier... */
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!is_identifier (token)) {
parse_warn (cfile, "expecting identifier after '.'");
if (token != SEMI)
struct universe **ua, *nu;
char *s;
- next_token (&val, cfile); /* Discard the SPACE token, which was
- checked by the caller. */
- token = next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile); /* Discard the SPACE token,
+ which was checked by the
+ caller. */
+ token = next_token (&val, (unsigned *)0, cfile);
if (!is_identifier (token)) {
parse_warn (cfile, "expecting identifier.");
skip_to_semi (cfile);
int has_encapsulation = 0;
/* Parse the option code. */
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NUMBER) {
parse_warn (cfile, "expecting option code number.");
skip_to_semi (cfile);
}
option -> code = atoi (val);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != EQUAL) {
parse_warn (cfile, "expecting \"=\"");
skip_to_semi (cfile);
}
/* See if this is an array. */
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token == ARRAY) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != OF) {
parse_warn (cfile, "expecting \"of\".");
skip_to_semi (cfile);
return 0;
}
arrayp = 1;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
}
if (token == LBRACE) {
recordp = 1;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
}
/* At this point we're expecting a data type. */
skip_to_semi (cfile);
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != OF) {
parse_warn (cfile, "expecting \"of\".");
skip_to_semi (cfile);
return 0;
}
arrayp = recordp + 1;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if ((recordp) && (token == LBRACE)) {
parse_warn (cfile,
"only uniform array inside record.");
case INTEGER:
is_signed = 1;
parse_integer:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NUMBER) {
parse_warn (cfile, "expecting number.");
skip_to_rbrace (cfile, recordp);
case SIGNED:
is_signed = 1;
parse_signed:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != INTEGER) {
parse_warn (cfile, "expecting \"integer\" keyword.");
skip_to_rbrace (cfile, recordp);
goto no_arrays;
case ENCAPSULATE:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!is_identifier (token)) {
parse_warn (cfile,
"expecting option space identifier");
tokbuf [tokix++] = type;
if (recordp) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (arrayp > recordp) {
if (tokix == sizeof tokbuf) {
parse_warn (cfile,
skip_to_semi (cfile);
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
goto next_type;
}
if (token != RBRACE) {
tokenized into more than one token, so we have to parse them all
in before decoding. */
do {
- int l;
+ unsigned l;
- token = next_token (&val, cfile);
- l = strlen (val);
+ token = next_token (&val, &l, cfile);
t = dmalloc (l + sizeof *t, MDL);
if (!t)
log_fatal ("no memory for base64 buffer.");
memset (t, 0, (sizeof *t) - 1);
- strcpy (t -> string, val);
+ memcpy (t -> string, val, l + 1);
cc += l;
if (last)
last -> next = t;
else
bufs = t;
last = t;
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
} while (token == NUMBER_OR_NAME || token == NAME || token == EQUAL ||
token == NUMBER || token == PLUS || token == SLASH ||
token == STRING);
unsigned char *rvp;
do {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NUMBER && token != NUMBER_OR_NAME) {
parse_warn (cfile, "expecting hexadecimal number.");
skip_to_semi (cfile);
}
convert_num (cfile, &ibuf [ilen++], val, 16, 8);
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token != COLON)
break;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
} while (1);
if (!buffer_allocate (&data -> buffer, tlen + ilen, MDL))
struct dns_zone *zone;
isc_result_t status;
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
switch (token) {
case IF:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
return parse_if_statement (result, cfile, lose);
case TOKEN_ADD:
- token = next_token (&val, cfile);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != STRING) {
parse_warn (cfile, "expecting class name.");
skip_to_semi (cfile);
break;
case BREAK:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!parse_semi (cfile)) {
*lose = 1;
return 0;
break;
case SEND:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
known = 0;
option = parse_option_name (cfile, 0, &known);
if (!option) {
case SUPERSEDE:
case OPTION:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
known = 0;
option = parse_option_name (cfile, 0, &known);
if (!option) {
case IGNORE:
flag = 2;
pad:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
cache = (struct option_cache *)0;
if (!parse_allow_deny (&cache, cfile, flag))
return 0;
break;
case DEFAULT:
- token = next_token (&val, cfile);
- token = peek_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == COLON)
goto switch_default;
known = 0;
default_option_statement);
case PREPEND:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
known = 0;
option = parse_option_name (cfile, 0, &known);
if (!option) {
prepend_option_statement);
case APPEND:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
known = 0;
option = parse_option_name (cfile, 0, &known);
if (!option) {
append_option_statement);
case ON:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
return parse_on_statement (result, cfile, lose);
case SWITCH:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
return parse_switch_statement (result, cfile, lose);
case CASE:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (case_context == context_any) {
parse_warn (cfile,
"case statement in inappropriate scope.");
cfile, lose, case_context);
switch_default:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (case_context == context_any) {
parse_warn (cfile, "switch default statement in %s",
"inappropriate scope.");
case DEFINE:
case TOKEN_SET:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token == DEFINE)
flag = 1;
else
flag = 0;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NAME && token != NUMBER_OR_NAME) {
parse_warn (cfile,
"%s can't be a variable name", val);
if (!(*result)->data.set.name)
log_fatal ("can't allocate variable name");
strcpy ((*result) -> data.set.name, val);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token == LPAREN) {
struct string_list *head, *cur, *new;
struct expression *expr;
head = cur = (struct string_list *)0;
do {
- token = next_token (&val, cfile);
+ token = next_token (&val,
+ (unsigned *)0, cfile);
if (token == RPAREN)
break;
if (token != NAME && token != NUMBER_OR_NAME) {
} else {
head = cur = new;
}
- token = next_token (&val, cfile);
+ token = next_token (&val,
+ (unsigned *)0, cfile);
} while (token == COMMA);
if (token != RPAREN) {
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LBRACE) {
parse_warn (cfile, "expecting left brace.");
goto badx;
goto badx;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RBRACE) {
parse_warn (cfile, "expecting rigt brace.");
goto badx;
break;
case UNSET:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NAME && token != NUMBER_OR_NAME) {
parse_warn (cfile,
"%s can't be a variable name", val);
break;
case EVAL:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!executable_statement_allocate (result, MDL))
log_fatal ("no memory for eval statement.");
break;
case RETURN:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!executable_statement_allocate (result, MDL))
log_fatal ("no memory for return statement.");
break;
case LOG:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!executable_statement_allocate (result, MDL))
log_fatal ("no memory for log statement.");
(*result) -> op = log_statement;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LPAREN) {
parse_warn (cfile, "left parenthesis expected.");
skip_to_semi (cfile);
return 0;
}
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
i = 1;
if (token == FATAL) {
(*result) -> data.log.priority = log_priority_fatal;
i = 0;
}
if (i) {
- token = next_token (&val, cfile);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COMMA) {
parse_warn (cfile, "comma expected.");
skip_to_semi (cfile);
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RPAREN) {
parse_warn (cfile, "right parenthesis expected.");
skip_to_semi (cfile);
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != SEMI) {
parse_warn (cfile, "semicolon expected.");
skip_to_semi (cfile);
because it's appropriate for all DHCP agents with
parsers. */
case ZONE:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
zone = (struct dns_zone *)0;
if (!dns_zone_allocate (&zone, MDL))
log_fatal ("no memory for new zone.");
/* Also not really a statement, but same idea as above. */
case KEY:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!parse_key (cfile)) {
*lose = 1;
return 0;
option_hash_lookup (&option, config_universe -> hash,
val, 0, MDL);
if (option) {
- token = next_token (&val, cfile);
+ token = next_token (&val,
+ (unsigned *)0, cfile);
return parse_option_statement
(result, cfile, 1, option,
supersede_option_statement);
struct option_cache *oc;
int done = 0;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LBRACE) {
parse_warn (cfile, "expecting left brace");
return 0;
}
do {
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
switch (token) {
case PRIMARY:
if (zone -> primary) {
log_fatal ("can't allocate secondary.");
oc = zone -> secondary;
consemup:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
do {
struct expression *expr = (struct expression *)0;
if (!parse_ip_addr_or_hostname (&expr, cfile, 0)) {
expr, MDL);
expression_dereference (&expr, MDL);
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
} while (token == COMMA);
if (token != SEMI) {
parse_warn (cfile, "expecting semicolon.");
break;
case KEY:
- token = next_token (&val, cfile);
- token = peek_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == STRING) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
key_name = (char *)0;
} else {
key_name = parse_host_name (cfile);
}
} while (!done);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RBRACE) {
parse_warn (cfile, "expecting right brace.");
return 0;
if (omapi_auth_key_new (&key, MDL) != ISC_R_SUCCESS)
log_fatal ("no memory for key");
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == STRING) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
key -> name = dmalloc (strlen (val) + 1, MDL);
if (!key -> name)
log_fatal ("no memory for key name.");
}
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LBRACE) {
parse_warn (cfile, "expecting left brace");
goto bad;
}
do {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
switch (token) {
case ALGORITHM:
if (key -> algorithm) {
}
/* Allow the BIND 8 syntax, which has a semicolon after each
closing brace. */
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == SEMI)
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
/* Remember the key. */
status = omapi_auth_key_enter (key);
(*result) -> op = on_statement;
do {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
switch (token) {
case EXPIRY:
(*result) -> data.on.evtypes |= ON_EXPIRY;
executable_statement_dereference (result, MDL);
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
} while (token == OR);
/* Semicolon means no statements. */
if (*lose) {
/* Try to even things up. */
do {
- token = next_token (&val, cfile);
+ token = next_token (&val,
+ (unsigned *)0, cfile);
} while (token != END_OF_FILE && token != RBRACE);
executable_statement_dereference (result, MDL);
return 0;
}
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RBRACE) {
parse_warn (cfile, "right brace expected.");
skip_to_semi (cfile);
log_fatal ("no memory for new statement.");
(*result) -> op = switch_statement;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LPAREN) {
parse_warn (cfile, "expecting left brace.");
pfui:
goto gnorf;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RPAREN) {
parse_warn (cfile, "right paren expected.");
goto pfui;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LBRACE) {
parse_warn (cfile, "left brace expected.");
goto pfui;
return 0;
}
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RBRACE) {
parse_warn (cfile, "right brace expected.");
goto pfui;
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COLON) {
parse_warn (cfile, "colon expected.");
goto pfui;
(*result) -> op = if_statement;
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == LPAREN) {
parenp = 1;
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
} else
parenp = 0;
print_expression ("if condition", if_condition);
#endif
if (parenp) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RPAREN) {
parse_warn (cfile, "expecting right paren.");
*lose = 1;
return 0;
}
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LBRACE) {
parse_warn (cfile, "left brace expected.");
skip_to_semi (cfile);
if (*lose) {
/* Try to even things up. */
do {
- token = next_token (&val, cfile);
+ token = next_token (&val,
+ (unsigned *)0, cfile);
} while (token != END_OF_FILE && token != RBRACE);
executable_statement_dereference (result, MDL);
return 0;
}
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RBRACE) {
parse_warn (cfile, "right brace expected.");
skip_to_semi (cfile);
executable_statement_dereference (result, MDL);
return 0;
}
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == ELSE) {
- token = next_token (&val, cfile);
- token = peek_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == IF) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!parse_if_statement (&(*result) -> data.ie.false,
cfile, lose)) {
if (!*lose)
executable_statement_dereference (result, MDL);
return 0;
} else {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!(parse_executable_statements
(&(*result) -> data.ie.false,
cfile, lose, context_any))) {
executable_statement_dereference (result, MDL);
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RBRACE) {
parse_warn (cfile, "right brace expected.");
skip_to_semi (cfile);
}
}
} else if (token == ELSIF) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!parse_if_statement (&(*result) -> data.ie.false,
cfile, lose)) {
if (!*lose)
int i;
unsigned long u;
isc_result_t status, code;
+ unsigned len;
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
/* Check for unary operators... */
switch (token) {
case CHECK:
- token = next_token (&val, cfile);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != STRING) {
parse_warn (cfile, "string expected.");
skip_to_semi (cfile);
break;
case TOKEN_NOT:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (context == context_dns) {
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
goto not_exists;
}
if (!expression_allocate (expr, MDL))
break;
case LPAREN:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!parse_expression (expr, cfile, lose, context,
(struct expression **)0, expr_none)) {
if (!*lose) {
*lose = 1;
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RPAREN) {
*lose = 1;
parse_warn (cfile, "right paren expected");
case EXISTS:
if (context == context_dns)
goto ns_exists;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
(*expr) -> op = expr_exists;
break;
case STATIC:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
(*expr) -> op = expr_static;
break;
case KNOWN:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
(*expr) -> op = expr_known;
break;
case SUBSTRING:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
(*expr) -> op = expr_substring;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LPAREN) {
nolparen:
expression_dereference (expr, MDL);
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COMMA) {
nocomma:
expression_dereference (expr, MDL);
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COMMA)
goto nocomma;
(&(*expr) -> data.substring.len, cfile, lose))
goto nonum;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RPAREN) {
norparen:
parse_warn (cfile, "right parenthesis expected.");
break;
case SUFFIX:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
(*expr) -> op = expr_suffix;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LPAREN)
goto nolparen;
cfile, lose))
goto nodata;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COMMA)
goto nocomma;
cfile, lose))
goto nonum;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RPAREN)
goto norparen;
break;
case CONCAT:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
(*expr) -> op = expr_concat;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LPAREN)
goto nolparen;
cfile, lose))
goto nodata;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COMMA)
goto nocomma;
cfile, lose))
goto nodata;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token == COMMA) {
nexp = (struct expression *)0;
break;
case BINARY_TO_ASCII:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
(*expr) -> op = expr_binary_to_ascii;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LPAREN)
goto nolparen;
cfile, lose))
goto nodata;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COMMA)
goto nocomma;
cfile, lose))
goto nodata;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COMMA)
goto nocomma;
cfile, lose))
goto nodata;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COMMA)
goto nocomma;
cfile, lose))
goto nodata;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RPAREN)
goto norparen;
break;
case REVERSE:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
(*expr) -> op = expr_reverse;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LPAREN)
goto nolparen;
(&(*expr) -> data.reverse.width, cfile, lose)))
goto nodata;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COMMA)
goto nocomma;
(&(*expr) -> data.reverse.buffer, cfile, lose)))
goto nodata;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RPAREN)
goto norparen;
break;
case PICK:
/* pick (a, b, c) actually produces an internal representation
that looks like pick (a, pick (b, pick (c, nil))). */
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!(expression_allocate (expr, MDL)))
log_fatal ("can't allocate expression");
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LPAREN)
goto nolparen;
cfile, lose)))
goto nodata;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token == COMMA) {
if (!(expression_allocate
(&nexp -> data.pick_first_value.cdr,
parse_warn (cfile,
"Please rebuild dhcpd with --with-nsupdate.");
#endif
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token == DNS_UPDATE)
opcode = expr_ns_add;
else
opcode = expr_ns_delete;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LPAREN)
goto nolparen;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != STRING) {
parse_warn (cfile,
"parse_expression: expecting string.");
if (!make_const_int (&(*ep) -> data.arg.val, u))
log_fatal ("can't allocate rrtype value.");
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COMMA)
goto nocomma;
ep = &((*ep) -> data.arg.next);
cfile, lose)))
goto nodata;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COMMA)
goto nocomma;
goto nodata;
if (opcode == expr_ns_add) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COMMA)
goto nocomma;
}
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RPAREN)
goto norparen;
break;
parse_warn (cfile,
"Please rebuild dhcpd with --with-nsupdate.");
#endif
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LPAREN)
goto nolparen;
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token == COMMA) {
if (!(expression_allocate
/* NOT EXISTS is special cased above... */
not_exists:
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token != EXISTS) {
parse_warn (cfile, "expecting DNS prerequisite.");
*lose = 1;
ns_exists:
opcode = expr_ns_exists;
nsupdatecode:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
#if !defined (NSUPDATE)
parse_warn (cfile,
log_fatal ("can't allocate expression");
(*expr) -> op = opcode;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LPAREN)
goto nolparen;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!is_identifier (token) && token != NUMBER) {
parse_warn (cfile, "expecting identifier or number.");
badnsop:
goto badnsop;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COMMA)
goto nocomma;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!is_identifier (token) && token != NUMBER) {
parse_warn (cfile, "expecting identifier or number.");
goto badnsop;
goto badnsop;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COMMA)
goto nocomma;
(&(*expr) -> data.ns_add.rrname, cfile, lose)))
goto nodata;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COMMA)
goto nocomma;
goto nodata;
if (opcode == expr_ns_add) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COMMA)
goto nocomma;
}
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RPAREN)
goto norparen;
break;
(*expr) -> op = (token == OPTION
? expr_option
: expr_config_option);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
known = 0;
(*expr) -> data.option = parse_option_name (cfile, 0, &known);
if (!(*expr) -> data.option) {
break;
case HARDWARE:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
(*expr) -> op = expr_hardware;
break;
case LEASED_ADDRESS:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
(*expr) -> op = expr_leased_address;
break;
case CLIENT_STATE:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
(*expr) -> op = expr_client_state;
break;
case FILENAME:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
(*expr) -> op = expr_filename;
break;
case SERVER_NAME:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
(*expr) -> op = expr_sname;
break;
case LEASE_TIME:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
(*expr) -> op = expr_lease_time;
break;
case TOKEN_NULL:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
(*expr) -> op = expr_null;
break;
case HOST_DECL_NAME:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
(*expr) -> op = expr_host_decl_name;
break;
case UPDATED_DNS_RR:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LPAREN)
goto nolparen;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != STRING) {
parse_warn (cfile, "expecting string.");
bad_rrtype:
goto bad_rrtype;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RPAREN)
goto norparen;
break;
case PACKET:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
(*expr) -> op = expr_packet;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LPAREN)
goto nolparen;
cfile, lose))
goto nonum;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COMMA)
goto nocomma;
cfile, lose))
goto nonum;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RPAREN)
goto norparen;
break;
case STRING:
- token = next_token (&val, cfile);
+ token = next_token (&val, &len, cfile);
if (!make_const_data (expr, (const unsigned char *)val,
- strlen (val), 1, 1))
+ len, 1, 1))
log_fatal ("can't make constant string expression.");
break;
case EXTRACT_INT:
- token = next_token (&val, cfile);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LPAREN) {
parse_warn (cfile, "left parenthesis expected.");
*lose = 1;
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COMMA) {
parse_warn (cfile, "comma expected.");
*lose = 1;
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NUMBER) {
parse_warn (cfile, "number expected.");
*lose = 1;
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RPAREN) {
parse_warn (cfile, "right parenthesis expected.");
*lose = 1;
break;
case ENCODE_INT:
- token = next_token (&val, cfile);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LPAREN) {
parse_warn (cfile, "left parenthesis expected.");
*lose = 1;
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != COMMA) {
parse_warn (cfile, "comma expected.");
*lose = 1;
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NUMBER) {
parse_warn (cfile, "number expected.");
*lose = 1;
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RPAREN) {
parse_warn (cfile, "right parenthesis expected.");
*lose = 1;
number, by itself. */
if (context == context_numeric ||
context == context_data_or_numeric) {
- next_token (&val, cfile); /* Eat the number. */
+ next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
(*expr) -> op = expr_const_int;
known = FORMERR;
goto ns_const;
ns_const:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
(*expr) -> op = expr_const_int;
goto ns_const;
case DEFINED:
- token = next_token (&val, cfile);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LPAREN)
goto nolparen;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NAME && token != NUMBER_OR_NAME) {
parse_warn (cfile, "%s can't be a variable name", val);
skip_to_semi (cfile);
if (!(*expr)->data.variable)
log_fatal ("can't allocate variable name");
strcpy ((*expr) -> data.variable, val);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != RPAREN)
goto norparen;
break;
if (token != NAME && token != NUMBER_OR_NAME)
return 0;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
/* Save the name of the variable being referenced. */
cptr = dmalloc (strlen (val) + 1, MDL);
strcpy (cptr, val);
/* Simple variable reference, as far as we can tell. */
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token != LPAREN) {
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
break;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!expression_allocate (expr, MDL))
log_fatal ("can't allocate expression");
(*expr) -> op = expr_funcall;
return 0;
}
ep = &((*ep) -> data.arg.next);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
} while (token == COMMA);
if (token != RPAREN) {
parse_warn (cfile, "Right parenthesis expected.");
or at least a left-hand-side. If we do not see a binary token
as the next token, we're done with the expression. */
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
switch (token) {
case BANG:
- token = next_token (&val, cfile);
- token = peek_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token != EQUAL) {
parse_warn (cfile, "! in boolean context without =");
*lose = 1;
lhs = rhs;
rhs = (struct expression *)0;
binop = next_op;
- next_token (&val, cfile); /* Consume the operator. */
+ next_token (&val, (unsigned *)0, cfile);
goto new_rhs;
}
}
/* Eat the operator token - we now know it was a binary operator... */
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
/* If the binary operator we saw previously has a lower precedence
than the next operator, then the rhs we just parsed for that
struct executable_statement *stmt;
int ftt = 1;
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == SEMI) {
/* Eat the semicolon... */
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
goto done;
}
if (token == EQUAL) {
/* Eat the equals sign. */
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
/* Parse a data expression and use its value for the data. */
if (!parse_data_expression (&expr, cfile, &lose)) {
expression_dereference (&tmp, MDL);
}
if ((*fmt == 'A') || (*fmt == 'a')) {
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
/* Comma means: continue with next element in array */
if (token == COMMA) {
- token = next_token (&val, cfile);
+ token = next_token (&val,
+ (unsigned *)0, cfile);
continue;
}
/* no comma: end of array.
enum dhcp_token token;
struct expression *t = (struct expression *)0;
unsigned char buf [4];
- int len;
+ unsigned len;
unsigned char *ob;
struct iaddr addr;
int num;
switch (**fmt) {
case 'U':
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (!is_identifier (token)) {
if ((*fmt) [1] != 'o') {
parse_warn (cfile, "expecting identifier.");
}
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, &len, cfile);
if (!make_const_data (&t, (const unsigned char *)val,
- strlen (val), 1, 1))
+ len, 1, 1))
log_fatal ("No memory for %s", val);
break;
}
*fmt = g;
case 'X':
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == NUMBER_OR_NAME || token == NUMBER) {
if (!expression_allocate (&t, MDL))
return 0;
}
t -> op = expr_const_data;
} else if (token == STRING) {
- token = next_token (&val, cfile);
+ token = next_token (&val, &len, cfile);
if (!make_const_data (&t, (const unsigned char *)val,
- strlen (val), 1, 1))
+ len, 1, 1))
log_fatal ("No memory for \"%s\"", val);
} else {
if ((*fmt) [1] != 'o') {
break;
case 't': /* Text string... */
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token != STRING && !is_identifier (token)) {
if ((*fmt) [1] != 'o') {
parse_warn (cfile, "expecting string.");
}
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, &len, cfile);
if (!make_const_data (&t, (const unsigned char *)val,
- strlen (val), 1, 1))
+ len, 1, 1))
log_fatal ("No memory for concatenation");
break;
return 0;
}
*fmt = g;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!is_identifier (token)) {
parse_warn (cfile,
"identifier expected");
break;
case 'T': /* Lease interval. */
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token != INFINITE)
goto check_number;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
putLong (buf, -1);
if (!make_const_data (&t, buf, 4, 0, 1))
return 0;
case 'L': /* Unsigned 32-bit integer... */
case 'l': /* Signed 32-bit integer... */
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
check_number:
if (token != NUMBER) {
need_number:
}
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
convert_num (cfile, buf, val, 0, 32);
if (!make_const_data (&t, buf, 4, 0, 1))
return 0;
case 's': /* Signed 16-bit integer. */
case 'S': /* Unsigned 16-bit integer. */
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token != NUMBER)
goto need_number;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
convert_num (cfile, buf, val, 0, 16);
if (!make_const_data (&t, buf, 2, 0, 1))
return 0;
case 'b': /* Signed 8-bit integer. */
case 'B': /* Unsigned 8-bit integer. */
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token != NUMBER)
goto need_number;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
convert_num (cfile, buf, val, 0, 8);
if (!make_const_data (&t, buf, 1, 0, 1))
return 0;
break;
case 'f': /* Boolean flag. */
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (!is_identifier (token)) {
if ((*fmt) [1] != 'o')
parse_warn (cfile, "expecting identifier.");
parse_warn (cfile, "expecting boolean.");
goto bad_flag;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!make_const_data (&t, buf, 1, 0, 1))
return 0;
break;
break;
case 't': /* Text string... */
- token = next_token (&val, cfile);
+ token = next_token (&val,
+ &len, cfile);
if (token != STRING) {
parse_warn (cfile,
"expecting string.");
skip_to_semi (cfile);
return 0;
}
- len = strlen (val);
if (hunkix + len + 1 > sizeof hunkbuf) {
parse_warn (cfile,
"option data buffer %s",
skip_to_semi (cfile);
return 0;
}
- token = next_token (&val, cfile);
+ token = next_token (&val,
+ (unsigned *)0, cfile);
if (!is_identifier (token)) {
parse_warn (cfile,
"identifier expected");
case 'L': /* Unsigned 32-bit integer... */
case 'l': /* Signed 32-bit integer... */
- token = next_token (&val, cfile);
+ token = next_token (&val,
+ (unsigned *)0, cfile);
if (token != NUMBER) {
need_number:
parse_warn (cfile,
case 's': /* Signed 16-bit integer. */
case 'S': /* Unsigned 16-bit integer. */
- token = next_token (&val, cfile);
+ token = next_token (&val,
+ (unsigned *)0, cfile);
if (token != NUMBER)
goto need_number;
convert_num (cfile, buf, val, 0, 16);
case 'b': /* Signed 8-bit integer. */
case 'B': /* Unsigned 8-bit integer. */
- token = next_token (&val, cfile);
+ token = next_token (&val,
+ (unsigned *)0, cfile);
if (token != NUMBER)
goto need_number;
convert_num (cfile, buf, val, 0, 8);
goto alloc;
case 'f': /* Boolean flag. */
- token = next_token (&val, cfile);
+ token = next_token (&val,
+ (unsigned *)0, cfile);
if (!is_identifier (token)) {
parse_warn (cfile,
"expecting identifier.");
return 0;
}
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
} while (*fmt == 'A' && token == COMMA);
if (token != SEMI) {
unsigned len;
u_int8_t *s;
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == NUMBER_OR_NAME || token == NUMBER) {
len = 0;
do {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NUMBER && token != NUMBER_OR_NAME) {
parse_warn (cfile,
"expecting hexadecimal constant.");
skip_to_semi (cfile);
return 0;
}
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == COLON)
- token = next_token (&val, cfile);
+ token = next_token (&val,
+ (unsigned *)0, cfile);
} while (token == COLON);
val = (char *)buf;
} else if (token == STRING) {
- token = next_token (&val, cfile);
- len = strlen (val);
+ token = next_token (&val, &len, cfile);
if (len + 1 > max) {
parse_warn (cfile, "string constant too long.");
skip_to_semi (cfile);
#ifndef lint
static char copyright[] =
-"$Id: confpars.c,v 1.134 2001/03/01 18:17:07 mellon Exp $ Copyright (c) 1995-2001 The Internet Software Consortium. All rights reserved.\n";
+"$Id: confpars.c,v 1.135 2001/03/17 00:47:39 mellon Exp $ Copyright (c) 1995-2001 The Internet Software Consortium. All rights reserved.\n";
#endif /* not lint */
#include "dhcpd.h"
int status;
do {
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == END_OF_FILE)
break;
declaration = parse_statement (cfile, group, group_type,
(struct host_decl *)0,
declaration);
} while (1);
- token = next_token (&val, cfile); /* Clear the peek buffer */
+ token = next_token (&val, (unsigned *)0, cfile);
status = cfile -> warnings_occurred ? ISC_R_BADPARSE : ISC_R_SUCCESS;
return status;
isc_result_t status;
do {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token == END_OF_FILE)
break;
if (token == LEASE) {
int known;
isc_result_t status;
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
switch (token) {
case INCLUDE:
- next_token (&val, cfile);
- token = next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != STRING) {
parse_warn (cfile, "filename string expected.");
skip_to_semi (cfile);
return 1;
case HOST:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
if (type != HOST_DECL && type != CLASS_DECL)
parse_host_declaration (cfile, group);
else {
return 1;
case GROUP:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
if (type != HOST_DECL && type != CLASS_DECL)
parse_group_declaration (cfile, group);
else {
return 1;
case TIMESTAMP:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
parsed_time = parse_timestamp (cfile);
break;
case SHARED_NETWORK:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
if (type == SHARED_NET_DECL ||
type == HOST_DECL ||
type == SUBNET_DECL ||
return 1;
case SUBNET:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
if (type == HOST_DECL || type == SUBNET_DECL ||
type == CLASS_DECL) {
parse_warn (cfile,
return 1;
case VENDOR_CLASS:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
if (type == CLASS_DECL) {
parse_warn (cfile,
"class declarations not allowed here.");
return 1;
case USER_CLASS:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
if (type == CLASS_DECL) {
parse_warn (cfile,
"class declarations not allowed here.");
return 1;
case CLASS:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
if (type == CLASS_DECL) {
parse_warn (cfile,
"class declarations not allowed here.");
return 1;
case SUBCLASS:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
if (type == CLASS_DECL) {
parse_warn (cfile,
"class declarations not allowed here.");
return 1;
case HARDWARE:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
memset (&hardware, 0, sizeof hardware);
parse_hardware_param (cfile, &hardware);
if (host_decl)
break;
case FIXED_ADDR:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
cache = (struct option_cache *)0;
if (parse_fixed_addr_param (&cache, cfile)) {
if (host_decl)
break;
case POOL:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
if (type != SUBNET_DECL && type != SHARED_NET_DECL) {
parse_warn (cfile, "pool declared outside of network");
}
return declaration;
case RANGE:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
if (type != SUBNET_DECL || !group -> subnet) {
parse_warn (cfile,
"range declaration not allowed here.");
return declaration;
case TOKEN_NOT:
- token = next_token (&val, cfile);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
switch (token) {
case AUTHORITATIVE:
group -> authoritative = 0;
}
break;
case AUTHORITATIVE:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
group -> authoritative = 1;
authoritative:
if (type == HOST_DECL)
"option dhcp-server-identifier". */
case SERVER_IDENTIFIER:
option = dhcp_universe.options [DHO_DHCP_SERVER_IDENTIFIER];
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
goto finish_option;
case OPTION:
- token = next_token (&val, cfile);
- token = peek_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == SPACE) {
if (type != ROOT_GROUP) {
parse_warn (cfile,
known = 0;
option = parse_option_name (cfile, 1, &known);
if (option) {
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == CODE) {
if (type != ROOT_GROUP) {
parse_warn (cfile,
free_option (option, MDL);
break;
}
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
if (!parse_option_code_definition (cfile,
option))
free_option (option, MDL);
skip_to_semi (cfile);
break;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
#if defined (FAILOVER_PROTOCOL)
parse_failover_peer (cfile, group, type);
#else
isc_result_t status;
dhcp_failover_config_t *cp;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != PEER) {
parse_warn (cfile, "expecting \"peer\"");
skip_to_semi (cfile);
return;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (is_identifier (token) || token == STRING) {
name = dmalloc (strlen (val) + 1, MDL);
if (!name)
peer = (dhcp_failover_state_t *)0;
find_failover_peer (&peer, name, MDL);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token == SEMI) {
dfree (name, MDL);
if (type != SHARED_NET_DECL)
do {
cp = &peer -> me;
peer:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
switch (token) {
case RBRACE:
break;
break;
case PORT:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NUMBER) {
parse_warn (cfile, "expecting number");
skip_to_rbrace (cfile, 1);
case MAX_RESPONSE_DELAY:
tp = &cp -> max_response_delay;
parse_idle:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NUMBER) {
parse_warn (cfile, "expecting number.");
skip_to_rbrace (cfile, 1);
break;
case SPLIT:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (peer -> i_am == secondary)
parse_warn (cfile,
"secondary may not define %s",
break;
case LOAD:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != BALANCE) {
parse_warn (cfile, "expecting 'balance'");
badload:
skip_to_rbrace (cfile, 1);
break;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != TOKEN_MAX) {
parse_warn (cfile, "expecting 'max'");
goto badload;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != SECONDS) {
parse_warn (cfile, "expecting 'secs'");
goto badload;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NUMBER) {
parse_warn (cfile, "expecting number");
goto badload;
dhcp_failover_config_t *cp;
if (!peer) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != PEER) {
parse_warn (cfile, "expecting \"peer\"");
skip_to_semi (cfile);
return;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (is_identifier (token) || token == STRING) {
name = dmalloc (strlen (val) + 1, MDL);
if (!name)
return;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != STATE) {
parse_warn (cfile, "expecting 'state'");
if (token != SEMI)
state = (dhcp_failover_state_t *)0;
dhcp_failover_state_reference (&state, peer, MDL);
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LBRACE) {
parse_warn (cfile, "expecting left brace");
if (token != SEMI)
return;
}
do {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
switch (token) {
case RBRACE:
break;
case MY:
cp = &state -> me;
do_state:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != STATE) {
parse_warn (cfile, "expecting 'state'");
goto bogus;
enum failover_state state_in;
TIME stos_in;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
switch (token) {
case UNKNOWN_STATE:
state_in = unknown_state;
return;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != AT) {
parse_warn (cfile, "expecting \"at\"");
skip_to_semi (cfile);
}
do {
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
switch (token) {
case NO:
- next_token (&val, cfile);
- token = next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != FAILOVER ||
- (token = next_token (&val, cfile)) != PEER) {
+ (token = next_token (&val, (unsigned *)0,
+ cfile)) != PEER) {
parse_warn (cfile,
"expecting \"failover peer\".");
skip_to_semi (cfile);
#if defined (FAILOVER_PROTOCOL)
case FAILOVER:
- next_token (&val, cfile);
- token = next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != PEER) {
parse_warn (cfile, "expecting 'peer'.");
skip_to_semi (cfile);
break;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != STRING) {
parse_warn (cfile, "expecting string.");
skip_to_semi (cfile);
#endif
case RANGE:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
parse_address_range (cfile, group, type, pool);
break;
case ALLOW:
permit = new_permit (MDL);
if (!permit)
log_fatal ("no memory for permit");
- next_token (&val, cfile);
- token = next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
switch (token) {
case UNKNOWN:
permit -> type = permit_unknown_clients;
get_clients:
- if (next_token (&val, cfile) != CLIENTS) {
+ if (next_token (&val, (unsigned *)0,
+ cfile) != CLIENTS) {
parse_warn (cfile,
"expecting \"clients\"");
skip_to_semi (cfile);
case DYNAMIC:
permit -> type = permit_dynamic_bootp_clients;
- if (next_token (&val, cfile) != TOKEN_BOOTP) {
+ if (next_token (&val, (unsigned *)0,
+ cfile) != TOKEN_BOOTP) {
parse_warn (cfile,
"expecting \"bootp\"");
skip_to_semi (cfile);
goto get_clients;
case MEMBERS:
- if (next_token (&val, cfile) != OF) {
+ if (next_token (&val, (unsigned *)0,
+ cfile) != OF) {
parse_warn (cfile, "expecting \"of\"");
skip_to_semi (cfile);
free_permit (permit, MDL);
continue;
}
- if (next_token (&val, cfile) != STRING) {
+ if (next_token (&val, (unsigned *)0,
+ cfile) != STRING) {
parse_warn (cfile,
"expecting class name.");
skip_to_semi (cfile);
goto get_permit;
case RBRACE:
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
done = 1;
break;
const char *val;
int rv;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!strcasecmp (val, "true")
|| !strcasecmp (val, "on"))
rv = 1;
enum dhcp_token token;
const char *val;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LBRACE) {
parse_warn (cfile, "expecting left brace.");
skip_to_semi (cfile);
goto boom;
do {
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == RBRACE) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
break;
}
if (token == END_OF_FILE) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
parse_warn (cfile, "unexpected end of file");
break;
}
remember to save it. */
if (token == DYNAMIC) {
dynamicp = 1;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!parse_semi (cfile))
break;
continue;
remember to save it. */
if (token == TOKEN_DELETED) {
deleted = 1;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!parse_semi (cfile))
break;
continue;
if (token == GROUP) {
struct group_object *go;
- token = next_token (&val, cfile);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != STRING && !is_identifier (token)) {
parse_warn (cfile,
"expecting string or identifier.");
unsigned char *t = 0;
unsigned len;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
data_string_forget (&host -> client_identifier, MDL);
/* See if it's a string or a cshl. */
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == STRING) {
- token = next_token (&val, cfile);
+ token = next_token (&val, &len, cfile);
s = val;
- len = strlen (val);
host -> client_identifier.terminated = 1;
} else {
len = 0;
int new = 1;
isc_result_t status;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != STRING) {
parse_warn (cfile, "Expecting class name");
skip_to_semi (cfile);
/* If this is a straight subclass, parse the hash string. */
if (type == 3) {
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == STRING) {
- token = next_token (&val, cfile);
- data.len = strlen (val);
+ token = next_token (&val, &data.len, cfile);
data.buffer = (struct buffer *)0;
if (!buffer_allocate (&data.buffer,
data.len + 1, MDL)) {
}
data.terminated = 1;
data.data = &data.buffer -> data [0];
- strcpy ((char *)data.buffer -> data, val);
+ memcpy ((char *)data.buffer -> data, val,
+ data.len + 1);
} else if (token == NUMBER_OR_NAME || token == NUMBER) {
memset (&data, 0, sizeof data);
if (!parse_cshl (&data, cfile)) {
/* Spawned classes don't have to have their own settings. */
if (class -> superclass) {
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == SEMI) {
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
if (cp)
status = class_reference (cp, class, MDL);
class_dereference (&class, MDL);
}
do {
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == RBRACE) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
break;
} else if (token == END_OF_FILE) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
parse_warn (cfile, "unexpected end of file");
break;
} else if (token == MATCH) {
skip_to_semi (cfile);
break;
}
- token = next_token (&val, cfile);
- token = peek_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token != IF)
goto submatch;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!parse_boolean_expression (&class -> expr, cfile,
&lose)) {
if (!lose) {
skip_to_semi (cfile);
break;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
class -> spawning = 1;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != WITH) {
parse_warn (cfile,
"expecting with after spawn");
parse_semi (cfile);
}
} else if (token == LEASE) {
- next_token (&val, cfile);
- token = next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != LIMIT) {
parse_warn (cfile, "expecting \"limit\"");
if (token != SEMI)
skip_to_semi (cfile);
break;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NUMBER) {
parse_warn (cfile, "expecting a number");
if (token != SEMI)
share, MDL);
/* Get the name of the shared network... */
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == STRING) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (val [0] == 0) {
parse_warn (cfile, "zero-length shared network name");
}
do {
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == RBRACE) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!share -> subnets)
parse_warn (cfile,
"empty shared-network decl");
shared_network_dereference (&share, MDL);
return;
} else if (token == END_OF_FILE) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
parse_warn (cfile, "unexpected end of file");
break;
} else if (token == INTERFACE) {
- token = next_token (&val, cfile);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
new_shared_network_interface (cfile, share, val);
if (!parse_semi (cfile))
break;
iaddr.len = len;
subnet -> net = iaddr;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NETMASK) {
parse_warn (cfile, "Expecting netmask");
skip_to_semi (cfile);
}
do {
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == RBRACE) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
break;
} else if (token == END_OF_FILE) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
parse_warn (cfile, "unexpected end of file");
break;
} else if (token == INTERFACE) {
- token = next_token (&val, cfile);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
new_shared_network_interface (cfile, share, val);
if (!parse_semi (cfile))
break;
if (!clone_group (&g, group, MDL))
log_fatal ("no memory for explicit group.");
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (is_identifier (token) || token == STRING) {
- next_token (&val, cfile);
+ next_token (&val, (unsigned *)0, cfile);
name = dmalloc (strlen (val) + 1, MDL);
if (!name)
}
do {
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == RBRACE) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
break;
} else if (token == END_OF_FILE) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
parse_warn (cfile, "unexpected end of file");
break;
} else if (token == TOKEN_DELETED) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
parse_semi (cfile);
deletedp = 1;
} else if (token == DYNAMIC) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
parse_semi (cfile);
dynamicp = 1;
} else if (token == STATIC) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
parse_semi (cfile);
staticp = 1;
}
expression_dereference (&expr, MDL);
return 0;
}
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == COMMA)
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
} while (token == COMMA);
if (!parse_semi (cfile)) {
struct option_cache *oc;
pair *p;
binding_state_t new_state;
+ unsigned buflen = 0;
lease = (struct lease *)0;
status = lease_allocate (&lease, MDL);
}
do {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token == RBRACE)
break;
else if (token == END_OF_FILE) {
/* Colon-seperated hexadecimal octets... */
case UID:
seenbit = 8;
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == STRING) {
unsigned char *tuid;
- token = next_token (&val, cfile);
- lease -> uid_len = strlen (val);
- tuid = ((unsigned char *)
- dmalloc (lease -> uid_len, MDL));
- if (!tuid) {
- log_error ("no space for uid");
- lease_dereference (&lease, MDL);
- return 0;
+ token = next_token (&val, &buflen, cfile);
+ lease -> uid_len = buflen;
+ if (buflen < sizeof lease -> uid_buf)
+ tuid = lease -> uid_buf;
+ else {
+ tuid = ((unsigned char *)
+ dmalloc (buflen, MDL));
+ if (!tuid) {
+ log_error ("no space for uid");
+ lease_dereference (&lease,
+ MDL);
+ return 0;
+ }
}
memcpy (tuid, val, lease -> uid_len);
lease -> uid = tuid;
} else {
- unsigned uid_len = 0;
+ buflen = 0;
lease -> uid = (parse_numeric_aggregate
(cfile, (unsigned char *)0,
- &uid_len, ':', 16, 8));
- lease -> uid_len = uid_len;
+ &buflen, ':', 16, 8));
+ lease -> uid_len = buflen;
if (!lease -> uid) {
lease_dereference (&lease, MDL);
return 0;
case CLASS:
seenbit = 32;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (!is_identifier (token)) {
if (token != SEMI)
skip_to_rbrace (cfile, 1);
case TOKEN_NEXT:
seenbit = 128;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != BINDING) {
parse_warn (cfile, "expecting 'binding'");
skip_to_semi (cfile);
seenbit = 256;
do_binding_state:
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != STATE) {
parse_warn (cfile, "expecting 'state'");
skip_to_semi (cfile);
break;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
switch (token) {
case TOKEN_ABANDONED:
new_state = FTS_ABANDONED;
case CLIENT_HOSTNAME:
seenbit = 1024;
- token = peek_token (&val, cfile);
- if (token == STRING)
- lease -> client_hostname =
- parse_string (cfile);
- else {
+ token = peek_token (&val, (unsigned *)0, cfile);
+ if (token == STRING) {
+ if (!parse_string (cfile,
+ &lease -> client_hostname,
+ (unsigned *)0)) {
+ lease_dereference (&lease, MDL);
+ return 0;
+ }
+ } else {
lease -> client_hostname =
parse_host_name (cfile);
if (lease -> client_hostname)
parse_semi (cfile);
- }
- if (!lease -> client_hostname) {
- parse_warn (cfile, "expecting a hostname.");
- skip_to_semi (cfile);
- seenbit = 0;
- lease_dereference (&lease, MDL);
- return 0;
+ else {
+ parse_warn (cfile,
+ "expecting a hostname.");
+ skip_to_semi (cfile);
+ lease_dereference (&lease, MDL);
+ return 0;
+ }
}
break;
case BILLING:
seenbit = 2048;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token == CLASS) {
- token = next_token (&val, cfile);
+ token = next_token (&val,
+ (unsigned *)0, cfile);
if (token != STRING) {
parse_warn (cfile, "expecting string");
if (token != SEMI)
case TOKEN_SET:
noequal = 0;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NAME && token != NUMBER_OR_NAME) {
parse_warn (cfile,
"%s can't be a variable name",
log_fatal ("no memory for binding value.");
if (!noequal) {
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != EQUAL) {
parse_warn (cfile,
"expecting '=' in set statement.");
}
}
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == STRING) {
unsigned char *tuid;
- token = next_token (&val, cfile);
+ token = next_token (&val, &buflen, cfile);
binding -> value -> type = binding_data;
- binding -> value -> value.data.len = strlen (val);
+ binding -> value -> value.data.len = buflen;
if (!(buffer_allocate
(&binding -> value -> value.data.buffer,
- binding -> value-> value.data.len + 1,
- MDL)))
+ buflen + 1, MDL)))
log_fatal ("No memory for binding.");
- strcpy ((char *)
+ memcpy ((char *)
(binding -> value ->
- value.data.buffer -> data), val);
+ value.data.buffer -> data),
+ val, buflen + 1);
binding -> value -> value.data.data =
binding -> value -> value.data.buffer -> data;
binding -> value -> value.data.terminated = 1;
binding -> value -> value.data.buffer -> data;
}
} else if (token == PERCENT) {
- token = next_token (&val, cfile);
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != NUMBER) {
parse_warn (cfile,
"expecting decimal number.");
binding -> value -> type = binding_numeric;
binding -> value -> value.intval = atol (val);
} else if (token == NAME) {
- token = next_token (&val, cfile);
+ token = next_token (&val,
+ (unsigned *)0, cfile);
binding -> value -> type = binding_boolean;
if (!strcasecmp (val, "true"))
binding -> value -> value.boolean = 1;
struct pool *pool;
isc_result_t status;
- if ((token = peek_token (&val, cfile)) == DYNAMIC_BOOTP) {
- token = next_token (&val, cfile);
+ if ((token = peek_token (&val,
+ (unsigned *)0, cfile)) == DYNAMIC_BOOTP) {
+ token = next_token (&val, (unsigned *)0, cfile);
dynamic = 1;
}
low.len = len;
/* Only one address? */
- token = peek_token (&val, cfile);
+ token = peek_token (&val, (unsigned *)0, cfile);
if (token == SEMI)
high = low;
else {
high.len = len;
}
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
if (token != SEMI) {
parse_warn (cfile, "semicolon expected.");
skip_to_semi (cfile);
if (!make_const_data (&data, &rf, 1, 0, 1))
return 0;
- token = next_token (&val, cfile);
+ token = next_token (&val, (unsigned *)0, cfile);
switch (token) {
case TOKEN_BOOTP:
status = option_cache (oc, (struct data_string *)0, data,
projects / thirdparty / dhcp.git / commitdiff
