1 /*****************************************************************************
3 # Copyright 2019 AT&T Intellectual Property *
5 # Licensed under the Apache License, Version 2.0 (the "License"); *
6 # you may not use this file except in compliance with the License. *
7 # You may obtain a copy of the License at *
9 # http://www.apache.org/licenses/LICENSE-2.0 *
11 # Unless required by applicable law or agreed to in writing, software *
12 # distributed under the License is distributed on an "AS IS" BASIS, *
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
14 # See the License for the specific language governing permissions and *
15 # limitations under the License. *
17 ******************************************************************************/
20 * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
21 * Redistribution and modifications are permitted subject to BSD license.
23 #include <asn_internal.h>
25 #include <OBJECT_IDENTIFIER.h>
26 #include <OCTET_STRING.h>
27 #include <limits.h> /* for CHAR_BIT */
31 * OBJECT IDENTIFIER basic type description.
33 static const ber_tlv_tag_t asn_DEF_OBJECT_IDENTIFIER_tags[] = {
34 (ASN_TAG_CLASS_UNIVERSAL | (6 << 2))
36 asn_TYPE_operation_t asn_OP_OBJECT_IDENTIFIER = {
37 ASN__PRIMITIVE_TYPE_free,
38 OBJECT_IDENTIFIER_print,
39 OCTET_STRING_compare, /* Implemented in terms of a string comparison */
42 OBJECT_IDENTIFIER_decode_xer,
43 OBJECT_IDENTIFIER_encode_xer,
44 #ifdef ASN_DISABLE_OER_SUPPORT
48 OBJECT_IDENTIFIER_decode_oer,
49 OBJECT_IDENTIFIER_encode_oer,
50 #endif /* ASN_DISABLE_OER_SUPPORT */
51 #ifdef ASN_DISABLE_PER_SUPPORT
57 OCTET_STRING_decode_uper,
58 OCTET_STRING_encode_uper,
59 OCTET_STRING_decode_aper,
60 OCTET_STRING_encode_aper,
61 #endif /* ASN_DISABLE_PER_SUPPORT */
62 OBJECT_IDENTIFIER_random_fill,
63 0 /* Use generic outmost tag fetcher */
65 asn_TYPE_descriptor_t asn_DEF_OBJECT_IDENTIFIER = {
68 &asn_OP_OBJECT_IDENTIFIER,
69 asn_DEF_OBJECT_IDENTIFIER_tags,
70 sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)
71 / sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]),
72 asn_DEF_OBJECT_IDENTIFIER_tags, /* Same as above */
73 sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)
74 / sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]),
75 { 0, 0, OBJECT_IDENTIFIER_constraint },
76 0, 0, /* No members */
81 OBJECT_IDENTIFIER_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
82 asn_app_constraint_failed_f *ctfailcb,
84 const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
88 ASN__CTFAIL(app_key, td, sptr,
89 "%s: at least one numerical value "
91 td->name, __FILE__, __LINE__);
95 ASN__CTFAIL(app_key, td, sptr,
96 "%s: value not given (%s:%d)",
97 td->name, __FILE__, __LINE__);
105 OBJECT_IDENTIFIER_get_first_arcs(const uint8_t *arcbuf, size_t arcbuf_len,
106 asn_oid_arc_t *arc0, asn_oid_arc_t *arc1) {
109 ssize_t rd = OBJECT_IDENTIFIER_get_single_arc(arcbuf, arcbuf_len, &value);
110 if(rd <= 0) return rd;
115 } else if(value >= 40) {
127 OBJECT_IDENTIFIER_get_single_arc(const uint8_t *arcbuf, size_t arcbuf_len,
128 asn_oid_arc_t *ret_value) {
129 const uint8_t *b = arcbuf;
130 const uint8_t *arcend = arcbuf + arcbuf_len; /* End of arc */
132 if(arcbuf == arcend) {
136 asn_oid_arc_t upper_limit = (ASN_OID_ARC_MAX >> 7);
137 /* When the value reaches "upper_limit", it can take */
138 /* at most one more digit. If it exceeds "upper_limit" */
139 /* but there are more digits - it's an Overflow condition */
140 /* Gather all bits into the accumulator */
141 for(accum = 0; b < arcend; b++) {
142 accum = (accum << 7) | (*b & ~0x80);
143 if((*b & 0x80) == 0) { // no more digits
144 if(accum <= ASN_OID_ARC_MAX) {
146 return 1 + (b - arcbuf);
148 errno = ERANGE; /* Overflow */
151 } else { // to make sure we aren't wrapping around
152 if(accum > upper_limit) {
153 errno = ERANGE; /* Overflow */
165 OBJECT_IDENTIFIER__dump_body(const OBJECT_IDENTIFIER_t *st,
166 asn_app_consume_bytes_f *cb, void *app_key) {
168 asn_oid_arc_t arc0, arc1;
174 rd = OBJECT_IDENTIFIER_get_first_arcs(st->buf, st->size, &arc0, &arc1);
179 ret = snprintf(scratch, sizeof(scratch), "%"PRIu32".%"PRIu32, arc0, arc1);
180 if(ret >= (ssize_t)sizeof(scratch)) {
184 if(cb(scratch, ret, app_key) < 0)
189 rd = OBJECT_IDENTIFIER_get_single_arc(st->buf + off, st->size - off,
198 assert(off <= st->size);
199 ret = snprintf(scratch, sizeof(scratch), ".%" PRIu32, arc);
200 if(ret >= (ssize_t)sizeof(scratch)) {
204 if(cb(scratch, ret, app_key) < 0) return -1;
208 if(off != st->size) {
209 ASN_DEBUG("Could not scan to the end of Object Identifier");
216 static enum xer_pbd_rval
217 OBJECT_IDENTIFIER__xer_body_decode(const asn_TYPE_descriptor_t *td, void *sptr,
218 const void *chunk_buf, size_t chunk_size) {
219 OBJECT_IDENTIFIER_t *st = (OBJECT_IDENTIFIER_t *)sptr;
220 const char *chunk_end = (const char *)chunk_buf + chunk_size;
222 asn_oid_arc_t s_arcs[10];
223 asn_oid_arc_t *arcs = s_arcs;
229 num_arcs = OBJECT_IDENTIFIER_parse_arcs(
230 (const char *)chunk_buf, chunk_size, arcs,
231 sizeof(s_arcs) / sizeof(s_arcs[0]), &endptr);
233 /* Expecting more than zero arcs */
234 return XPBD_BROKEN_ENCODING;
235 } else if(num_arcs == 0) {
236 return XPBD_NOT_BODY_IGNORE;
238 assert(endptr == chunk_end);
240 if((size_t)num_arcs > sizeof(s_arcs)/sizeof(s_arcs[0])) {
241 arcs = (asn_oid_arc_t *)MALLOC(num_arcs * sizeof(asn_oid_arc_t));
242 if(!arcs) return XPBD_SYSTEM_FAILURE;
243 ret = OBJECT_IDENTIFIER_parse_arcs((const char *)chunk_buf, chunk_size,
244 arcs, num_arcs, &endptr);
246 return XPBD_SYSTEM_FAILURE; /* assert?.. */
250 * Convert arcs into BER representation.
252 ret = OBJECT_IDENTIFIER_set_arcs(st, arcs, num_arcs);
253 if(arcs != s_arcs) FREEMEM(arcs);
255 return ret ? XPBD_SYSTEM_FAILURE : XPBD_BODY_CONSUMED;
259 OBJECT_IDENTIFIER_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,
260 const asn_TYPE_descriptor_t *td, void **sptr,
261 const char *opt_mname, const void *buf_ptr,
263 return xer_decode_primitive(opt_codec_ctx, td,
264 sptr, sizeof(OBJECT_IDENTIFIER_t), opt_mname,
265 buf_ptr, size, OBJECT_IDENTIFIER__xer_body_decode);
269 OBJECT_IDENTIFIER_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr,
270 int ilevel, enum xer_encoder_flags_e flags,
271 asn_app_consume_bytes_f *cb, void *app_key) {
272 const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
273 asn_enc_rval_t er = {0,0,0};
278 if(!st || !st->buf) {
282 er.encoded = OBJECT_IDENTIFIER__dump_body(st, cb, app_key);
283 if(er.encoded < 0) ASN__ENCODE_FAILED;
289 OBJECT_IDENTIFIER_print(const asn_TYPE_descriptor_t *td, const void *sptr,
290 int ilevel, asn_app_consume_bytes_f *cb,
292 const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
294 (void)td; /* Unused argument */
295 (void)ilevel; /* Unused argument */
298 return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
301 if(cb("{ ", 2, app_key) < 0)
304 if(OBJECT_IDENTIFIER__dump_body(st, cb, app_key) < 0) {
308 return (cb(" }", 2, app_key) < 0) ? -1 : 0;
312 OBJECT_IDENTIFIER_get_arcs(const OBJECT_IDENTIFIER_t *st, asn_oid_arc_t *arcs,
314 asn_oid_arc_t arc0, arc1;
319 if(!st || !st->buf) {
324 rd = OBJECT_IDENTIFIER_get_first_arcs(st->buf, st->size, &arc0, &arc1);
343 rd = OBJECT_IDENTIFIER_get_single_arc(st->buf + off, st->size - off,
352 if(num_arcs < arc_slots) {
353 arcs[num_arcs] = arc;
359 if(off != st->size) {
368 * Save the single value as an object identifier arc.
371 OBJECT_IDENTIFIER_set_single_arc(uint8_t *arcbuf, size_t arcbuf_len,
372 asn_oid_arc_t value) {
374 * The following conditions must hold:
377 uint8_t scratch[((sizeof(value) * CHAR_BIT + 6) / 7)];
378 uint8_t *scratch_end = &scratch[sizeof(scratch)-1];
383 for(b = scratch_end, mask = 0; ; mask = 0x80, b--) {
384 *b = mask | (value & 0x7f);
391 result_len = (scratch_end - b) + 1;
393 if(result_len > arcbuf_len) {
397 memcpy(arcbuf, b, result_len);
403 OBJECT_IDENTIFIER_set_arcs(OBJECT_IDENTIFIER_t *st, const asn_oid_arc_t *arcs,
413 if(!st || !arcs || arc_slots < 2) {
423 /* 8.19.4: At most 39 subsequent values (including 0) */
427 } else if(arc0 == 2) {
428 if(arc1 > ASN_OID_ARC_MAX - 80) {
432 } else if(arc0 > 2) {
433 /* 8.19.4: Only three values are allocated from the root node */
439 * After above tests it is known that the value of arc0 is completely
440 * trustworthy (0..2). However, the arc1's value is still meaningless.
444 * Roughly estimate the maximum size necessary to encode these arcs.
445 * This estimation implicitly takes in account the following facts,
446 * that cancel each other:
447 * * the first two arcs are encoded in a single value.
448 * * the first value may require more space (+1 byte)
449 * * the value of the first arc which is in range (0..2)
451 size = ((sizeof(asn_oid_arc_t) * CHAR_BIT + 6) / 7) * arc_slots;
452 bp = buf = (uint8_t *)MALLOC(size + 1);
458 wrote = OBJECT_IDENTIFIER_set_single_arc(bp, size, arc0 * 40 + arc1);
463 assert((size_t)wrote <= size);
467 for(i = 2; i < arc_slots; i++) {
468 wrote = OBJECT_IDENTIFIER_set_single_arc(bp, size, arcs[i]);
473 assert((size_t)wrote <= size);
484 st->buf[st->size] = '\0';
491 OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,
492 asn_oid_arc_t *arcs, size_t arcs_count,
493 const char **opt_oid_text_end) {
499 ST_AFTERVALUE, /* Next character ought to be '.' or a space */
500 ST_WAITDIGITS /* Next character is expected to be a digit */
501 } state = ST_LEADSPACE;
503 if(!oid_text || oid_txt_length < -1 || (arcs_count && !arcs)) {
504 if(opt_oid_text_end) *opt_oid_text_end = oid_text;
509 if(oid_txt_length == -1)
510 oid_txt_length = strlen(oid_text);
512 #define _OID_CAPTURE_ARC(oid_text, oid_end) \
514 const char *endp = oid_end; \
515 unsigned long value; \
516 switch(asn_strtoul_lim(oid_text, &endp, &value)) { \
517 case ASN_STRTOX_EXTRA_DATA: \
518 case ASN_STRTOX_OK: \
519 if(value <= ASN_OID_ARC_MAX) { \
520 if(num_arcs < arcs_count) arcs[num_arcs] = value; \
522 oid_text = endp - 1; \
526 case ASN_STRTOX_ERROR_RANGE: \
527 if(opt_oid_text_end) *opt_oid_text_end = oid_text; \
530 case ASN_STRTOX_ERROR_INVAL: \
531 case ASN_STRTOX_EXPECT_MORE: \
532 if(opt_oid_text_end) *opt_oid_text_end = oid_text; \
538 for(oid_end = oid_text + oid_txt_length; oid_text<oid_end; oid_text++) {
540 case 0x09: case 0x0a: case 0x0d: case 0x20: /* whitespace */
546 state = ST_TAILSPACE;
549 break; /* Digits expected after ".", got whitespace */
558 *opt_oid_text_end = oid_text;
559 errno = EINVAL; /* Broken OID */
563 state = ST_WAITDIGITS;
567 case 0x30: case 0x31: case 0x32: case 0x33: case 0x34:
568 case 0x35: case 0x36: case 0x37: case 0x38: case 0x39:
573 *opt_oid_text_end = oid_text;
574 errno = EINVAL; /* "1. 1" => broken OID */
578 _OID_CAPTURE_ARC(oid_text, oid_end);
579 state = ST_AFTERVALUE;
584 /* Unexpected symbols */
585 state = ST_WAITDIGITS;
592 if(opt_oid_text_end) *opt_oid_text_end = oid_text;
594 /* Finalize last arc */
597 return 0; /* No OID found in input data */
599 errno = EINVAL; /* Broken OID */
606 errno = EINVAL; /* Broken OID */
611 * Generate values from the list of interesting values, or just a random
612 * value up to the upper limit.
615 OBJECT_IDENTIFIER__biased_random_arc(asn_oid_arc_t upper_bound) {
616 const asn_oid_arc_t values[] = {0, 1, 127, 128, 129, 254, 255, 256};
619 switch(asn_random_between(0, 2)) {
621 idx = asn_random_between(0, sizeof(values) / sizeof(values[0]) - 1);
622 if(values[idx] < upper_bound) {
627 return asn_random_between(0, upper_bound);
634 asn_random_fill_result_t
635 OBJECT_IDENTIFIER_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
636 const asn_encoding_constraints_t *constraints,
638 asn_random_fill_result_t result_ok = {ARFILL_OK, 1};
639 asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};
640 asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};
641 OBJECT_IDENTIFIER_t *st;
642 asn_oid_arc_t arcs[5];
643 size_t arcs_len = asn_random_between(2, 5);
648 if(max_length < arcs_len) return result_skipped;
653 st = CALLOC(1, sizeof(*st));
656 arcs[0] = asn_random_between(0, 2);
657 arcs[1] = OBJECT_IDENTIFIER__biased_random_arc(
658 arcs[0] <= 1 ? 39 : (ASN_OID_ARC_MAX - 80));
659 for(i = 2; i < arcs_len; i++) {
660 arcs[i] = OBJECT_IDENTIFIER__biased_random_arc(ASN_OID_ARC_MAX);
663 if(OBJECT_IDENTIFIER_set_arcs(st, arcs, arcs_len)) {
665 ASN_STRUCT_FREE(*td, st);
667 return result_failed;
672 result_ok.length = st->size;