asn1c库编码函数返回的encoded，存在一个小问题

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

asn_enc_rval_t
asn_encode_to_buffer(const asn_codec_ctx_t *opt_codec_ctx,
                     enum asn_transfer_syntax syntax,
                     const asn_TYPE_descriptor_t *td, const void *sptr,
                     void *buffer, size_t buffer_size) {
    struct overrun_encoder_key buf_key;
    asn_enc_rval_t er;

    if(buffer_size > 0 && !buffer) {
        errno = EINVAL;
        ASN__ENCODE_FAILED;
    }

    buf_key.buffer = buffer;
    buf_key.buffer_size = buffer_size;
    buf_key.computed_size = 0;

    er = asn_encode_internal(opt_codec_ctx, syntax, td, sptr,
                             overrun_encoder_cb, &buf_key);

    if(er.encoded >= 0 && (size_t)er.encoded != buf_key.computed_size) {
        ASN_DEBUG("asn_encode() returned %" ASN_PRI_SSIZE
                  " yet produced %" ASN_PRI_SIZE " bytes",
                  er.encoded, buf_key.computed_size);
        assert(er.encoded < 0 || (size_t)er.encoded == buf_key.computed_size);
    }

    return er;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

asn_enc_rval_t
uper_encode_to_buffer(const asn_TYPE_descriptor_t *td,
                      const asn_per_constraints_t *constraints,
                      const void *sptr, void *buffer, size_t buffer_size) {
    enc_to_buf_arg key;

    key.buffer = buffer;
    key.left = buffer_size;

    if(td) ASN_DEBUG("Encoding \"%s\" using UNALIGNED PER", td->name);

    return uper_encode(td, constraints, sptr, encode_to_buffer_cb, &key);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

/*
 * Type of the return value of the encoding functions (der_encode, xer_encode).
 */
typedef struct asn_enc_rval_s {
	/*
	 * Number of bytes encoded.
	 * -1 indicates failure to encode the structure.
	 * In this case, the members below this one are meaningful.
	 */
	ssize_t encoded;

	/*
	 * Members meaningful when (encoded == -1), for post mortem analysis.
	 */

	/* Type which cannot be encoded */
	const struct asn_TYPE_descriptor_s *failed_type;

	/* Pointer to the structure of that type */
	const void *structure_ptr;
} asn_enc_rval_t;

1
2
3
4
5
6

size_t bits_to_flush;

bits_to_flush = ((po.buffer - po.tmpspace) << 3) + po.nboff;

/* Set number of bits encoded to a firm value */
er.encoded = (po.flushed_bytes << 3) + bits_to_flush;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

case ATS_UNALIGNED_BASIC_PER:
    /* CANONICAL-UPER is a superset of BASIC-UPER. */
    /* Fall through. */
case ATS_UNALIGNED_CANONICAL_PER:
    if(td->op->uper_encoder) {
        er = uper_encode(td, 0, sptr, callback, callback_key);
        if(er.encoded == -1) {
            if(er.failed_type && er.failed_type->op->uper_encoder) {
                errno = EBADF;  /* Structure has incorrect form. */
            } else {
                errno = ENOENT; /* UPER is not defined for this type. */
            }
        } else {
            ASN_DEBUG("Complete encoded in %ld bits", (long)er.encoded);
            if(er.encoded == 0) {
                /* Enforce "Complete Encoding" of X.691 #11.1 */
                if(callback("\0", 1, callback_key) < 0) {
                    errno = EBADF;
                    ASN__ENCODE_FAILED;
                }
                er.encoded = 8; /* Exactly 8 zero bits is added. */
            }
            /* Convert bits into bytes */
            er.encoded = (er.encoded + 7) >> 3;
        }