From: Ted Lemon Date: Sat, 31 Jul 1999 18:03:55 +0000 (+0000) Subject: - Regularize expression evaluation calls so that they are all passed a pointer X-Git-Tag: V3-BETA-1-PATCH-2~5^2~158 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=4038ec529e4d19042cd35dc65e04c93584a9bd89;p=thirdparty%2Fdhcp.git - Regularize expression evaluation calls so that they are all passed a pointer to the incoming packet, if any, the current lease, if any, the parsed incoming options, and the in-scope configuration file options. - Incoming packets are now reference counted, so that the callee can save them for later expression evaluation (e.g., in dhcp_reply). --- diff --git a/common/options.c b/common/options.c index c3311c7d4..3276ff8a8 100644 --- a/common/options.c +++ b/common/options.c @@ -22,7 +22,7 @@ #ifndef lint static char copyright[] = -"$Id: options.c,v 1.44 1999/07/06 16:53:30 mellon Exp $ Copyright (c) 1995, 1996 The Internet Software Consortium. All rights reserved.\n"; +"$Id: options.c,v 1.45 1999/07/31 18:03:54 mellon Exp $ Copyright (c) 1995, 1996 The Internet Software Consortium. All rights reserved.\n"; #endif /* not lint */ #define DHCP_OPTION_DATA @@ -233,13 +233,14 @@ int parse_agent_information_option (packet, len, data) three seperate buffers if needed. This allows us to cons up a set of vendor options using the same routine. */ -int cons_options (inpacket, outpacket, lease, - mms, options, overload, terminate, bootpp, prl) +int cons_options (inpacket, outpacket, lease, mms, in_options, cfg_options, + overload, terminate, bootpp, prl) struct packet *inpacket; struct dhcp_packet *outpacket; struct lease *lease; int mms; - struct option_state *options; + struct option_state *in_options; + struct option_state *cfg_options; int overload; /* Overload flags that may be set. */ int terminate; int bootpp; @@ -267,8 +268,8 @@ int cons_options (inpacket, outpacket, lease, if (!mms && inpacket && (op = lookup_option (&dhcp_universe, inpacket -> options, DHO_DHCP_MAX_MESSAGE_SIZE))) { - evaluate_option_cache (&ds, inpacket, - inpacket -> options, lease, op); + evaluate_option_cache (&ds, inpacket, lease, + in_options, cfg_options, op); if (ds.len >= sizeof (u_int16_t)) mms = getUShort (ds.data); data_string_forget (&ds, "cons_options"); @@ -329,13 +330,13 @@ int cons_options (inpacket, outpacket, lease, space, and the first for loop is skipped, because it's slightly more general to do it this way, taking the 1Q99 DHCP futures work into account. */ - if (options -> site_code_min) { + if (cfg_options -> site_code_min) { for (i = 0; i < OPTION_HASH_SIZE; i++) { - hash = options -> universes [dhcp_universe.index]; + hash = cfg_options -> universes [dhcp_universe.index]; for (pp = hash [i]; pp; pp = pp -> cdr) { op = (struct option_cache *)(pp -> car); if (op -> option -> code < - options -> site_code_min && + cfg_options -> site_code_min && priority_len < PRIORITY_COUNT) priority_list [priority_len++] = op -> option -> code; @@ -347,11 +348,12 @@ int cons_options (inpacket, outpacket, lease, is no site option space, we'll be cycling through the dhcp option space. */ for (i = 0; i < OPTION_HASH_SIZE; i++) { - hash = options -> universes [options -> site_universe]; + hash = (cfg_options -> universes + [cfg_options -> site_universe]); for (pp = hash [i]; pp; pp = pp -> cdr) { op = (struct option_cache *)(pp -> car); if (op -> option -> code >= - options -> site_code_min && + cfg_options -> site_code_min && priority_len < PRIORITY_COUNT) priority_list [priority_len++] = op -> option -> code; @@ -364,8 +366,9 @@ int cons_options (inpacket, outpacket, lease, (main_buffer_size - 7 + ((overload & 1) ? DHCP_FILE_LEN : 0) + ((overload & 2) ? DHCP_SNAME_LEN : 0)), + inpacket, lease, - options, + in_options, cfg_options, priority_list, priority_len, main_buffer_size, (main_buffer_size + @@ -437,8 +440,8 @@ int cons_options (inpacket, outpacket, lease, /* We tack any agent options onto the end of the packet after we've put it together. */ - if (options -> universe_count > agent_universe.index && - options -> universes [agent_universe.index]) { + if (cfg_options -> universe_count > agent_universe.index && + cfg_options -> universes [agent_universe.index]) { int len = 0; struct agent_options *a; struct option_tag *o; @@ -446,7 +449,7 @@ int cons_options (inpacket, outpacket, lease, /* Cycle through the options, appending them to the buffer. */ for (a = ((struct agent_options *) - options -> universes [agent_universe.index]); + cfg_options -> universes [agent_universe.index]); a; a = a -> next) { if (agentix + a -> length + 3 + DHCP_FIXED_LEN <= dhcp_max_agent_option_packet_length) { @@ -474,12 +477,15 @@ int cons_options (inpacket, outpacket, lease, /* Store all the requested options into the requested buffer. */ -int store_options (buffer, buflen, lease, options, priority_list, priority_len, - first_cutoff, second_cutoff, terminate) +int store_options (buffer, buflen, packet, lease, + in_options, cfg_options, priority_list, + priority_len, first_cutoff, second_cutoff, terminate) unsigned char *buffer; int buflen; + struct packet *packet; struct lease *lease; - struct option_state *options; + struct option_state *in_options; + struct option_state *cfg_options; int *priority_list; int priority_len; int first_cutoff, second_cutoff; @@ -524,12 +530,12 @@ int store_options (buffer, buflen, lease, options, priority_list, priority_len, /* Look up the option in the site option space if the code is above the cutoff, otherwise in the DHCP option space. */ - if (code >= options -> site_code_min) + if (code >= cfg_options -> site_code_min) oc = lookup_option - (universes [options -> site_universe], - options, code); + (universes [cfg_options -> site_universe], + cfg_options, code); else - oc = lookup_option (&dhcp_universe, options, code); + oc = lookup_option (&dhcp_universe, cfg_options, code); /* If no data is available for this option, skip it. */ if (!oc) { @@ -537,8 +543,8 @@ int store_options (buffer, buflen, lease, options, priority_list, priority_len, } /* Find the value of the option... */ - evaluate_option_cache (&od, (struct packet *)0, - options, lease, oc); + evaluate_option_cache (&od, packet, lease, + in_options, cfg_options, oc); if (!od.len) { continue; } @@ -784,63 +790,14 @@ char *pretty_print_option (code, data, len, emit_commas, emit_quotes) return optbuf; } -void do_packet (interface, packet, len, from_port, from, hfrom) - struct interface_info *interface; - struct dhcp_packet *packet; - int len; - unsigned int from_port; - struct iaddr from; - struct hardware *hfrom; -{ - struct packet tp; - int i; - struct option_cache *op; - - memset (&tp, 0, sizeof tp); - tp.raw = packet; - tp.packet_length = len; - tp.client_port = from_port; - tp.client_addr = from; - tp.interface = interface; - tp.haddr = hfrom; - - if (packet -> hlen > sizeof packet -> chaddr) { - log_info ("Discarding packet with bogus hlen."); - return; - } - if (!parse_options (&tp)) { - if (tp.options) - option_state_dereference (&tp.options, "do_packet"); - return; - } - - if (tp.options_valid && - (op = lookup_option (&dhcp_universe, tp.options, - DHO_DHCP_MESSAGE_TYPE))) { - struct data_string dp; - memset (&dp, 0, sizeof dp); - evaluate_option_cache (&dp, &tp, tp.options, - (struct lease *)0, op); - if (dp.len > 0) - tp.packet_type = dp.data [0]; - else - tp.packet_type = 0; - data_string_forget (&dp, "do_packet"); - } - - if (tp.packet_type) - dhcp (&tp); - else - bootp (&tp); - - option_state_dereference (&tp.options, "do_packet"); -} - -int hashed_option_get (result, universe, packet, lease, options, code) +int hashed_option_get (result, universe, packet, lease, + in_options, cfg_options, options, code) struct data_string *result; struct universe *universe; struct packet *packet; struct lease *lease; + struct option_state *in_options; + struct option_state *cfg_options; struct option_state *options; int code; { @@ -851,17 +808,20 @@ int hashed_option_get (result, universe, packet, lease, options, code) oc = ((*universe -> lookup_func) (universe, options, code)); if (!oc) return 0; - if (!evaluate_option_cache (result, packet, - options, lease, oc)) + if (!evaluate_option_cache (result, packet, lease, + in_options, cfg_options, oc)) return 0; return 1; } -int agent_option_get (result, universe, packet, lease, options, code) +int agent_option_get (result, universe, packet, lease, + in_options, cfg_options, options, code) struct data_string *result; struct universe *universe; struct packet *packet; struct lease *lease; + struct option_state *in_options; + struct option_state *cfg_options; struct option_state *options; int code; { @@ -1224,10 +1184,13 @@ int agent_option_state_dereference (universe, state) return 1; } -int store_option (result, universe, lease, oc) +int store_option (result, universe, packet, lease, in_options, cfg_options, oc) struct data_string *result; struct universe *universe; + struct packet *packet; struct lease *lease; + struct option_state *in_options; + struct option_state *cfg_options; struct option_cache *oc; { struct data_string d1, d2; @@ -1235,8 +1198,8 @@ int store_option (result, universe, lease, oc) memset (&d1, 0, sizeof d1); memset (&d2, 0, sizeof d2); - if (evaluate_option_cache (&d2, (struct packet *)0, - (struct option_state *)0, lease, oc)) { + if (evaluate_option_cache (&d2, packet, lease, + in_options, cfg_options, oc)) { if (!buffer_allocate (&d1.buffer, (result -> len + universe -> length_size + @@ -1266,10 +1229,13 @@ int store_option (result, universe, lease, oc) return 0; } -int option_space_encapsulate (result, options, lease, name) +int option_space_encapsulate (result, packet, lease, + in_options, cfg_options, name) struct data_string *result; - struct option_state *options; + struct packet *packet; struct lease *lease; + struct option_state *in_options; + struct option_state *cfg_options; struct data_string *name; { struct universe *u; @@ -1282,33 +1248,38 @@ int option_space_encapsulate (result, options, lease, name) } if (u -> encapsulate) - return (*u -> encapsulate) (result, options, lease, u); + return (*u -> encapsulate) (result, packet, lease, + in_options, cfg_options, u); log_error ("encapsulation requested for %s with no support.", name -> data); return 0; } -int hashed_option_space_encapsulate (result, options, lease, universe) +int hashed_option_space_encapsulate (result, packet, lease, + in_options, cfg_options, universe) struct data_string *result; - struct option_state *options; + struct packet *packet; struct lease *lease; + struct option_state *in_options; + struct option_state *cfg_options; struct universe *universe; { pair p, *hash; int status; int i; - if (universe -> index >= options -> universe_count) + if (universe -> index >= cfg_options -> universe_count) return 0; - hash = options -> universes [universe -> index]; + hash = cfg_options -> universes [universe -> index]; if (!hash) return 0; status = 0; for (i = 0; i < OPTION_HASH_SIZE; i++) { for (p = hash [i]; p; p = p -> cdr) { - if (store_option (result, universe, lease, + if (store_option (result, universe, packet, lease, + in_options, cfg_options, (struct option_cache *)p -> car)) status = 1; } @@ -1316,3 +1287,65 @@ int hashed_option_space_encapsulate (result, options, lease, universe) return status; } + +void do_packet (interface, packet, len, from_port, from, hfrom) + struct interface_info *interface; + struct dhcp_packet *packet; + int len; + unsigned int from_port; + struct iaddr from; + struct hardware *hfrom; +{ + int i; + struct option_cache *op; + struct packet *decoded_packet; + + decoded_packet = (struct packet *)0; + if (!packet_allocate (&decoded_packet, "do_packet")) { + log_error ("do_packet: no memory for incoming packet!"); + return; + } + decoded_packet -> raw = packet; + decoded_packet -> packet_length = len; + decoded_packet -> client_port = from_port; + decoded_packet -> client_addr = from; + decoded_packet -> interface = interface; + decoded_packet -> haddr = hfrom; + + if (packet -> hlen > sizeof packet -> chaddr) { + packet_dereference (&decoded_packet, "do_packet"); + log_info ("Discarding packet with bogus hlen."); + return; + } + if (!parse_options (decoded_packet)) { + if (decoded_packet -> options) + option_state_dereference (&decoded_packet -> options, + "do_packet"); + packet_dereference (&decoded_packet, "do_packet"); + return; + } + + if (decoded_packet -> options_valid && + (op = lookup_option (&dhcp_universe, decoded_packet -> options, + DHO_DHCP_MESSAGE_TYPE))) { + struct data_string dp; + memset (&dp, 0, sizeof dp); + evaluate_option_cache (&dp, decoded_packet, (struct lease *)0, + decoded_packet -> options, + (struct option_state *)0, op); + if (dp.len > 0) + decoded_packet -> packet_type = dp.data [0]; + else + decoded_packet -> packet_type = 0; + data_string_forget (&dp, "do_packet"); + } + + if (decoded_packet -> packet_type) + dhcp (decoded_packet); + else + bootp (decoded_packet); + + /* If the caller kept the packet, they'll have upped the refcnt. */ + packet_dereference (&decoded_packet, "do_packet"); +} + diff --git a/common/tree.c b/common/tree.c index 2406524dc..99f260e7a 100644 --- a/common/tree.c +++ b/common/tree.c @@ -22,7 +22,7 @@ #ifndef lint static char copyright[] = -"$Id: tree.c,v 1.42 1999/07/21 20:58:17 mellon Exp $ Copyright (c) 1995, 1996, 1997, 1998 The Internet Software Consortium. All rights reserved.\n"; +"$Id: tree.c,v 1.43 1999/07/31 18:03:55 mellon Exp $ Copyright (c) 1995, 1996, 1997, 1998 The Internet Software Consortium. All rights reserved.\n"; #endif /* not lint */ #include "dhcpd.h" @@ -378,11 +378,13 @@ static int do_host_lookup (result, dns) return 1; } -int evaluate_boolean_expression (result, packet, options, lease, expr) +int evaluate_boolean_expression (result, packet, lease, in_options, + cfg_options, expr) int *result; struct packet *packet; - struct option_state *options; struct lease *lease; + struct option_state *in_options; + struct option_state *cfg_options; struct expression *expr; { struct data_string left, right; @@ -404,12 +406,12 @@ int evaluate_boolean_expression (result, packet, options, lease, expr) case expr_equal: memset (&left, 0, sizeof left); - sleft = evaluate_data_expression (&left, packet, options, - lease, + sleft = evaluate_data_expression (&left, packet, lease, + in_options, cfg_options, expr -> data.equal [0]); memset (&right, 0, sizeof right); - sright = evaluate_data_expression (&right, packet, options, - lease, + sright = evaluate_data_expression (&right, packet, lease, + in_options, cfg_options, expr -> data.equal [1]); if (sleft && sright) { if (left.len == right.len && @@ -437,11 +439,11 @@ int evaluate_boolean_expression (result, packet, options, lease, expr) return sleft && sright; case expr_and: - sleft = evaluate_boolean_expression (&bleft, packet, options, - lease, + sleft = evaluate_boolean_expression (&bleft, packet, lease, + in_options, cfg_options, expr -> data.and [0]); - sright = evaluate_boolean_expression (&bright, packet, options, - lease, + sright = evaluate_boolean_expression (&bright, packet, lease, + in_options, cfg_options, expr -> data.and [1]); #if defined (DEBUG_EXPRESSIONS) @@ -458,11 +460,11 @@ int evaluate_boolean_expression (result, packet, options, lease, expr) return 0; case expr_or: - sleft = evaluate_boolean_expression (&bleft, packet, options, - lease, + sleft = evaluate_boolean_expression (&bleft, packet, lease, + in_options, cfg_options, expr -> data.or [0]); - sright = evaluate_boolean_expression (&bright, packet, options, - lease, + sright = evaluate_boolean_expression (&bright, packet, lease, + in_options, cfg_options, expr -> data.or [1]); #if defined (DEBUG_EXPRESSIONS) log_debug ("bool: or (%s, %s) = %s", @@ -478,8 +480,8 @@ int evaluate_boolean_expression (result, packet, options, lease, expr) return 0; case expr_not: - sleft = evaluate_boolean_expression (&bleft, packet, options, - lease, + sleft = evaluate_boolean_expression (&bleft, packet, lease, + in_options, cfg_options, expr -> data.not); #if defined (DEBUG_EXPRESSIONS) log_debug ("bool: not (%s) = %s", @@ -496,10 +498,11 @@ int evaluate_boolean_expression (result, packet, options, lease, expr) case expr_exists: memset (&left, 0, sizeof left); - if (!options || + if (!in_options || !((*expr -> data.option -> universe -> get_func) (&left, expr -> data.exists -> universe, - packet, lease, options, expr -> data.exists -> code))) + packet, lease, in_options, cfg_options, in_options, + expr -> data.exists -> code))) *result = 0; else { *result = 1; @@ -535,15 +538,19 @@ int evaluate_boolean_expression (result, packet, options, lease, expr) if (packet -> packet_type != DHCPREQUEST) return 0; memset (&rrtype, 0, sizeof expr1); - s0 = evaluate_data_expression (&rrtype, packet, options, lease, + s0 = evaluate_data_expression (&rrtype, packet, lease, + in_options, cfg_options, expr -> data.dns_update.type); memset (&expr1, 0, sizeof expr1); - s1 = evaluate_data_expression (&expr1, packet, options, lease, + s1 = evaluate_data_expression (&expr1, packet, lease, + in_options, cfg_options, expr -> data.dns_update.expr1); memset (&expr2, 0, sizeof expr2); - s2 = evaluate_data_expression (&expr2, packet, options, lease, + s2 = evaluate_data_expression (&expr2, packet, lease, + in_options, cfg_options, expr -> data.dns_update.expr2); - s3 = evaluate_numeric_expression (&ttl, packet, options, lease, + s3 = evaluate_numeric_expression (&ttl, packet, lease, + in_options, cfg_options, expr -> data.dns_update.ttl); *result = 0; /* assume failure */ @@ -609,11 +616,13 @@ log_info("calling updatePTR(%s, %s, %d, lease)", expr1.data , expr2.data, ttl); return 0; } -int evaluate_data_expression (result, packet, options, lease, expr) +int evaluate_data_expression (result, packet, lease, + in_options, cfg_options, expr) struct data_string *result; struct packet *packet; - struct option_state *options; struct lease *lease; + struct option_state *in_options; + struct option_state *cfg_options; struct expression *expr; { struct data_string data, other; @@ -625,15 +634,16 @@ int evaluate_data_expression (result, packet, options, lease, expr) /* Extract N bytes starting at byte M of a data string. */ case expr_substring: memset (&data, 0, sizeof data); - s0 = evaluate_data_expression (&data, packet, options, - lease, + s0 = evaluate_data_expression (&data, packet, lease, + in_options, cfg_options, expr -> data.substring.expr); /* Evaluate the offset and length. */ s1 = evaluate_numeric_expression - (&offset, packet, options, lease, + (&offset, packet, lease, in_options, cfg_options, expr -> data.substring.offset); - s2 = evaluate_numeric_expression (&len, packet, options, lease, + s2 = evaluate_numeric_expression (&len, packet, lease, + in_options, cfg_options, expr -> data.substring.len); if (s0 && s1 && s2) { @@ -671,10 +681,12 @@ int evaluate_data_expression (result, packet, options, lease, expr) /* Extract the last N bytes of a data string. */ case expr_suffix: memset (&data, 0, sizeof data); - s0 = evaluate_data_expression (&data, packet, options, lease, + s0 = evaluate_data_expression (&data, packet, lease, + in_options, cfg_options, expr -> data.suffix.expr); /* Evaluate the length. */ - s1 = evaluate_numeric_expression (&len, packet, options, lease, + s1 = evaluate_numeric_expression (&len, packet, lease, + in_options, cfg_options, expr -> data.substring.len); if (s0 && s1) { data_string_copy (result, &data, @@ -703,10 +715,11 @@ int evaluate_data_expression (result, packet, options, lease, expr) /* Extract an option. */ case expr_option: - if (options) + if (in_options) s0 = ((*expr -> data.option -> universe -> get_func) (result, expr -> data.option -> universe, - packet, lease, options, + packet, lease, + in_options, cfg_options, in_options, expr -> data.option -> code)); else s0 = 0; @@ -721,10 +734,11 @@ int evaluate_data_expression (result, packet, options, lease, expr) return s0; case expr_config_option: - if (lease -> state && lease -> state -> options) + if (cfg_options) s0 = ((*expr -> data.option -> universe -> get_func) (result, expr -> data.option -> universe, - packet, lease, lease -> state -> options, + packet, lease, + in_options, cfg_options, cfg_options, expr -> data.option -> code)); else s0 = 0; @@ -774,10 +788,12 @@ int evaluate_data_expression (result, packet, options, lease, expr) return 0; } - s0 = evaluate_numeric_expression (&len, packet, options, lease, + s0 = evaluate_numeric_expression (&len, packet, lease, + in_options, cfg_options, expr -> data.packet.len); s1 = evaluate_numeric_expression (&offset, - packet, options, lease, + packet, lease, + in_options, cfg_options, expr -> data.packet.len); if (s0 && s1 && offset < packet -> packet_length) { if (offset + len > packet -> packet_length) @@ -810,9 +826,10 @@ int evaluate_data_expression (result, packet, options, lease, expr) /* The encapsulation of all defined options in an option space... */ case expr_encapsulate: - if (options) + if (cfg_options) s0 = option_space_encapsulate - (result, options, lease, + (result, packet, lease, + in_options, cfg_options, &expr -> data.encapsulate); else s0 = 0; @@ -852,10 +869,12 @@ int evaluate_data_expression (result, packet, options, lease, expr) /* Concatenation... */ case expr_concat: memset (&data, 0, sizeof data); - s0 = evaluate_data_expression (&data, packet, options, lease, + s0 = evaluate_data_expression (&data, packet, lease, + in_options, cfg_options, expr -> data.concat [0]); memset (&other, 0, sizeof other); - s1 = evaluate_data_expression (&other, packet, options, lease, + s1 = evaluate_data_expression (&other, packet, lease, + in_options, cfg_options, expr -> data.concat [1]); if (s0 && s1) { @@ -889,7 +908,8 @@ int evaluate_data_expression (result, packet, options, lease, expr) return s0 || s1; case expr_encode_int8: - s0 = evaluate_numeric_expression (&len, packet, options, lease, + s0 = evaluate_numeric_expression (&len, packet, lease, + in_options, cfg_options, expr -> data.packet.len); if (s0) { result -> len = 1; @@ -917,7 +937,8 @@ int evaluate_data_expression (result, packet, options, lease, expr) case expr_encode_int16: - s0 = evaluate_numeric_expression (&len, packet, options, lease, + s0 = evaluate_numeric_expression (&len, packet, lease, + in_options, cfg_options, expr -> data.packet.len); if (s0) { result -> len = 2; @@ -944,7 +965,8 @@ int evaluate_data_expression (result, packet, options, lease, expr) return s0; case expr_encode_int32: - s0 = evaluate_numeric_expression (&len, packet, options, lease, + s0 = evaluate_numeric_expression (&len, packet, lease, + in_options, cfg_options, expr -> data.packet.len); if (s0) { result -> len = 4; @@ -973,19 +995,22 @@ int evaluate_data_expression (result, packet, options, lease, expr) case expr_binary_to_ascii: /* Evaluate the base (offset) and width (len): */ s0 = evaluate_numeric_expression - (&offset, packet, options, lease, + (&offset, packet, lease, in_options, cfg_options, expr -> data.b2a.base); - s1 = evaluate_numeric_expression (&len, packet, options, lease, + s1 = evaluate_numeric_expression (&len, packet, lease, + in_options, cfg_options, expr -> data.b2a.width); /* Evaluate the seperator string. */ memset (&data, 0, sizeof data); - s2 = evaluate_data_expression (&data, packet, options, lease, + s2 = evaluate_data_expression (&data, packet, lease, + in_options, cfg_options, expr -> data.b2a.seperator); /* Evaluate the data to be converted. */ memset (&other, 0, sizeof other); - s3 = evaluate_data_expression (&other, packet, options, lease, + s3 = evaluate_data_expression (&other, packet, lease, + in_options, cfg_options, expr -> data.b2a.buffer); if (s0 && s1 && s2 && s3) { @@ -1091,12 +1116,13 @@ int evaluate_data_expression (result, packet, options, lease, expr) case expr_reverse: /* Evaluate the width (len): */ s0 = evaluate_numeric_expression - (&len, packet, options, lease, + (&len, packet, lease, in_options, cfg_options, expr -> data.reverse.width); /* Evaluate the data. */ memset (&data, 0, sizeof data); - s1 = evaluate_data_expression (&data, packet, options, lease, + s1 = evaluate_data_expression (&data, packet, lease, + in_options, cfg_options, expr -> data.reverse.buffer); if (s0 && s1) { @@ -1171,7 +1197,7 @@ int evaluate_data_expression (result, packet, options, lease, expr) case expr_pick_first_value: memset (&data, 0, sizeof data); if ((evaluate_data_expression - (result, packet, options, lease, + (result, packet, lease, in_options, cfg_options, expr -> data.pick_first_value.car))) { #if defined (DEBUG_EXPRESSIONS) log_debug ("data: pick_first_value (%s, ???)", @@ -1181,7 +1207,7 @@ int evaluate_data_expression (result, packet, options, lease, expr) return 1; } if ((evaluate_data_expression - (result, packet, options, lease, + (result, packet, lease, in_options, cfg_options, expr -> data.pick_first_value.cdr))) { #if defined (DEBUG_EXPRESSIONS) log_debug ("data: pick_first_value (NULL, %s)", @@ -1241,11 +1267,13 @@ int evaluate_data_expression (result, packet, options, lease, expr) return 0; } -int evaluate_numeric_expression (result, packet, options, lease, expr) +int evaluate_numeric_expression (result, packet, lease, + in_options, cfg_options, expr) unsigned long *result; struct packet *packet; - struct option_state *options; struct lease *lease; + struct option_state *in_options; + struct option_state *cfg_options; struct expression *expr; { struct data_string data; @@ -1288,8 +1316,8 @@ int evaluate_numeric_expression (result, packet, options, lease, expr) case expr_extract_int8: memset (&data, 0, sizeof data); status = evaluate_data_expression - (&data, packet, - options, lease, expr -> data.extract_int); + (&data, packet, lease, in_options, cfg_options, + expr -> data.extract_int); if (status) *result = data.data [0]; #if defined (DEBUG_EXPRESSIONS) @@ -1304,7 +1332,7 @@ int evaluate_numeric_expression (result, packet, options, lease, expr) case expr_extract_int16: memset (&data, 0, sizeof data); status = (evaluate_data_expression - (&data, packet, options, lease, + (&data, packet, lease, in_options, cfg_options, expr -> data.extract_int)); if (status && data.len >= 2) *result = getUShort (data.data); @@ -1321,7 +1349,7 @@ int evaluate_numeric_expression (result, packet, options, lease, expr) case expr_extract_int32: memset (&data, 0, sizeof data); status = (evaluate_data_expression - (&data, packet, options, lease, + (&data, packet, lease, in_options, cfg_options, expr -> data.extract_int)); if (status && data.len >= 4) *result = getULong (data.data); @@ -1371,11 +1399,12 @@ int evaluate_numeric_expression (result, packet, options, lease, expr) result of that evaluation. There should never be both an expression and a valid data_string. */ -int evaluate_option_cache (result, packet, options, lease, oc) +int evaluate_option_cache (result, packet, lease, in_options, cfg_options, oc) struct data_string *result; struct packet *packet; - struct option_state *options; struct lease *lease; + struct option_state *in_options; + struct option_state *cfg_options; struct option_cache *oc; { if (oc -> data.len) { @@ -1385,28 +1414,31 @@ int evaluate_option_cache (result, packet, options, lease, oc) } if (!oc -> expression) return 0; - return evaluate_data_expression (result, packet, options, lease, + return evaluate_data_expression (result, packet, lease, in_options, + cfg_options, oc -> expression); } /* Evaluate an option cache and extract a boolean from the result, returning the boolean. Return false if there is no data. */ -int evaluate_boolean_option_cache (packet, options, lease, oc) +int evaluate_boolean_option_cache (packet, lease, in_options, cfg_options, oc) struct packet *packet; - struct option_state *options; struct lease *lease; + struct option_state *in_options; + struct option_state *cfg_options; struct option_cache *oc; { struct data_string ds; int result; /* So that we can be called with option_lookup as an argument. */ - if (!oc || !options) + if (!oc || !in_options) return 0; memset (&ds, 0, sizeof ds); - if (!evaluate_option_cache (&ds, packet, options, lease, oc)) + if (!evaluate_option_cache (&ds, packet, lease, + in_options, cfg_options, oc)) return 0; if (ds.len && ds.data [0]) @@ -1421,10 +1453,12 @@ int evaluate_boolean_option_cache (packet, options, lease, oc) /* Evaluate a boolean expression and return the result of the evaluation, or FALSE if it failed. */ -int evaluate_boolean_expression_result (packet, options, lease, expr) +int evaluate_boolean_expression_result (packet, lease, + in_options, cfg_options, expr) struct packet *packet; - struct option_state *options; struct lease *lease; + struct option_state *in_options; + struct option_state *cfg_options; struct expression *expr; { int result; @@ -1433,8 +1467,8 @@ int evaluate_boolean_expression_result (packet, options, lease, expr) if (!expr) return 0; - if (!evaluate_boolean_expression (&result, - packet, options, lease, expr)) + if (!evaluate_boolean_expression (&result, packet, lease, + in_options, cfg_options, expr)) return 0; return result;