workbench/network/stacks/AROSTCP/dhcp/omapip/auth.c

   1 /* auth.c
   2
   3    Subroutines having to do with authentication. */
   4
   5 /*
   6  * Copyright (c) 2004 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  *   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 ocopyright[] =
  37 "$Id$ Copyright 2004 Internet Systems Consortium.";
  38 #endif
  39
  40 #include <omapip/omapip_p.h>
  41
  42 OMAPI_OBJECT_ALLOC (omapi_auth_key, omapi_auth_key_t, omapi_type_auth_key)
  43 typedef struct hash omapi_auth_hash_t;
  44 HASH_FUNCTIONS_DECL (omapi_auth_key, const char *,
  45                      omapi_auth_key_t, omapi_auth_hash_t)
  46 omapi_auth_hash_t *auth_key_hash;
  47 HASH_FUNCTIONS (omapi_auth_key, const char *, omapi_auth_key_t,
  48                 omapi_auth_hash_t,
  49                 omapi_auth_key_reference, omapi_auth_key_dereference)
  50
  51 isc_result_t omapi_auth_key_new (omapi_auth_key_t **o, const char *file,
  52                                  int line)
  53 {
  54         return omapi_auth_key_allocate (o, file, line);
  55 }
  56
  57 isc_result_t omapi_auth_key_destroy (omapi_object_t *h,
  58                                      const char *file, int line)
  59 {
  60         omapi_auth_key_t *a;
  61
  62         if (h -> type != omapi_type_auth_key)
  63                 return ISC_R_INVALIDARG;
  64         a = (omapi_auth_key_t *)h;
  65
  66         if (auth_key_hash)
  67                 omapi_auth_key_hash_delete (auth_key_hash, a -> name, 0, MDL);
  68
  69         if (a -> name)
  70                 dfree (a -> name, MDL);
  71         if (a -> algorithm)
  72                 dfree (a -> algorithm, MDL);
  73         if (a -> key)
  74                 omapi_data_string_dereference (&a -> key, MDL);
  75
  76         return ISC_R_SUCCESS;
  77 }
  78
  79 isc_result_t omapi_auth_key_enter (omapi_auth_key_t *a)
  80 {
  81         omapi_auth_key_t *tk;
  82
  83         if (a -> type != omapi_type_auth_key)
  84                 return ISC_R_INVALIDARG;
  85
  86         tk = (omapi_auth_key_t *)0;
  87         if (auth_key_hash) {
  88                 omapi_auth_key_hash_lookup (&tk, auth_key_hash,
  89                                             a -> name, 0, MDL);
  90                 if (tk == a) {
  91                         omapi_auth_key_dereference (&tk, MDL);
  92                         return ISC_R_SUCCESS;
  93                 }
  94                 if (tk) {
  95                         omapi_auth_key_hash_delete (auth_key_hash,
  96                                                     tk -> name, 0, MDL);
  97                         omapi_auth_key_dereference (&tk, MDL);
  98                 }
  99         } else {
 100                 if (!omapi_auth_key_new_hash (&auth_key_hash, 1, MDL))
 101                         return ISC_R_NOMEMORY;
 102         }
 103         omapi_auth_key_hash_add (auth_key_hash, a -> name, 0, a, MDL);
 104         return ISC_R_SUCCESS;
 105
 106 }
 107
 108 isc_result_t omapi_auth_key_lookup_name (omapi_auth_key_t **a,
 109                                          const char *name)
 110 {
 111         if (!auth_key_hash)
 112                 return ISC_R_NOTFOUND;
 113         if (!omapi_auth_key_hash_lookup (a, auth_key_hash, name, 0, MDL))
 114                 return ISC_R_NOTFOUND;
 115         return ISC_R_SUCCESS;
 116 }
 117
 118 isc_result_t omapi_auth_key_lookup (omapi_object_t **h,
 119                                     omapi_object_t *id,
 120                                     omapi_object_t *ref)
 121 {
 122         isc_result_t status;
 123         omapi_value_t *name = (omapi_value_t *)0;
 124         omapi_value_t *algorithm = (omapi_value_t *)0;
 125
 126         if (!auth_key_hash)
 127                 return ISC_R_NOTFOUND;
 128
 129         if (!ref)
 130                 return ISC_R_NOKEYS;
 131
 132         status = omapi_get_value_str (ref, id, "name", &name);
 133         if (status != ISC_R_SUCCESS)
 134                 return status;
 135
 136         if ((name -> value -> type != omapi_datatype_string) &&
 137             (name -> value -> type != omapi_datatype_data)) {
 138                 omapi_value_dereference (&name, MDL);
 139                 return ISC_R_NOTFOUND;
 140         }
 141
 142         status = omapi_get_value_str (ref, id, "algorithm", &algorithm);
 143         if (status != ISC_R_SUCCESS) {
 144                 omapi_value_dereference (&name, MDL);
 145                 return status;
 146         }
 147
 148         if ((algorithm -> value -> type != omapi_datatype_string) &&
 149             (algorithm -> value -> type != omapi_datatype_data)) {
 150                 omapi_value_dereference (&name, MDL);
 151                 omapi_value_dereference (&algorithm, MDL);
 152                 return ISC_R_NOTFOUND;
 153         }
 154
 155
 156         if (!omapi_auth_key_hash_lookup ((omapi_auth_key_t **)h, auth_key_hash,
 157                                          (const char *)
 158                                          name -> value -> u.buffer.value,
 159                                          name -> value -> u.buffer.len, MDL)) {
 160                 omapi_value_dereference (&name, MDL);
 161                 omapi_value_dereference (&algorithm, MDL);
 162                 return ISC_R_NOTFOUND;
 163         }
 164
 165         if (omapi_td_strcasecmp (algorithm -> value,
 166                                  ((omapi_auth_key_t *)*h) -> algorithm) != 0) {
 167                 omapi_value_dereference (&name, MDL);
 168                 omapi_value_dereference (&algorithm, MDL);
 169                 omapi_object_dereference (h, MDL);
 170                 return ISC_R_NOTFOUND;
 171         }
 172
 173         omapi_value_dereference (&name, MDL);
 174         omapi_value_dereference (&algorithm, MDL);
 175
 176         return ISC_R_SUCCESS;
 177 }
 178
 179 isc_result_t omapi_auth_key_stuff_values (omapi_object_t *c,
 180                                           omapi_object_t *id,
 181                                           omapi_object_t *h)
 182 {
 183         omapi_auth_key_t *a;
 184         isc_result_t status;
 185
 186         if (h -> type != omapi_type_auth_key)
 187                 return ISC_R_INVALIDARG;
 188         a = (omapi_auth_key_t *)h;
 189
 190         /* Write only the name and algorithm -- not the secret! */
 191         if (a -> name) {
 192                 status = omapi_connection_put_name (c, "name");
 193                 if (status != ISC_R_SUCCESS)
 194                         return status;
 195                 status = omapi_connection_put_string (c, a -> name);
 196                 if (status != ISC_R_SUCCESS)
 197                         return status;
 198         }
 199         if (a -> algorithm) {
 200                 status = omapi_connection_put_name (c, "algorithm");
 201                 if (status != ISC_R_SUCCESS)
 202                         return status;
 203                 status = omapi_connection_put_string (c, a -> algorithm);
 204                 if (status != ISC_R_SUCCESS)
 205                         return status;
 206         }
 207
 208         return ISC_R_SUCCESS;
 209 }
 210
 211 isc_result_t omapi_auth_key_get_value (omapi_object_t *h,
 212                                        omapi_object_t *id,
 213                                        omapi_data_string_t *name,
 214                                        omapi_value_t **value)
 215 {
 216         omapi_auth_key_t *a;
 217         isc_result_t status;
 218
 219         if (h -> type != omapi_type_auth_key)
 220                 return ISC_R_UNEXPECTED;
 221         a = (omapi_auth_key_t *)h;
 222
 223         if (omapi_ds_strcmp (name, "name") == 0) {
 224                 if (a -> name)
 225                         return omapi_make_string_value
 226                                 (value, name, a -> name, MDL);
 227                 else
 228                         return ISC_R_NOTFOUND;
 229         } else if (omapi_ds_strcmp (name, "key") == 0) {
 230                 if (a -> key) {
 231                         status = omapi_value_new (value, MDL);
 232                         if (status != ISC_R_SUCCESS)
 233                                 return status;
 234
 235                         status = omapi_data_string_reference
 236                                 (&(*value) -> name, name, MDL);
 237                         if (status != ISC_R_SUCCESS) {
 238                                 omapi_value_dereference (value, MDL);
 239                                 return status;
 240                         }
 241
 242                         status = omapi_typed_data_new (MDL, &(*value) -> value,
 243                                                        omapi_datatype_data,
 244                                                        a -> key -> len);
 245                         if (status != ISC_R_SUCCESS) {
 246                                 omapi_value_dereference (value, MDL);
 247                                 return status;
 248                         }
 249
 250                         memcpy ((*value) -> value -> u.buffer.value,
 251                                 a -> key -> value, a -> key -> len);
 252                         return ISC_R_SUCCESS;
 253                 } else
 254                         return ISC_R_NOTFOUND;
 255         } else if (omapi_ds_strcmp (name, "algorithm") == 0) {
 256                 if (a -> algorithm)
 257                         return omapi_make_string_value
 258                                 (value, name, a -> algorithm, MDL);
 259                 else
 260                         return ISC_R_NOTFOUND;
 261         }
 262
 263         return ISC_R_SUCCESS;
 264 }