libasn1fix/asn1fix_misc.c

   1 #include "asn1fix_internal.h"
   2 #include "asn1fix.h"
   3
   4 char const *
   5 asn1f_printable_reference(const asn1p_ref_t *ref) {
   6         if(ref) {
   7                 return asn1p_ref_string(ref);
   8         } else {
   9                 return "<no ref>";
  10         }
  11 }
  12
  13 char const *
  14 asn1f_printable_value(asn1p_value_t *v) {
  15         static char buf[128];
  16         static char *managedptr;
  17         static size_t managedptr_len;
  18         int ret;
  19
  20 #define ENSURE(len)     do {                        \
  21         size_t tmp_len = (len);                     \
  22         if(tmp_len >= managedptr_len) {             \
  23             free(managedptr);                       \
  24             managedptr = calloc(1, tmp_len + 1);    \
  25             if(managedptr) {                        \
  26                 managedptr_len = tmp_len;           \
  27             } else {                                \
  28                 managedptr_len = 0;                 \
  29                 return "<memory allocation error>"; \
  30             }                                       \
  31         }                                           \
  32     } while(0)
  33
  34         if(v == NULL)
  35                 return "<no value>";
  36
  37         switch(v->type) {
  38         case ATV_NOVALUE:
  39                 return "<NO VALUE>";
  40         case ATV_NULL:
  41                 return "NULL";
  42         case ATV_REAL:
  43                 ret = snprintf(buf, sizeof(buf), "%f", v->value.v_double);
  44                 if(ret >= (ssize_t)sizeof(buf))
  45                         memcpy(buf + sizeof(buf) - 4, "...", 4);
  46                 return buf;
  47         case ATV_INTEGER:
  48                 ret = snprintf(buf, sizeof(buf), "%s", asn1p_itoa(v->value.v_integer));
  49                 if(ret >= (ssize_t)sizeof(buf))
  50                         memcpy(buf + sizeof(buf) - 4, "...", 4);
  51                 return buf;
  52         case ATV_MIN: return "MIN";
  53         case ATV_MAX: return "MAX";
  54         case ATV_FALSE: return "FALSE";
  55         case ATV_TRUE: return "TRUE";
  56         case ATV_TUPLE:
  57                 ret = snprintf(buf, sizeof(buf), "{%d, %d}",
  58                         (int)(v->value.v_integer >> 4),
  59                         (int)(v->value.v_integer & 0xff));
  60                 if(ret >= (ssize_t)sizeof(buf))
  61                         memcpy(buf + sizeof(buf) - 4, "...", 4);
  62                 return buf;
  63         case ATV_QUADRUPLE:
  64                 ret = snprintf(buf, sizeof(buf), "{%d, %d, %d, %d}",
  65                         (int)((v->value.v_integer >> 24) & 0xff),
  66                         (int)((v->value.v_integer >> 16) & 0xff),
  67                         (int)((v->value.v_integer >>  8) & 0xff),
  68                         (int)(v->value.v_integer & 0xff));
  69                 if(ret >= (ssize_t)sizeof(buf))
  70                         memcpy(buf + sizeof(buf) - 4, "...", 4);
  71                 return buf;
  72         case ATV_STRING:
  73         case ATV_UNPARSED:
  74                 /* Buffer is guaranteed to be null-terminated */
  75                 assert(v->value.string.buf[v->value.string.size] == '\0');
  76                 return (char *)v->value.string.buf;
  77         case ATV_TYPE:
  78                 return "<Type>";
  79         case ATV_BITVECTOR:
  80                 {
  81                         uint8_t *bitvector;
  82                         char *ptr;
  83                         size_t len;
  84                         int i;
  85                         /*
  86                          * Compute number of bytes necessary
  87                          * to represend the binary value.
  88                          */
  89                         int bits = v->value.binary_vector.size_in_bits;
  90                         len = ((bits%8)?bits:(bits >> 2)) + sizeof("''H");
  91                         /*
  92                          * Reallocate managed buffer
  93                          */
  94                         ENSURE(len);
  95
  96                         /*
  97                          * Fill the buffer.
  98                          */
  99                         ptr = managedptr;
 100                         bitvector = v->value.binary_vector.bits;
 101                         *ptr++ = '\'';
 102                         if(bits%8) {
 103                                 /*
 104                                  * Dump bit by bit.
 105                                  */
 106                                 for(i = 0; i < bits; i++) {
 107                                         uint8_t uc;
 108                                         uc = bitvector[i>>3];
 109                                         *ptr++ = ((uc >> (7-(i%8)))&1)?'1':'0';
 110                                 }
 111                         } else {
 112                                 static const char *hextable="0123456789ABCDEF";
 113                                 /*
 114                                  * Dump byte by byte.
 115                                  */
 116                                 for(i = 0; i < (bits >> 3); i++) {
 117                                         *ptr++ = hextable[bitvector[i] >> 4];
 118                                         *ptr++ = hextable[bitvector[i] & 0x0f];
 119                                 }
 120                         }
 121                         *ptr++ = '\'';
 122                         *ptr++ = (bits%8)?'B':'H';
 123                         *ptr++ = 'H';
 124                         assert(len == (size_t)(ptr - managedptr));
 125                         return managedptr;
 126                 }
 127         case ATV_REFERENCED:
 128                 {
 129                         asn1p_ref_t *ref;
 130                         size_t reflen;
 131                         char *ptr;
 132
 133                         assert(v->value.reference);
 134                         ref = v->value.reference;
 135                         reflen = ref->comp_count;       /* Number of dots */
 136                         for(size_t i = 0; i < ref->comp_count; i++)
 137                                 reflen += strlen(ref->components[i].name);
 138                         /*
 139                          * Make sure we have a buffer of this size.
 140                          */
 141                         ENSURE(reflen);
 142
 143                         /*
 144                          * Fill-up the buffer.
 145                          */
 146                         ptr = managedptr;
 147                         for(size_t i = 0; i < ref->comp_count; i++) {
 148                                 char *nc;
 149                                 if(i) *ptr++ = '.';
 150                                 for(nc = ref->components[i].name; *nc; nc++)
 151                                         *ptr++ = *nc;
 152                         }
 153                         *ptr++ = '\0';
 154                         assert(reflen == (size_t)(ptr - managedptr));
 155                         return managedptr;
 156                 }
 157         case ATV_VALUESET:
 158                 return "<ValueSet>";
 159         case ATV_CHOICE_IDENTIFIER:
 160                 {
 161                         char *cid = v->value.choice_identifier.identifier;
 162                         char const *vptr = asn1f_printable_value(
 163                                         v->value.choice_identifier.value);
 164                         char *val;
 165
 166                         val = strdup(vptr);
 167                         if(!val) return "<memory allocation error>";
 168
 169                         ENSURE(strlen(cid) + sizeof(": ") + strlen(val));
 170
 171                         ret = snprintf(managedptr, managedptr_len + 1,
 172                                 "%s: %s", cid, val);
 173                         assert(ret >= 0 && (size_t)ret <= managedptr_len);
 174                         free(val);
 175                         return managedptr;
 176                 }
 177         }
 178
 179         return "<some complex value>";
 180 }
 181
 182
 183 /*
 184  * Recursively invoke a given function over the given expr and all its
 185  * children.
 186  */
 187 int
 188 asn1f_recurse_expr(arg_t *arg, int (*callback)(arg_t *arg)) {
 189         asn1p_expr_t *expr = arg->expr;
 190         int rvalue = 0;
 191         int ret;
 192
 193         assert(expr);
 194
 195         if(expr->lhs_params && expr->spec_index == -1) {
 196                 int i;
 197                 for(i = 0; i < expr->specializations.pspecs_count; i++) {
 198                         arg->expr = expr->specializations.pspec[i].my_clone;
 199                         ret = asn1f_recurse_expr(arg, callback);
 200                         RET2RVAL(ret, rvalue);
 201                 }
 202                 arg->expr = expr;       /* revert */
 203                 return rvalue;
 204         }
 205
 206         /*
 207          * Invoke the callback at this very level.
 208          */
 209         ret = callback(arg);
 210         RET2RVAL(ret, rvalue);
 211
 212         /*
 213          * Recursively invoke myself
 214          * to iterate over each element in the tree.
 215          */
 216         TQ_FOR(arg->expr, &(expr->members), next) {
 217                 assert(arg->expr->expr_type != A1TC_INVALID);
 218                 assert(arg->expr->parent_expr == expr);
 219                 ret = asn1f_recurse_expr(arg, callback);
 220                 RET2RVAL(ret, rvalue);
 221         }
 222
 223         arg->expr = expr;       /* Restore original position */
 224
 225         return rvalue;
 226 }
 227
 228
 229 /*
 230  * Check that every child of a given expr has unique name or does not have any.
 231  */
 232 int
 233 asn1f_check_unique_expr(arg_t *arg) {
 234         asn1p_expr_t *expr;
 235         int rvalue = 0;
 236
 237         TQ_FOR(expr, &(arg->expr->members), next) {
 238                 if(expr->Identifier) {
 239                         int ret = asn1f_check_unique_expr_child(arg, expr,
 240                                 0, "identifier");
 241                         if(ret) rvalue = -1;
 242                 } else {
 243                         /*
 244                          * No point of comparing this child with any other:
 245                          * this one does not have a name.
 246                          */
 247                 }
 248         }
 249
 250         return rvalue;
 251 }
 252
 253 /*
 254  * Check that every preceeding child of the given expr is not
 255  * having the name of the given one.
 256  */
 257 int
 258 asn1f_check_unique_expr_child(arg_t *arg, asn1p_expr_t *child,
 259                 int (*opt_compare)(asn1p_expr_t *a, asn1p_expr_t *b),
 260                 const char *opt_property_name) {
 261         asn1p_expr_t *expr;
 262
 263         if(!opt_property_name) opt_property_name = "property";
 264
 265         assert(child);
 266         assert(opt_compare || child->Identifier);
 267
 268         TQ_FOR(expr, &(arg->expr->members), next) {
 269                 int ret;
 270
 271                 if(expr == child)
 272                         break;
 273
 274                 /*
 275                  * Compare according to the custom rule or default
 276                  * names comparisons.
 277                  */
 278                 if(opt_compare) {
 279                         ret = opt_compare(expr, child);
 280                 } else {
 281                         if(expr->Identifier == NULL
 282                         || expr->expr_type == A1TC_EXTENSIBLE)
 283                                 continue;
 284                         ret = strcmp(expr->Identifier, child->Identifier);
 285                 }
 286
 287                 if(ret == 0) {
 288                         FATAL("Clash detected: "
 289                                 "\"%s\" at line %d has similar %s with "
 290                                 "\"%s\" at line %d",
 291                                 expr->Identifier,
 292                                 expr->_lineno,
 293                                 opt_property_name,
 294                                 child->Identifier,
 295                                 child->_lineno
 296                         );
 297                         return -1;
 298                 }
 299         }
 300
 301         return 0;
 302 }
 303
 304 int
 305 asn1f_count_children(asn1p_expr_t *expr) {
 306         asn1p_expr_t *child;
 307         int count = 0;
 308
 309         TQ_FOR(child, &(expr->members), next) {
 310                 count++;
 311         }
 312
 313         return count;
 314 }
 315
 316
 317 static char **known_types;
 318 static int known_types_count;
 319 static int known_types_size;
 320
 321 static int _known_types_cmp(const void *ap, const void *bp) {
 322         const char *a = *(const char * const *)ap;
 323         const char *b = *(const char * const *)bp;
 324         return strcmp(a, b);
 325 }
 326
 327 int
 328 asn1f_make_known_external_type(const char *type_name) {
 329         char *tname;
 330
 331         /* Check for duplicates */
 332         if(asn1f_check_known_external_type(type_name) == 0) {
 333                 errno = EEXIST;
 334                 return -1;
 335         }
 336
 337         /* Ensure enough space */
 338         if(known_types_count <= known_types_size) {
 339                 int n = known_types_size ? known_types_size << 1 : 4;
 340                 void *p;
 341                 p = realloc(known_types, n * sizeof(known_types[0]));
 342                 if(!p) return -1;
 343                 known_types = p;
 344                 known_types_size = n;
 345         }
 346
 347         tname = strdup(type_name);
 348         if(!tname) return -1;
 349
 350         known_types[known_types_count++] = tname;
 351
 352 #ifdef  HAVE_MERGESORT
 353         mergesort
 354 #else
 355         qsort
 356 #endif
 357         (known_types, known_types_count, sizeof(known_types[0]),
 358                 _known_types_cmp);
 359
 360         return 0;
 361 }
 362
 363 int
 364 asn1f_check_known_external_type(const char *type_name) {
 365         if(known_types_count) {
 366                 void *p = bsearch(&type_name, known_types, known_types_count,
 367                                 sizeof(known_types[0]), _known_types_cmp);
 368                 if(p) return 0;
 369         }
 370         errno = ESRCH;
 371         return -1;
 372 }
 373