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>
26 static ssize_t der_write_TL(ber_tlv_tag_t tag, ber_tlv_len_t len,
27 asn_app_consume_bytes_f *cb, void *app_key, int constructed);
30 * The DER encoder of any type.
33 der_encode(const asn_TYPE_descriptor_t *type_descriptor, const void *struct_ptr,
34 asn_app_consume_bytes_f *consume_bytes, void *app_key) {
35 ASN_DEBUG("DER encoder invoked for %s",
36 type_descriptor->name);
39 * Invoke type-specific encoder.
41 return type_descriptor->op->der_encoder(
42 type_descriptor, struct_ptr, /* Pointer to the destination structure */
43 0, 0, consume_bytes, app_key);
47 * Argument type and callback necessary for der_encode_to_buffer().
49 typedef struct enc_to_buf_arg {
53 static int encode_to_buffer_cb(const void *buffer, size_t size, void *key) {
54 enc_to_buf_arg *arg = (enc_to_buf_arg *)key;
57 return -1; /* Data exceeds the available buffer size */
59 memcpy(arg->buffer, buffer, size);
60 arg->buffer = ((char *)arg->buffer) + size;
67 * A variant of the der_encode() which encodes the data into the provided buffer
70 der_encode_to_buffer(const asn_TYPE_descriptor_t *type_descriptor,
71 const void *struct_ptr, void *buffer, size_t buffer_size) {
76 arg.left = buffer_size;
78 ec = type_descriptor->op->der_encoder(type_descriptor,
79 struct_ptr, /* Pointer to the destination structure */
80 0, 0, encode_to_buffer_cb, &arg);
81 if(ec.encoded != -1) {
82 assert(ec.encoded == (ssize_t)(buffer_size - arg.left));
83 /* Return the encoded contents size */
90 * Write out leading TL[v] sequence according to the type definition.
93 der_write_tags(const asn_TYPE_descriptor_t *sd, size_t struct_length,
94 int tag_mode, int last_tag_form,
95 ber_tlv_tag_t tag, /* EXPLICIT or IMPLICIT tag */
96 asn_app_consume_bytes_f *cb, void *app_key) {
97 #define ASN1_DER_MAX_TAGS_COUNT 4
99 tags_buf_scratch[ASN1_DER_MAX_TAGS_COUNT * sizeof(ber_tlv_tag_t)];
100 ssize_t lens[ASN1_DER_MAX_TAGS_COUNT * sizeof(ssize_t)];
101 const ber_tlv_tag_t *tags; /* Copy of tags stream */
102 int tags_count; /* Number of tags */
103 size_t overall_length;
106 ASN_DEBUG("Writing tags (%s, tm=%d, tc=%d, tag=%s, mtc=%d)",
107 sd->name, tag_mode, sd->tags_count,
108 ber_tlv_tag_string(tag),
111 -((tag_mode == -1) && sd->tags_count))
115 if(sd->tags_count + 1 > ASN1_DER_MAX_TAGS_COUNT) {
116 ASN_DEBUG("System limit %d on tags count", ASN1_DER_MAX_TAGS_COUNT);
122 * Instead of doing shaman dance like we do in ber_check_tags(),
123 * allocate a small array on the stack
124 * and initialize it appropriately.
127 ber_tlv_tag_t *tags_buf = tags_buf_scratch;
128 tags_count = sd->tags_count
129 + 1 /* EXPLICIT or IMPLICIT tag is given */
130 - ((tag_mode == -1) && sd->tags_count);
133 stag_offset = -1 + ((tag_mode == -1) && sd->tags_count);
134 for(i = 1; i < tags_count; i++)
135 tags_buf[i] = sd->tags[i + stag_offset];
139 tags_count = sd->tags_count;
142 /* No tags to write */
147 * Array of tags is initialized.
148 * Now, compute the size of the TLV pairs, from right to left.
150 overall_length = struct_length;
151 for(i = tags_count - 1; i >= 0; --i) {
152 lens[i] = der_write_TL(tags[i], overall_length, 0, 0, 0);
153 if(lens[i] == -1) return -1;
154 overall_length += lens[i];
155 lens[i] = overall_length - lens[i];
158 if(!cb) return overall_length - struct_length;
160 ASN_DEBUG("Encoding %s TL sequence (%d elements)", sd->name,
164 * Encode the TL sequence for real.
166 for(i = 0; i < tags_count; i++) {
170 /* Check if this tag happens to be constructed */
171 _constr = (last_tag_form || i < (tags_count - 1));
173 len = der_write_TL(tags[i], lens[i], cb, app_key, _constr);
174 if(len == -1) return -1;
177 return overall_length - struct_length;
181 der_write_TL(ber_tlv_tag_t tag, ber_tlv_len_t len,
182 asn_app_consume_bytes_f *cb, void *app_key,
186 int buf_size = cb?sizeof(buf):0;
189 /* Serialize tag (T from TLV) into possibly zero-length buffer */
190 tmp = ber_tlv_tag_serialize(tag, buf, buf_size);
191 if(tmp == -1 || tmp > (ssize_t)sizeof(buf)) return -1;
194 /* Serialize length (L from TLV) into possibly zero-length buffer */
195 tmp = der_tlv_length_serialize(len, buf+size, buf_size?buf_size-size:0);
196 if(tmp == -1) return -1;
199 if(size > sizeof(buf))
203 * If callback is specified, invoke it, and check its return value.
206 if(constructed) *buf |= 0x20;
207 if(cb(buf, size, app_key) < 0)