contrib/bind9/lib/isccc/sexpr.c

   1 /*
   2  * Portions Copyright (C) 2004, 2005  Internet Systems Consortium, Inc. ("ISC")
   3  * Portions Copyright (C) 2001  Internet Software Consortium.
   4  * Portions Copyright (C) 2001  Nominum, Inc.
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC AND NOMINUM DISCLAIMS ALL
  11  * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
  12  * OF MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY
  13  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 /* $Id: sexpr.c,v 1.4.18.2 2005/04/29 00:17:12 marka Exp $ */
  20
  21 /*! \file */
  22
  23 #include <config.h>
  24
  25 #include <ctype.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #include <isc/assertions.h>
  30 #include <isccc/sexpr.h>
  31 #include <isccc/util.h>
  32
  33 static isccc_sexpr_t sexpr_t = { ISCCC_SEXPRTYPE_T, { NULL } };
  34
  35 #define CAR(s)                  (s)->value.as_dottedpair.car
  36 #define CDR(s)                  (s)->value.as_dottedpair.cdr
  37
  38 isccc_sexpr_t *
  39 isccc_sexpr_cons(isccc_sexpr_t *car, isccc_sexpr_t *cdr)
  40 {
  41         isccc_sexpr_t *sexpr;
  42
  43         sexpr = malloc(sizeof(*sexpr));
  44         if (sexpr == NULL)
  45                 return (NULL);
  46         sexpr->type = ISCCC_SEXPRTYPE_DOTTEDPAIR;
  47         CAR(sexpr) = car;
  48         CDR(sexpr) = cdr;
  49
  50         return (sexpr);
  51 }
  52
  53 isccc_sexpr_t *
  54 isccc_sexpr_tconst(void)
  55 {
  56         return (&sexpr_t);
  57 }
  58
  59 isccc_sexpr_t *
  60 isccc_sexpr_fromstring(const char *str)
  61 {
  62         isccc_sexpr_t *sexpr;
  63
  64         sexpr = malloc(sizeof(*sexpr));
  65         if (sexpr == NULL)
  66                 return (NULL);
  67         sexpr->type = ISCCC_SEXPRTYPE_STRING;
  68         sexpr->value.as_string = strdup(str);
  69         if (sexpr->value.as_string == NULL) {
  70                 free(sexpr);
  71                 return (NULL);
  72         }
  73
  74         return (sexpr);
  75 }
  76
  77 isccc_sexpr_t *
  78 isccc_sexpr_frombinary(const isccc_region_t *region)
  79 {
  80         isccc_sexpr_t *sexpr;
  81         unsigned int region_size;
  82
  83         sexpr = malloc(sizeof(*sexpr));
  84         if (sexpr == NULL)
  85                 return (NULL);
  86         sexpr->type = ISCCC_SEXPRTYPE_BINARY;
  87         region_size = REGION_SIZE(*region);
  88         /*
  89          * We add an extra byte when we malloc so we can NUL terminate
  90          * the binary data.  This allows the caller to use it as a C
  91          * string.  It's up to the caller to ensure this is safe.  We don't
  92          * add 1 to the length of the binary region, because the NUL is
  93          * not part of the binary data.
  94          */
  95         sexpr->value.as_region.rstart = malloc(region_size + 1);
  96         if (sexpr->value.as_region.rstart == NULL) {
  97                 free(sexpr);
  98                 return (NULL);
  99         }
 100         sexpr->value.as_region.rend = sexpr->value.as_region.rstart +
 101                 region_size;
 102         memcpy(sexpr->value.as_region.rstart, region->rstart, region_size);
 103         /*
 104          * NUL terminate.
 105          */
 106         sexpr->value.as_region.rstart[region_size] = '\0';
 107
 108         return (sexpr);
 109 }
 110
 111 void
 112 isccc_sexpr_free(isccc_sexpr_t **sexprp)
 113 {
 114         isccc_sexpr_t *sexpr;
 115         isccc_sexpr_t *item;
 116
 117         sexpr = *sexprp;
 118         if (sexpr == NULL)
 119                 return;
 120         switch (sexpr->type) {
 121         case ISCCC_SEXPRTYPE_STRING:
 122                 free(sexpr->value.as_string);
 123                 break;
 124         case ISCCC_SEXPRTYPE_DOTTEDPAIR:
 125                 item = CAR(sexpr);
 126                 if (item != NULL)
 127                         isccc_sexpr_free(&item);
 128                 item = CDR(sexpr);
 129                 if (item != NULL)
 130                         isccc_sexpr_free(&item);
 131                 break;
 132         case ISCCC_SEXPRTYPE_BINARY:
 133                 free(sexpr->value.as_region.rstart);
 134                 break;
 135         }
 136         free(sexpr);
 137
 138         *sexprp = NULL;
 139 }
 140
 141 static isc_boolean_t
 142 printable(isccc_region_t *r)
 143 {
 144         unsigned char *curr;
 145
 146         curr = r->rstart;
 147         while (curr != r->rend) {
 148                 if (!isprint(*curr))
 149                         return (ISC_FALSE);
 150                 curr++;
 151         }
 152
 153         return (ISC_TRUE);
 154 }
 155
 156 void
 157 isccc_sexpr_print(isccc_sexpr_t *sexpr, FILE *stream)
 158 {
 159         isccc_sexpr_t *cdr;
 160         unsigned int size, i;
 161         unsigned char *curr;
 162
 163         if (sexpr == NULL) {
 164                 fprintf(stream, "nil");
 165                 return;
 166         }
 167
 168         switch (sexpr->type) {
 169         case ISCCC_SEXPRTYPE_T:
 170                 fprintf(stream, "t");
 171                 break;
 172         case ISCCC_SEXPRTYPE_STRING:
 173                 fprintf(stream, "\"%s\"", sexpr->value.as_string);
 174                 break;
 175         case ISCCC_SEXPRTYPE_DOTTEDPAIR:
 176                 fprintf(stream, "(");
 177                 do {
 178                         isccc_sexpr_print(CAR(sexpr), stream);
 179                         cdr = CDR(sexpr);
 180                         if (cdr != NULL) {
 181                                 fprintf(stream, " ");
 182                                 if (cdr->type != ISCCC_SEXPRTYPE_DOTTEDPAIR) {
 183                                         fprintf(stream, ". ");
 184                                         isccc_sexpr_print(cdr, stream);
 185                                         cdr = NULL;
 186                                 }
 187                         }
 188                         sexpr = cdr;
 189                 } while (sexpr != NULL);
 190                 fprintf(stream, ")");
 191                 break;
 192         case ISCCC_SEXPRTYPE_BINARY:
 193                 size = REGION_SIZE(sexpr->value.as_region);
 194                 curr = sexpr->value.as_region.rstart;
 195                 if (printable(&sexpr->value.as_region)) {
 196                         fprintf(stream, "'%.*s'", (int)size, curr);
 197                 } else {
 198                         fprintf(stream, "0x");
 199                         for (i = 0; i < size; i++)
 200                                 fprintf(stream, "%02x", *curr++);
 201                 }
 202                 break;
 203         default:
 204                 INSIST(0);
 205         }
 206 }
 207
 208 isccc_sexpr_t *
 209 isccc_sexpr_car(isccc_sexpr_t *list)
 210 {
 211         REQUIRE(list->type == ISCCC_SEXPRTYPE_DOTTEDPAIR);
 212
 213         return (CAR(list));
 214 }
 215
 216 isccc_sexpr_t *
 217 isccc_sexpr_cdr(isccc_sexpr_t *list)
 218 {
 219         REQUIRE(list->type == ISCCC_SEXPRTYPE_DOTTEDPAIR);
 220
 221         return (CDR(list));
 222 }
 223
 224 void
 225 isccc_sexpr_setcar(isccc_sexpr_t *pair, isccc_sexpr_t *car)
 226 {
 227         REQUIRE(pair->type == ISCCC_SEXPRTYPE_DOTTEDPAIR);
 228
 229         CAR(pair) = car;
 230 }
 231
 232 void
 233 isccc_sexpr_setcdr(isccc_sexpr_t *pair, isccc_sexpr_t *cdr)
 234 {
 235         REQUIRE(pair->type == ISCCC_SEXPRTYPE_DOTTEDPAIR);
 236
 237         CDR(pair) = cdr;
 238 }
 239
 240 isccc_sexpr_t *
 241 isccc_sexpr_addtolist(isccc_sexpr_t **l1p, isccc_sexpr_t *l2)
 242 {
 243         isccc_sexpr_t *last, *elt, *l1;
 244
 245         REQUIRE(l1p != NULL);
 246         l1 = *l1p;
 247         REQUIRE(l1 == NULL || l1->type == ISCCC_SEXPRTYPE_DOTTEDPAIR);
 248
 249         elt = isccc_sexpr_cons(l2, NULL);
 250         if (elt == NULL)
 251                 return (NULL);
 252         if (l1 == NULL) {
 253                 *l1p = elt;
 254                 return (elt);
 255         }
 256         for (last = l1; CDR(last) != NULL; last = CDR(last))
 257                 /* Nothing */;
 258         CDR(last) = elt;
 259
 260         return (elt);
 261 }
 262
 263 isc_boolean_t
 264 isccc_sexpr_listp(isccc_sexpr_t *sexpr)
 265 {
 266         if (sexpr == NULL || sexpr->type == ISCCC_SEXPRTYPE_DOTTEDPAIR)
 267                 return (ISC_TRUE);
 268         return (ISC_FALSE);
 269 }
 270
 271 isc_boolean_t
 272 isccc_sexpr_emptyp(isccc_sexpr_t *sexpr)
 273 {
 274         if (sexpr == NULL)
 275                 return (ISC_TRUE);
 276         return (ISC_FALSE);
 277 }
 278
 279 isc_boolean_t
 280 isccc_sexpr_stringp(isccc_sexpr_t *sexpr)
 281 {
 282         if (sexpr != NULL && sexpr->type == ISCCC_SEXPRTYPE_STRING)
 283                 return (ISC_TRUE);
 284         return (ISC_FALSE);
 285 }
 286
 287 isc_boolean_t
 288 isccc_sexpr_binaryp(isccc_sexpr_t *sexpr)
 289 {
 290         if (sexpr != NULL && sexpr->type == ISCCC_SEXPRTYPE_BINARY)
 291                 return (ISC_TRUE);
 292         return (ISC_FALSE);
 293 }
 294
 295 char *
 296 isccc_sexpr_tostring(isccc_sexpr_t *sexpr)
 297 {
 298         REQUIRE(sexpr != NULL &&
 299                 (sexpr->type == ISCCC_SEXPRTYPE_STRING ||
 300                  sexpr->type == ISCCC_SEXPRTYPE_BINARY));
 301
 302         if (sexpr->type == ISCCC_SEXPRTYPE_BINARY)
 303                 return ((char *)sexpr->value.as_region.rstart);
 304         return (sexpr->value.as_string);
 305 }
 306
 307 isccc_region_t *
 308 isccc_sexpr_tobinary(isccc_sexpr_t *sexpr)
 309 {
 310         REQUIRE(sexpr != NULL && sexpr->type == ISCCC_SEXPRTYPE_BINARY);
 311         return (&sexpr->value.as_region);
 312 }