2 * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
\r
3 * Redistribution and modifications are permitted subject to BSD license.
\r
5 #include <asn_internal.h>
\r
8 static ssize_t der_write_TL(ber_tlv_tag_t tag, ber_tlv_len_t len,
\r
9 asn_app_consume_bytes_f *cb, void *app_key, int constructed);
\r
12 * The DER encoder of any type.
\r
15 der_encode(const asn_TYPE_descriptor_t *type_descriptor, const void *struct_ptr,
\r
16 asn_app_consume_bytes_f *consume_bytes, void *app_key) {
\r
17 ASN_DEBUG("DER encoder invoked for %s",
\r
18 type_descriptor->name);
\r
21 * Invoke type-specific encoder.
\r
23 return type_descriptor->op->der_encoder(
\r
24 type_descriptor, struct_ptr, /* Pointer to the destination structure */
\r
25 0, 0, consume_bytes, app_key);
\r
29 * Argument type and callback necessary for der_encode_to_buffer().
\r
31 typedef struct enc_to_buf_arg {
\r
35 static int encode_to_buffer_cb(const void *buffer, size_t size, void *key) {
\r
36 enc_to_buf_arg *arg = (enc_to_buf_arg *)key;
\r
38 if(arg->left < size)
\r
39 return -1; /* Data exceeds the available buffer size */
\r
41 memcpy(arg->buffer, buffer, size);
\r
42 arg->buffer = ((char *)arg->buffer) + size;
\r
49 * A variant of the der_encode() which encodes the data into the provided buffer
\r
52 der_encode_to_buffer(const asn_TYPE_descriptor_t *type_descriptor,
\r
53 const void *struct_ptr, void *buffer, size_t buffer_size) {
\r
57 arg.buffer = buffer;
\r
58 arg.left = buffer_size;
\r
60 ec = type_descriptor->op->der_encoder(type_descriptor,
\r
61 struct_ptr, /* Pointer to the destination structure */
\r
62 0, 0, encode_to_buffer_cb, &arg);
\r
63 if(ec.encoded != -1) {
\r
64 assert(ec.encoded == (ssize_t)(buffer_size - arg.left));
\r
65 /* Return the encoded contents size */
\r
72 * Write out leading TL[v] sequence according to the type definition.
\r
75 der_write_tags(const asn_TYPE_descriptor_t *sd, size_t struct_length,
\r
76 int tag_mode, int last_tag_form,
\r
77 ber_tlv_tag_t tag, /* EXPLICIT or IMPLICIT tag */
\r
78 asn_app_consume_bytes_f *cb, void *app_key) {
\r
79 #define ASN1_DER_MAX_TAGS_COUNT 4
\r
81 tags_buf_scratch[ASN1_DER_MAX_TAGS_COUNT * sizeof(ber_tlv_tag_t)];
\r
82 ssize_t lens[ASN1_DER_MAX_TAGS_COUNT * sizeof(ssize_t)];
\r
83 const ber_tlv_tag_t *tags; /* Copy of tags stream */
\r
84 int tags_count; /* Number of tags */
\r
85 size_t overall_length;
\r
88 ASN_DEBUG("Writing tags (%s, tm=%d, tc=%d, tag=%s, mtc=%d)",
\r
89 sd->name, tag_mode, sd->tags_count,
\r
90 ber_tlv_tag_string(tag),
\r
93 -((tag_mode == -1) && sd->tags_count))
\r
97 if(sd->tags_count + 1 > ASN1_DER_MAX_TAGS_COUNT) {
\r
98 ASN_DEBUG("System limit %d on tags count", ASN1_DER_MAX_TAGS_COUNT);
\r
104 * Instead of doing shaman dance like we do in ber_check_tags(),
\r
105 * allocate a small array on the stack
\r
106 * and initialize it appropriately.
\r
109 ber_tlv_tag_t *tags_buf = tags_buf_scratch;
\r
110 tags_count = sd->tags_count
\r
111 + 1 /* EXPLICIT or IMPLICIT tag is given */
\r
112 - ((tag_mode == -1) && sd->tags_count);
\r
113 /* Copy tags over */
\r
115 stag_offset = -1 + ((tag_mode == -1) && sd->tags_count);
\r
116 for(i = 1; i < tags_count; i++)
\r
117 tags_buf[i] = sd->tags[i + stag_offset];
\r
121 tags_count = sd->tags_count;
\r
124 /* No tags to write */
\r
125 if(tags_count == 0)
\r
129 * Array of tags is initialized.
\r
130 * Now, compute the size of the TLV pairs, from right to left.
\r
132 overall_length = struct_length;
\r
133 for(i = tags_count - 1; i >= 0; --i) {
\r
134 lens[i] = der_write_TL(tags[i], overall_length, 0, 0, 0);
\r
135 if(lens[i] == -1) return -1;
\r
136 overall_length += lens[i];
\r
137 lens[i] = overall_length - lens[i];
\r
140 if(!cb) return overall_length - struct_length;
\r
142 ASN_DEBUG("Encoding %s TL sequence (%d elements)", sd->name,
\r
146 * Encode the TL sequence for real.
\r
148 for(i = 0; i < tags_count; i++) {
\r
152 /* Check if this tag happens to be constructed */
\r
153 _constr = (last_tag_form || i < (tags_count - 1));
\r
155 len = der_write_TL(tags[i], lens[i], cb, app_key, _constr);
\r
156 if(len == -1) return -1;
\r
159 return overall_length - struct_length;
\r
163 der_write_TL(ber_tlv_tag_t tag, ber_tlv_len_t len,
\r
164 asn_app_consume_bytes_f *cb, void *app_key,
\r
168 int buf_size = cb?sizeof(buf):0;
\r
171 /* Serialize tag (T from TLV) into possibly zero-length buffer */
\r
172 tmp = ber_tlv_tag_serialize(tag, buf, buf_size);
\r
173 if(tmp == -1 || tmp > (ssize_t)sizeof(buf)) return -1;
\r
176 /* Serialize length (L from TLV) into possibly zero-length buffer */
\r
177 tmp = der_tlv_length_serialize(len, buf+size, buf_size?buf_size-size:0);
\r
178 if(tmp == -1) return -1;
\r
181 if(size > sizeof(buf))
\r
185 * If callback is specified, invoke it, and check its return value.
\r
188 if(constructed) *buf |= 0x20;
\r
189 if(cb(buf, size, app_key) < 0)
\r