Annotation of embedaddon/dhcp/server/class.c, revision 1.1
1.1 ! misho 1: /* class.c
! 2:
! 3: Handling for client classes. */
! 4:
! 5: /*
! 6: * Copyright (c) 2004,2007,2009 by Internet Systems Consortium, Inc. ("ISC")
! 7: * Copyright (c) 1998-2003 by Internet Software Consortium
! 8: *
! 9: * Permission to use, copy, modify, and distribute this software for any
! 10: * purpose with or without fee is hereby granted, provided that the above
! 11: * copyright notice and this permission notice appear in all copies.
! 12: *
! 13: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
! 14: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 15: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
! 16: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 17: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 18: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
! 19: * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 20: *
! 21: * Internet Systems Consortium, Inc.
! 22: * 950 Charter Street
! 23: * Redwood City, CA 94063
! 24: * <info@isc.org>
! 25: * https://www.isc.org/
! 26: *
! 27: * This software has been written for Internet Systems Consortium
! 28: * by Ted Lemon in cooperation with Vixie Enterprises and Nominum, Inc.
! 29: * To learn more about Internet Systems Consortium, see
! 30: * ``https://www.isc.org/''. To learn more about Vixie Enterprises,
! 31: * see ``http://www.vix.com''. To learn more about Nominum, Inc., see
! 32: * ``http://www.nominum.com''.
! 33: */
! 34:
! 35: #include "dhcpd.h"
! 36:
! 37: struct collection default_collection = {
! 38: (struct collection *)0,
! 39: "default",
! 40: (struct class *)0,
! 41: };
! 42:
! 43: struct collection *collections = &default_collection;
! 44: struct executable_statement *default_classification_rules;
! 45:
! 46: int have_billing_classes;
! 47:
! 48: /* Build the default classification rule tree. */
! 49:
! 50: void classification_setup ()
! 51: {
! 52: /* eval ... */
! 53: default_classification_rules = (struct executable_statement *)0;
! 54: if (!executable_statement_allocate (&default_classification_rules,
! 55: MDL))
! 56: log_fatal ("Can't allocate check of default collection");
! 57: default_classification_rules -> op = eval_statement;
! 58:
! 59: /* check-collection "default" */
! 60: if (!expression_allocate (&default_classification_rules -> data.eval,
! 61: MDL))
! 62: log_fatal ("Can't allocate default check expression");
! 63: default_classification_rules -> data.eval -> op = expr_check;
! 64: default_classification_rules -> data.eval -> data.check =
! 65: &default_collection;
! 66: }
! 67:
! 68: void classify_client (packet)
! 69: struct packet *packet;
! 70: {
! 71: execute_statements ((struct binding_value **)0, packet,
! 72: (struct lease *)0, (struct client_state *)0,
! 73: packet -> options, (struct option_state *)0,
! 74: &global_scope, default_classification_rules);
! 75: }
! 76:
! 77: int check_collection (packet, lease, collection)
! 78: struct packet *packet;
! 79: struct lease *lease;
! 80: struct collection *collection;
! 81: {
! 82: struct class *class, *nc;
! 83: struct data_string data;
! 84: int matched = 0;
! 85: int status;
! 86: int ignorep;
! 87:
! 88: for (class = collection -> classes; class; class = class -> nic) {
! 89: #if defined (DEBUG_CLASS_MATCHING)
! 90: log_info ("checking against class %s...", class -> name);
! 91: #endif
! 92: memset (&data, 0, sizeof data);
! 93:
! 94: /* If there is a "match if" expression, check it. If
! 95: we get a match, and there's no subclass expression,
! 96: it's a match. If we get a match and there is a subclass
! 97: expression, then we check the submatch. If it's not a
! 98: match, that's final - we don't check the submatch. */
! 99:
! 100: if (class -> expr) {
! 101: status = (evaluate_boolean_expression_result
! 102: (&ignorep, packet, lease,
! 103: (struct client_state *)0,
! 104: packet -> options, (struct option_state *)0,
! 105: lease ? &lease -> scope : &global_scope,
! 106: class -> expr));
! 107: if (status) {
! 108: if (!class -> submatch) {
! 109: matched = 1;
! 110: #if defined (DEBUG_CLASS_MATCHING)
! 111: log_info ("matches class.");
! 112: #endif
! 113: classify (packet, class);
! 114: continue;
! 115: }
! 116: } else
! 117: continue;
! 118: }
! 119:
! 120: /* Check to see if the client matches an existing subclass.
! 121: If it doesn't, and this is a spawning class, spawn a new
! 122: subclass and put the client in it. */
! 123: if (class -> submatch) {
! 124: status = (evaluate_data_expression
! 125: (&data, packet, lease,
! 126: (struct client_state *)0,
! 127: packet -> options, (struct option_state *)0,
! 128: lease ? &lease -> scope : &global_scope,
! 129: class -> submatch, MDL));
! 130: if (status && data.len) {
! 131: nc = (struct class *)0;
! 132: if (class_hash_lookup (&nc, class -> hash,
! 133: (const char *)data.data,
! 134: data.len, MDL)) {
! 135: #if defined (DEBUG_CLASS_MATCHING)
! 136: log_info ("matches subclass %s.",
! 137: print_hex_1 (data.len,
! 138: data.data, 60));
! 139: #endif
! 140: data_string_forget (&data, MDL);
! 141: classify (packet, nc);
! 142: matched = 1;
! 143: class_dereference (&nc, MDL);
! 144: continue;
! 145: }
! 146: if (!class -> spawning) {
! 147: data_string_forget (&data, MDL);
! 148: continue;
! 149: }
! 150: /* XXX Write out the spawned class? */
! 151: #if defined (DEBUG_CLASS_MATCHING)
! 152: log_info ("spawning subclass %s.",
! 153: print_hex_1 (data.len, data.data, 60));
! 154: #endif
! 155: status = class_allocate (&nc, MDL);
! 156: group_reference (&nc -> group,
! 157: class -> group, MDL);
! 158: class_reference (&nc -> superclass,
! 159: class, MDL);
! 160: nc -> lease_limit = class -> lease_limit;
! 161: nc -> dirty = 1;
! 162: if (nc -> lease_limit) {
! 163: nc -> billed_leases =
! 164: (dmalloc
! 165: (nc -> lease_limit *
! 166: sizeof (struct lease *),
! 167: MDL));
! 168: if (!nc -> billed_leases) {
! 169: log_error ("no memory for%s",
! 170: " billing");
! 171: data_string_forget
! 172: (&nc -> hash_string,
! 173: MDL);
! 174: class_dereference (&nc, MDL);
! 175: data_string_forget (&data,
! 176: MDL);
! 177: continue;
! 178: }
! 179: memset (nc -> billed_leases, 0,
! 180: (nc -> lease_limit *
! 181: sizeof nc -> billed_leases));
! 182: }
! 183: data_string_copy (&nc -> hash_string, &data,
! 184: MDL);
! 185: data_string_forget (&data, MDL);
! 186: if (!class -> hash)
! 187: class_new_hash(&class->hash,
! 188: SCLASS_HASH_SIZE, MDL);
! 189: class_hash_add (class -> hash,
! 190: (const char *)
! 191: nc -> hash_string.data,
! 192: nc -> hash_string.len,
! 193: nc, MDL);
! 194: classify (packet, nc);
! 195: class_dereference (&nc, MDL);
! 196: }
! 197: }
! 198: }
! 199: return matched;
! 200: }
! 201:
! 202: void classify (packet, class)
! 203: struct packet *packet;
! 204: struct class *class;
! 205: {
! 206: if (packet -> class_count < PACKET_MAX_CLASSES)
! 207: class_reference (&packet -> classes [packet -> class_count++],
! 208: class, MDL);
! 209: else
! 210: log_error ("too many classes match %s",
! 211: print_hw_addr (packet -> raw -> htype,
! 212: packet -> raw -> hlen,
! 213: packet -> raw -> chaddr));
! 214: }
! 215:
! 216:
! 217: isc_result_t unlink_class(struct class **class) {
! 218: struct collection *lp;
! 219: struct class *cp, *pp;
! 220:
! 221: for (lp = collections; lp; lp = lp -> next) {
! 222: for (pp = 0, cp = lp -> classes; cp; pp = cp, cp = cp -> nic)
! 223: if (cp == *class) {
! 224: if (pp == 0) {
! 225: lp->classes = cp->nic;
! 226: } else {
! 227: pp->nic = cp->nic;
! 228: }
! 229: cp->nic = 0;
! 230: class_dereference(class, MDL);
! 231:
! 232: return ISC_R_SUCCESS;
! 233: }
! 234: }
! 235: return ISC_R_NOTFOUND;
! 236: }
! 237:
! 238:
! 239: isc_result_t find_class (struct class **class, const char *name,
! 240: const char *file, int line)
! 241: {
! 242: struct collection *lp;
! 243: struct class *cp;
! 244:
! 245: for (lp = collections; lp; lp = lp -> next) {
! 246: for (cp = lp -> classes; cp; cp = cp -> nic)
! 247: if (cp -> name && !strcmp (name, cp -> name)) {
! 248: return class_reference (class, cp, file, line);
! 249: }
! 250: }
! 251: return ISC_R_NOTFOUND;
! 252: }
! 253:
! 254: int unbill_class (lease, class)
! 255: struct lease *lease;
! 256: struct class *class;
! 257: {
! 258: int i;
! 259:
! 260: for (i = 0; i < class -> lease_limit; i++)
! 261: if (class -> billed_leases [i] == lease)
! 262: break;
! 263: if (i == class -> lease_limit) {
! 264: log_error ("lease %s unbilled with no billing arrangement.",
! 265: piaddr (lease -> ip_addr));
! 266: return 0;
! 267: }
! 268: class_dereference (&lease -> billing_class, MDL);
! 269: lease_dereference (&class -> billed_leases [i], MDL);
! 270: class -> leases_consumed--;
! 271: return 1;
! 272: }
! 273:
! 274: int bill_class (lease, class)
! 275: struct lease *lease;
! 276: struct class *class;
! 277: {
! 278: int i;
! 279:
! 280: if (lease -> billing_class) {
! 281: log_error ("lease billed with existing billing arrangement.");
! 282: unbill_class (lease, lease -> billing_class);
! 283: }
! 284:
! 285: if (class -> leases_consumed == class -> lease_limit)
! 286: return 0;
! 287:
! 288: for (i = 0; i < class -> lease_limit; i++)
! 289: if (!class -> billed_leases [i])
! 290: break;
! 291:
! 292: if (i == class -> lease_limit) {
! 293: log_error ("class billing consumption disagrees with leases.");
! 294: return 0;
! 295: }
! 296:
! 297: lease_reference (&class -> billed_leases [i], lease, MDL);
! 298: class_reference (&lease -> billing_class, class, MDL);
! 299: class -> leases_consumed++;
! 300: return 1;
! 301: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to class.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dhcp / server