workbench/network/stacks/AROSTCP/dhcp/common/memory.c

   1 /* memory.c
   2
   3    Memory-resident database... */
   4
   5 /*
   6  * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
   7  * Copyright (c) 1995-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  *   http://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  * ``http://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 #if 0
  36 static char copyright[] =
  37 "$Id$ Copyright (c) 2004 Internet Systems Consortium.  All rights reserved.\n";
  38 #endif
  39
  40 #include "dhcpd.h"
  41
  42 struct group *root_group;
  43 group_hash_t *group_name_hash;
  44 int (*group_write_hook) (struct group_object *);
  45
  46 isc_result_t delete_group (struct group_object *group, int writep)
  47 {
  48         struct group_object *d;
  49
  50         /* The group should exist and be hashed - if not, it's invalid. */
  51         if (group_name_hash) {
  52                 d = (struct group_object *)0;
  53                 group_hash_lookup (&d, group_name_hash, group -> name,
  54                                    strlen (group -> name), MDL);
  55         } else
  56                 return ISC_R_INVALIDARG;
  57         if (!d)
  58                 return ISC_R_INVALIDARG;
  59
  60         /* Also not okay to delete a group that's not the one in
  61            the hash table. */
  62         if (d != group)
  63                 return ISC_R_INVALIDARG;
  64
  65         /* If it's dynamic, and we're deleting it, we can just blow away the
  66            hash table entry. */
  67         if ((group -> flags & GROUP_OBJECT_DYNAMIC) &&
  68             !(group -> flags & GROUP_OBJECT_STATIC)) {
  69                 group_hash_delete (group_name_hash,
  70                                    group -> name, strlen (group -> name), MDL);
  71         } else {
  72                 group -> flags |= GROUP_OBJECT_DELETED;
  73                 if (group -> group)
  74                         group_dereference (&group -> group, MDL);
  75         }
  76
  77         /* Store the group declaration in the lease file. */
  78         if (writep && group_write_hook) {
  79                 if (!(*group_write_hook) (group))
  80                         return ISC_R_IOERROR;
  81         }
  82         return ISC_R_SUCCESS;
  83 }
  84
  85 isc_result_t supersede_group (struct group_object *group, int writep)
  86 {
  87         struct group_object *t;
  88         // struct group_object *u;
  89         // isc_result_t status;
  90
  91         /* Register the group in the group name hash table,
  92            so we can look it up later. */
  93         if (group_name_hash) {
  94                 t = (struct group_object *)0;
  95                 group_hash_lookup (&t, group_name_hash,
  96                         group -> name,
  97                              strlen (group -> name), MDL);
  98                 if (t && t != group) {
  99                         /* If this isn't a dynamic entry, then we need to flag
 100                            the replacement as not dynamic either - otherwise,
 101                            if the dynamic entry is deleted later, the static
 102                            entry will come back next time the server is stopped
 103                            and restarted. */
 104                         if (!(t -> flags & GROUP_OBJECT_DYNAMIC))
 105                                 group -> flags |= GROUP_OBJECT_STATIC;
 106
 107                         /* Delete the old object if it hasn't already been
 108                            deleted.  If it has already been deleted, get rid of
 109                            the hash table entry.  This is a legitimate
 110                            situation - a deleted static object needs to be kept
 111                            around so we remember it's deleted. */
 112                         if (!(t -> flags & GROUP_OBJECT_DELETED))
 113                                 delete_group (t, 0);
 114                         else {
 115                                 group_hash_delete (group_name_hash,
 116                                                    group -> name,
 117                                                    strlen (group -> name),
 118                                                    MDL);
 119                                 group_object_dereference (&t, MDL);
 120                         }
 121                 }
 122         } else {
 123                 group_new_hash (&group_name_hash, 0, MDL);
 124                 t = (struct group_object *)0;
 125         }
 126
 127         /* Add the group to the group name hash if it's not
 128            already there, and also thread it into the list of
 129            dynamic groups if appropriate. */
 130         if (!t) {
 131                 group_hash_add (group_name_hash, group -> name,
 132                                 strlen (group -> name), group, MDL);
 133         }
 134
 135         /* Store the group declaration in the lease file. */
 136         if (writep && group_write_hook) {
 137                 if (!(*group_write_hook) (group))
 138                         return ISC_R_IOERROR;
 139         }
 140         return ISC_R_SUCCESS;
 141 }
 142
 143 int clone_group (struct group **gp, struct group *group,
 144                  const char *file, int line)
 145 {
 146         // isc_result_t status;
 147         struct group *g = (struct group *)0;
 148
 149         /* Normally gp should contain the null pointer, but for convenience
 150            it's permissible to clone a group into itself. */
 151         if (*gp && *gp != group)
 152                 return 0;
 153         if (!group_allocate (&g, file, line))
 154                 return 0;
 155         if (group == *gp)
 156                 *gp = (struct group *)0;
 157         group_reference (gp, g, file, line);
 158         g -> authoritative = group -> authoritative;
 159         group_reference (&g -> next, group, file, line);
 160         group_dereference (&g, file, line);
 161         return 1;
 162 }