[thirdparty/openssl.git] / crypto / asn1 / tasn_prn.c

/*
 * Copyright 2000-2016 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include <stddef.h>
#include "internal/cryptlib.h"
#include <openssl/asn1.h>
#include <openssl/asn1t.h>
#include <openssl/objects.h>
#include <openssl/buffer.h>
#include <openssl/err.h>
#include <openssl/x509v3.h>
#include "crypto/asn1.h"
#include "asn1_local.h"

/*
 * Print routines.
 */

/* ASN1_PCTX routines */

static ASN1_PCTX default_pctx = {
    ASN1_PCTX_FLAGS_SHOW_ABSENT, /* flags */
    0,                          /* nm_flags */
    0,                          /* cert_flags */
    0,                          /* oid_flags */
    0                           /* str_flags */
};

ASN1_PCTX *ASN1_PCTX_new(void)
{
    ASN1_PCTX *ret;

    ret = OPENSSL_zalloc(sizeof(*ret));
    if (ret == NULL) {
        ASN1err(ASN1_F_ASN1_PCTX_NEW, ERR_R_MALLOC_FAILURE);
        return NULL;
    }
    return ret;
}

void ASN1_PCTX_free(ASN1_PCTX *p)
{
    OPENSSL_free(p);
}

unsigned long ASN1_PCTX_get_flags(const ASN1_PCTX *p)
{
    return p->flags;
}

void ASN1_PCTX_set_flags(ASN1_PCTX *p, unsigned long flags)
{
    p->flags = flags;
}

unsigned long ASN1_PCTX_get_nm_flags(const ASN1_PCTX *p)
{
    return p->nm_flags;
}

void ASN1_PCTX_set_nm_flags(ASN1_PCTX *p, unsigned long flags)
{
    p->nm_flags = flags;
}

unsigned long ASN1_PCTX_get_cert_flags(const ASN1_PCTX *p)
{
    return p->cert_flags;
}

void ASN1_PCTX_set_cert_flags(ASN1_PCTX *p, unsigned long flags)
{
    p->cert_flags = flags;
}

unsigned long ASN1_PCTX_get_oid_flags(const ASN1_PCTX *p)
{
    return p->oid_flags;
}

void ASN1_PCTX_set_oid_flags(ASN1_PCTX *p, unsigned long flags)
{
    p->oid_flags = flags;
}

unsigned long ASN1_PCTX_get_str_flags(const ASN1_PCTX *p)
{
    return p->str_flags;
}

void ASN1_PCTX_set_str_flags(ASN1_PCTX *p, unsigned long flags)
{
    p->str_flags = flags;
}

/* Main print routines */

static int asn1_item_print_ctx(BIO *out, const ASN1_VALUE **fld, int indent,
                               const ASN1_ITEM *it,
                               const char *fname, const char *sname,
                               int nohdr, const ASN1_PCTX *pctx);

static int asn1_template_print_ctx(BIO *out, const ASN1_VALUE **fld, int indent,
                            const ASN1_TEMPLATE *tt, const ASN1_PCTX *pctx);

static int asn1_primitive_print(BIO *out, const ASN1_VALUE **fld,
                                const ASN1_ITEM *it, int indent,
                                const char *fname, const char *sname,
                                const ASN1_PCTX *pctx);

static int asn1_print_fsname(BIO *out, int indent,
                             const char *fname, const char *sname,
                             const ASN1_PCTX *pctx);

int ASN1_item_print(BIO *out, const ASN1_VALUE *ifld, int indent,
                    const ASN1_ITEM *it, const ASN1_PCTX *pctx)
{
    const char *sname;
    if (pctx == NULL)
        pctx = &default_pctx;
    if (pctx->flags & ASN1_PCTX_FLAGS_NO_STRUCT_NAME)
        sname = NULL;
    else
        sname = it->sname;
    return asn1_item_print_ctx(out, &ifld, indent, it, NULL, sname, 0, pctx);
}

static int asn1_item_print_ctx(BIO *out, const ASN1_VALUE **fld, int indent,
                               const ASN1_ITEM *it,
                               const char *fname, const char *sname,
                               int nohdr, const ASN1_PCTX *pctx)
{
    const ASN1_TEMPLATE *tt;
    const ASN1_EXTERN_FUNCS *ef;
    const ASN1_VALUE **tmpfld;
    const ASN1_AUX *aux = it->funcs;
    ASN1_aux_const_cb *asn1_cb = NULL;
    ASN1_PRINT_ARG parg;
    int i;
    if (aux != NULL) {
        parg.out = out;
        parg.indent = indent;
        parg.pctx = pctx;
        asn1_cb = ((aux->flags & ASN1_AFLG_CONST_CB) != 0) ? aux->asn1_const_cb
            : (ASN1_aux_const_cb *)aux->asn1_cb; /* backward compatibility */
    }

   if (((it->itype != ASN1_ITYPE_PRIMITIVE)
       || (it->utype != V_ASN1_BOOLEAN)) && *fld == NULL) {
        if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_ABSENT) {
            if (!nohdr && !asn1_print_fsname(out, indent, fname, sname, pctx))
                return 0;
            if (BIO_puts(out, "<ABSENT>\n") <= 0)
                return 0;
        }
        return 1;
    }

    switch (it->itype) {
    case ASN1_ITYPE_PRIMITIVE:
        if (it->templates) {
            if (!asn1_template_print_ctx(out, fld, indent,
                                         it->templates, pctx))
                return 0;
            break;
        }
        /* fall through */
    case ASN1_ITYPE_MSTRING:
        if (!asn1_primitive_print(out, fld, it, indent, fname, sname, pctx))
            return 0;
        break;

    case ASN1_ITYPE_EXTERN:
        if (!nohdr && !asn1_print_fsname(out, indent, fname, sname, pctx))
            return 0;
        /* Use new style print routine if possible */
        ef = it->funcs;
        if (ef && ef->asn1_ex_print) {
            i = ef->asn1_ex_print(out, fld, indent, "", pctx);
            if (!i)
                return 0;
            if ((i == 2) && (BIO_puts(out, "\n") <= 0))
                return 0;
            return 1;
        } else if (sname &&
                   BIO_printf(out, ":EXTERNAL TYPE %s\n", sname) <= 0)
            return 0;
        break;

    case ASN1_ITYPE_CHOICE:
        /* CHOICE type, get selector */
        i = asn1_get_choice_selector_const(fld, it);
        /* This should never happen... */
        if ((i < 0) || (i >= it->tcount)) {
            if (BIO_printf(out, "ERROR: selector [%d] invalid\n", i) <= 0)
                return 0;
            return 1;
        }
        tt = it->templates + i;
        tmpfld = asn1_get_const_field_ptr(fld, tt);
        if (!asn1_template_print_ctx(out, tmpfld, indent, tt, pctx))
            return 0;
        break;

    case ASN1_ITYPE_SEQUENCE:
    case ASN1_ITYPE_NDEF_SEQUENCE:
        if (!nohdr && !asn1_print_fsname(out, indent, fname, sname, pctx))
            return 0;
        if (fname || sname) {
            if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_SEQUENCE) {
                if (BIO_puts(out, " {\n") <= 0)
                    return 0;
            } else {
                if (BIO_puts(out, "\n") <= 0)
                    return 0;
            }
        }

        if (asn1_cb) {
            i = asn1_cb(ASN1_OP_PRINT_PRE, fld, it, &parg);
            if (i == 0)
                return 0;
            if (i == 2)
                return 1;
        }

        /* Print each field entry */
        for (i = 0, tt = it->templates; i < it->tcount; i++, tt++) {
            const ASN1_TEMPLATE *seqtt;
            seqtt = asn1_do_adb(*fld, tt, 1);
            if (!seqtt)
                return 0;
            tmpfld = asn1_get_const_field_ptr(fld, seqtt);
            if (!asn1_template_print_ctx(out, tmpfld,
                                         indent + 2, seqtt, pctx))
                return 0;
        }
        if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_SEQUENCE) {
            if (BIO_printf(out, "%*s}\n", indent, "") < 0)
                return 0;
        }

        if (asn1_cb) {
            i = asn1_cb(ASN1_OP_PRINT_POST, fld, it, &parg);
            if (i == 0)
                return 0;
        }
        break;

    default:
        BIO_printf(out, "Unprocessed type %d\n", it->itype);
        return 0;
    }

    return 1;
}

static int asn1_template_print_ctx(BIO *out, const ASN1_VALUE **fld, int indent,
                            const ASN1_TEMPLATE *tt, const ASN1_PCTX *pctx)
{
    int i, flags;
    const char *sname, *fname;
    const ASN1_VALUE *tfld;
    flags = tt->flags;
    if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_FIELD_STRUCT_NAME)
        sname = ASN1_ITEM_ptr(tt->item)->sname;
    else
        sname = NULL;
    if (pctx->flags & ASN1_PCTX_FLAGS_NO_FIELD_NAME)
        fname = NULL;
    else
        fname = tt->field_name;

    /*
     * If field is embedded then fld needs fixing so it is a pointer to
     * a pointer to a field.
     */
    if (flags & ASN1_TFLG_EMBED) {
        tfld = (const ASN1_VALUE *)fld;
        fld = &tfld;
    }

    if (flags & ASN1_TFLG_SK_MASK) {
        char *tname;
        const ASN1_VALUE *skitem;
        STACK_OF(const_ASN1_VALUE) *stack;

        /* SET OF, SEQUENCE OF */
        if (fname) {
            if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_SSOF) {
                if (flags & ASN1_TFLG_SET_OF)
                    tname = "SET";
                else
                    tname = "SEQUENCE";
                if (BIO_printf(out, "%*s%s OF %s {\n",
                               indent, "", tname, tt->field_name) <= 0)
                    return 0;
            } else if (BIO_printf(out, "%*s%s:\n", indent, "", fname) <= 0)
                return 0;
        }
        stack = (STACK_OF(const_ASN1_VALUE) *)*fld;
        for (i = 0; i < sk_const_ASN1_VALUE_num(stack); i++) {
            if ((i > 0) && (BIO_puts(out, "\n") <= 0))
                return 0;

            skitem = sk_const_ASN1_VALUE_value(stack, i);
            if (!asn1_item_print_ctx(out, &skitem, indent + 2,
                                     ASN1_ITEM_ptr(tt->item), NULL, NULL, 1,
                                     pctx))
                return 0;
        }
        if (i == 0 && BIO_printf(out, "%*s<%s>\n", indent + 2, "",
                                 stack == NULL ? "ABSENT" : "EMPTY") <= 0)
            return 0;
        if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_SEQUENCE) {
            if (BIO_printf(out, "%*s}\n", indent, "") <= 0)
                return 0;
        }
        return 1;
    }
    return asn1_item_print_ctx(out, fld, indent, ASN1_ITEM_ptr(tt->item),
                               fname, sname, 0, pctx);
}

static int asn1_print_fsname(BIO *out, int indent,
                             const char *fname, const char *sname,
                             const ASN1_PCTX *pctx)
{
    static const char spaces[] = "                    ";
    static const int nspaces = sizeof(spaces) - 1;

    while (indent > nspaces) {
        if (BIO_write(out, spaces, nspaces) != nspaces)
            return 0;
        indent -= nspaces;
    }
    if (BIO_write(out, spaces, indent) != indent)
        return 0;
    if (pctx->flags & ASN1_PCTX_FLAGS_NO_STRUCT_NAME)
        sname = NULL;
    if (pctx->flags & ASN1_PCTX_FLAGS_NO_FIELD_NAME)
        fname = NULL;
    if (!sname && !fname)
        return 1;
    if (fname) {
        if (BIO_puts(out, fname) <= 0)
            return 0;
    }
    if (sname) {
        if (fname) {
            if (BIO_printf(out, " (%s)", sname) <= 0)
                return 0;
        } else {
            if (BIO_puts(out, sname) <= 0)
                return 0;
        }
    }
    if (BIO_write(out, ": ", 2) != 2)
        return 0;
    return 1;
}

static int asn1_print_boolean(BIO *out, int boolval)
{
    const char *str;
    switch (boolval) {
    case -1:
        str = "BOOL ABSENT";
        break;

    case 0:
        str = "FALSE";
        break;

    default:
        str = "TRUE";
        break;

    }

    if (BIO_puts(out, str) <= 0)
        return 0;
    return 1;

}

static int asn1_print_integer(BIO *out, const ASN1_INTEGER *str)
{
    char *s;
    int ret = 1;
    s = i2s_ASN1_INTEGER(NULL, str);
    if (s == NULL)
        return 0;
    if (BIO_puts(out, s) <= 0)
        ret = 0;
    OPENSSL_free(s);
    return ret;
}

static int asn1_print_oid(BIO *out, const ASN1_OBJECT *oid)
{
    char objbuf[80];
    const char *ln;
    ln = OBJ_nid2ln(OBJ_obj2nid(oid));
    if (!ln)
        ln = "";
    OBJ_obj2txt(objbuf, sizeof(objbuf), oid, 1);
    if (BIO_printf(out, "%s (%s)", ln, objbuf) <= 0)
        return 0;
    return 1;
}

static int asn1_print_obstring(BIO *out, const ASN1_STRING *str, int indent)
{
    if (str->type == V_ASN1_BIT_STRING) {
        if (BIO_printf(out, " (%ld unused bits)\n", str->flags & 0x7) <= 0)
            return 0;
    } else if (BIO_puts(out, "\n") <= 0)
        return 0;
    if ((str->length > 0)
        && BIO_dump_indent(out, (const char *)str->data, str->length,
                           indent + 2) <= 0)
        return 0;
    return 1;
}

static int asn1_primitive_print(BIO *out, const ASN1_VALUE **fld,
                                const ASN1_ITEM *it, int indent,
                                const char *fname, const char *sname,
                                const ASN1_PCTX *pctx)
{
    long utype;
    ASN1_STRING *str;
    int ret = 1, needlf = 1;
    const char *pname;
    const ASN1_PRIMITIVE_FUNCS *pf;
    pf = it->funcs;
    if (!asn1_print_fsname(out, indent, fname, sname, pctx))
        return 0;
    if (pf && pf->prim_print)
        return pf->prim_print(out, fld, it, indent, pctx);
    if (it->itype == ASN1_ITYPE_MSTRING) {
        str = (ASN1_STRING *)*fld;
        utype = str->type & ~V_ASN1_NEG;
    } else {
        utype = it->utype;
        if (utype == V_ASN1_BOOLEAN)
            str = NULL;
        else
            str = (ASN1_STRING *)*fld;
    }
    if (utype == V_ASN1_ANY) {
        const ASN1_TYPE *atype = (const ASN1_TYPE *)*fld;
        utype = atype->type;
        fld = (const ASN1_VALUE **)&atype->value.asn1_value; /* actually is const */
        str = (ASN1_STRING *)*fld;
        if (pctx->flags & ASN1_PCTX_FLAGS_NO_ANY_TYPE)
            pname = NULL;
        else
            pname = ASN1_tag2str(utype);
    } else {
        if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_TYPE)
            pname = ASN1_tag2str(utype);
        else
            pname = NULL;
    }

    if (utype == V_ASN1_NULL) {
        if (BIO_puts(out, "NULL\n") <= 0)
            return 0;
        return 1;
    }

    if (pname) {
        if (BIO_puts(out, pname) <= 0)
            return 0;
        if (BIO_puts(out, ":") <= 0)
            return 0;
    }

    switch (utype) {
    case V_ASN1_BOOLEAN:
        {
            int boolval = *(int *)fld;
            if (boolval == -1)
                boolval = it->size;
            ret = asn1_print_boolean(out, boolval);
        }
        break;

    case V_ASN1_INTEGER:
    case V_ASN1_ENUMERATED:
        ret = asn1_print_integer(out, str);
        break;

    case V_ASN1_UTCTIME:
        ret = ASN1_UTCTIME_print(out, str);
        break;

    case V_ASN1_GENERALIZEDTIME:
        ret = ASN1_GENERALIZEDTIME_print(out, str);
        break;

    case V_ASN1_OBJECT:
        ret = asn1_print_oid(out, (const ASN1_OBJECT *)*fld);
        break;

    case V_ASN1_OCTET_STRING:
    case V_ASN1_BIT_STRING:
        ret = asn1_print_obstring(out, str, indent);
        needlf = 0;
        break;

    case V_ASN1_SEQUENCE:
    case V_ASN1_SET:
    case V_ASN1_OTHER:
        if (BIO_puts(out, "\n") <= 0)
            return 0;
        if (ASN1_parse_dump(out, str->data, str->length, indent, 0) <= 0)
            ret = 0;
        needlf = 0;
        break;

    default:
        ret = ASN1_STRING_print_ex(out, str, pctx->str_flags);

    }
    if (!ret)
        return 0;
    if (needlf && BIO_puts(out, "\n") <= 0)
        return 0;
    return 1;
}
Commit	Line	Data
0f113f3e	1	/*
2039c421	2	* Copyright 2000-2016 The OpenSSL Project Authors. All Rights Reserved.
9d6b1ce6	3	*
365a2d99	4	* Licensed under the Apache License 2.0 (the "License"). You may not use
2039c421 RS	5	* this file except in compliance with the License. You can obtain a copy
	6	* in the file LICENSE in the source distribution or at
	7	* https://www.openssl.org/source/license.html
9d6b1ce6 DSH	8	*/
9d6b1ce6 DSH	9
9d6b1ce6	10	#include <stddef.h>
b39fc560	11	#include "internal/cryptlib.h"
9d6b1ce6	12	#include <openssl/asn1.h>
56defd9a	13	#include <openssl/asn1t.h>
9d6b1ce6 DSH	14	#include <openssl/objects.h>
	15	#include <openssl/buffer.h>
	16	#include <openssl/err.h>
56defd9a	17	#include <openssl/x509v3.h>
25f2138b	18	#include "crypto/asn1.h"
706457b7	19	#include "asn1_local.h"
9d6b1ce6	20
0f113f3e MC	21	/*
0f113f3e MC	22	* Print routines.
9d6b1ce6 DSH	23	*/
9d6b1ce6 DSH	24
56defd9a	25	/* ASN1_PCTX routines */
9d6b1ce6	26
df2ee0e2	27	static ASN1_PCTX default_pctx = {
0f113f3e MC	28	ASN1_PCTX_FLAGS_SHOW_ABSENT, /* flags */
	29	0, /* nm_flags */
	30	0, /* cert_flags */
	31	0, /* oid_flags */
	32	0 /* str_flags */
	33	};
9d6b1ce6	34
56defd9a	35	ASN1_PCTX *ASN1_PCTX_new(void)
0f113f3e MC	36	{
0f113f3e MC	37	ASN1_PCTX *ret;
64b25758 RS	38
64b25758 RS	39	ret = OPENSSL_zalloc(sizeof(*ret));
0f113f3e MC	40	if (ret == NULL) {
	41	ASN1err(ASN1_F_ASN1_PCTX_NEW, ERR_R_MALLOC_FAILURE);
	42	return NULL;
	43	}
0f113f3e MC	44	return ret;
0f113f3e MC	45	}
56defd9a DSH	46
56defd9a DSH	47	void ASN1_PCTX_free(ASN1_PCTX *p)
0f113f3e	48	{
b548a1f1	49	OPENSSL_free(p);
0f113f3e	50	}
56defd9a	51
35da893f	52	unsigned long ASN1_PCTX_get_flags(const ASN1_PCTX *p)
0f113f3e MC	53	{
	54	return p->flags;
	55	}
56defd9a DSH	56
56defd9a DSH	57	void ASN1_PCTX_set_flags(ASN1_PCTX *p, unsigned long flags)
0f113f3e MC	58	{
	59	p->flags = flags;
	60	}
56defd9a	61
35da893f	62	unsigned long ASN1_PCTX_get_nm_flags(const ASN1_PCTX *p)
0f113f3e MC	63	{
	64	return p->nm_flags;
	65	}
56defd9a DSH	66
56defd9a DSH	67	void ASN1_PCTX_set_nm_flags(ASN1_PCTX *p, unsigned long flags)
0f113f3e MC	68	{
	69	p->nm_flags = flags;
	70	}
56defd9a	71
35da893f	72	unsigned long ASN1_PCTX_get_cert_flags(const ASN1_PCTX *p)
0f113f3e MC	73	{
	74	return p->cert_flags;
	75	}
56defd9a DSH	76
56defd9a DSH	77	void ASN1_PCTX_set_cert_flags(ASN1_PCTX *p, unsigned long flags)
0f113f3e MC	78	{
	79	p->cert_flags = flags;
	80	}
56defd9a	81
35da893f	82	unsigned long ASN1_PCTX_get_oid_flags(const ASN1_PCTX *p)
0f113f3e MC	83	{
	84	return p->oid_flags;
	85	}
56defd9a DSH	86
56defd9a DSH	87	void ASN1_PCTX_set_oid_flags(ASN1_PCTX *p, unsigned long flags)
0f113f3e MC	88	{
	89	p->oid_flags = flags;
	90	}
56defd9a	91
35da893f	92	unsigned long ASN1_PCTX_get_str_flags(const ASN1_PCTX *p)
0f113f3e MC	93	{
	94	return p->str_flags;
	95	}
56defd9a DSH	96
56defd9a DSH	97	void ASN1_PCTX_set_str_flags(ASN1_PCTX *p, unsigned long flags)
0f113f3e MC	98	{
	99	p->str_flags = flags;
	100	}
56defd9a DSH	101
	102	/* Main print routines */
	103
9fdcc21f	104	static int asn1_item_print_ctx(BIO out, const ASN1_VALUE *fld, int indent,
0f113f3e MC	105	const ASN1_ITEM *it,
	106	const char fname, const char sname,
	107	int nohdr, const ASN1_PCTX *pctx);
9194296d	108
9fdcc21f	109	static int asn1_template_print_ctx(BIO out, const ASN1_VALUE *fld, int indent,
0f113f3e	110	const ASN1_TEMPLATE tt, const ASN1_PCTX pctx);
9194296d	111
9fdcc21f	112	static int asn1_primitive_print(BIO out, const ASN1_VALUE *fld,
0f113f3e MC	113	const ASN1_ITEM *it, int indent,
	114	const char fname, const char sname,
	115	const ASN1_PCTX *pctx);
9194296d	116
b173acfc	117	static int asn1_print_fsname(BIO *out, int indent,
0f113f3e MC	118	const char fname, const char sname,
0f113f3e MC	119	const ASN1_PCTX *pctx);
56defd9a	120
9fdcc21f	121	int ASN1_item_print(BIO out, const ASN1_VALUE ifld, int indent,
0f113f3e MC	122	const ASN1_ITEM it, const ASN1_PCTX pctx)
	123	{
	124	const char *sname;
	125	if (pctx == NULL)
	126	pctx = &default_pctx;
	127	if (pctx->flags & ASN1_PCTX_FLAGS_NO_STRUCT_NAME)
	128	sname = NULL;
	129	else
	130	sname = it->sname;
	131	return asn1_item_print_ctx(out, &ifld, indent, it, NULL, sname, 0, pctx);
	132	}
56defd9a	133
9fdcc21f	134	static int asn1_item_print_ctx(BIO out, const ASN1_VALUE *fld, int indent,
0f113f3e MC	135	const ASN1_ITEM *it,
	136	const char fname, const char sname,
	137	int nohdr, const ASN1_PCTX *pctx)
	138	{
	139	const ASN1_TEMPLATE *tt;
	140	const ASN1_EXTERN_FUNCS *ef;
9fdcc21f	141	const ASN1_VALUE **tmpfld;
0f113f3e	142	const ASN1_AUX *aux = it->funcs;
9fdcc21f	143	ASN1_aux_const_cb *asn1_cb = NULL;
0f113f3e MC	144	ASN1_PRINT_ARG parg;
0f113f3e MC	145	int i;
9fdcc21f	146	if (aux != NULL) {
0f113f3e MC	147	parg.out = out;
	148	parg.indent = indent;
	149	parg.pctx = pctx;
9fdcc21f DO	150	asn1_cb = ((aux->flags & ASN1_AFLG_CONST_CB) != 0) ? aux->asn1_const_cb
	151	: (ASN1_aux_const_cb )aux->asn1_cb; / backward compatibility */
	152	}
0f113f3e	153
ad72d9fd DSH	154	if (((it->itype != ASN1_ITYPE_PRIMITIVE)
ad72d9fd DSH	155	\|\| (it->utype != V_ASN1_BOOLEAN)) && *fld == NULL) {
0f113f3e MC	156	if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_ABSENT) {
	157	if (!nohdr && !asn1_print_fsname(out, indent, fname, sname, pctx))
	158	return 0;
	159	if (BIO_puts(out, "<ABSENT>\n") <= 0)
	160	return 0;
	161	}
	162	return 1;
	163	}
	164
	165	switch (it->itype) {
	166	case ASN1_ITYPE_PRIMITIVE:
	167	if (it->templates) {
	168	if (!asn1_template_print_ctx(out, fld, indent,
	169	it->templates, pctx))
	170	return 0;
5dc1247a	171	break;
0f113f3e	172	}
f430ba31	173	/* fall through */
0f113f3e MC	174	case ASN1_ITYPE_MSTRING:
	175	if (!asn1_primitive_print(out, fld, it, indent, fname, sname, pctx))
	176	return 0;
	177	break;
	178
	179	case ASN1_ITYPE_EXTERN:
	180	if (!nohdr && !asn1_print_fsname(out, indent, fname, sname, pctx))
	181	return 0;
	182	/* Use new style print routine if possible */
	183	ef = it->funcs;
	184	if (ef && ef->asn1_ex_print) {
	185	i = ef->asn1_ex_print(out, fld, indent, "", pctx);
	186	if (!i)
	187	return 0;
	188	if ((i == 2) && (BIO_puts(out, "\n") <= 0))
	189	return 0;
	190	return 1;
	191	} else if (sname &&
	192	BIO_printf(out, ":EXTERNAL TYPE %s\n", sname) <= 0)
	193	return 0;
	194	break;
	195
	196	case ASN1_ITYPE_CHOICE:
0f113f3e	197	/* CHOICE type, get selector */
9fdcc21f	198	i = asn1_get_choice_selector_const(fld, it);
0f113f3e MC	199	/* This should never happen... */
	200	if ((i < 0) \|\| (i >= it->tcount)) {
	201	if (BIO_printf(out, "ERROR: selector [%d] invalid\n", i) <= 0)
	202	return 0;
	203	return 1;
	204	}
	205	tt = it->templates + i;
9fdcc21f	206	tmpfld = asn1_get_const_field_ptr(fld, tt);
0f113f3e MC	207	if (!asn1_template_print_ctx(out, tmpfld, indent, tt, pctx))
	208	return 0;
	209	break;
	210
	211	case ASN1_ITYPE_SEQUENCE:
	212	case ASN1_ITYPE_NDEF_SEQUENCE:
	213	if (!nohdr && !asn1_print_fsname(out, indent, fname, sname, pctx))
	214	return 0;
	215	if (fname \|\| sname) {
	216	if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_SEQUENCE) {
	217	if (BIO_puts(out, " {\n") <= 0)
	218	return 0;
	219	} else {
	220	if (BIO_puts(out, "\n") <= 0)
	221	return 0;
	222	}
	223	}
	224
	225	if (asn1_cb) {
	226	i = asn1_cb(ASN1_OP_PRINT_PRE, fld, it, &parg);
	227	if (i == 0)
	228	return 0;
	229	if (i == 2)
	230	return 1;
	231	}
	232
	233	/* Print each field entry */
	234	for (i = 0, tt = it->templates; i < it->tcount; i++, tt++) {
	235	const ASN1_TEMPLATE *seqtt;
9fdcc21f	236	seqtt = asn1_do_adb(*fld, tt, 1);
61986d32	237	if (!seqtt)
34a7ed0c	238	return 0;
9fdcc21f	239	tmpfld = asn1_get_const_field_ptr(fld, seqtt);
0f113f3e MC	240	if (!asn1_template_print_ctx(out, tmpfld,
	241	indent + 2, seqtt, pctx))
	242	return 0;
	243	}
	244	if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_SEQUENCE) {
	245	if (BIO_printf(out, "%*s}\n", indent, "") < 0)
	246	return 0;
	247	}
	248
	249	if (asn1_cb) {
	250	i = asn1_cb(ASN1_OP_PRINT_POST, fld, it, &parg);
	251	if (i == 0)
	252	return 0;
	253	}
	254	break;
	255
	256	default:
	257	BIO_printf(out, "Unprocessed type %d\n", it->itype);
	258	return 0;
	259	}
	260
	261	return 1;
	262	}
9d6b1ce6	263
9fdcc21f	264	static int asn1_template_print_ctx(BIO out, const ASN1_VALUE *fld, int indent,
0f113f3e MC	265	const ASN1_TEMPLATE tt, const ASN1_PCTX pctx)
	266	{
	267	int i, flags;
	268	const char sname, fname;
9fdcc21f	269	const ASN1_VALUE *tfld;
0f113f3e MC	270	flags = tt->flags;
	271	if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_FIELD_STRUCT_NAME)
	272	sname = ASN1_ITEM_ptr(tt->item)->sname;
	273	else
	274	sname = NULL;
	275	if (pctx->flags & ASN1_PCTX_FLAGS_NO_FIELD_NAME)
	276	fname = NULL;
	277	else
	278	fname = tt->field_name;
9d103dbb DSH	279
	280	/*
	281	* If field is embedded then fld needs fixing so it is a pointer to
	282	* a pointer to a field.
	283	*/
	284	if (flags & ASN1_TFLG_EMBED) {
9fdcc21f	285	tfld = (const ASN1_VALUE *)fld;
9d103dbb DSH	286	fld = &tfld;
	287	}
	288
0f113f3e MC	289	if (flags & ASN1_TFLG_SK_MASK) {
0f113f3e MC	290	char *tname;
9fdcc21f DO	291	const ASN1_VALUE *skitem;
9fdcc21f DO	292	STACK_OF(const_ASN1_VALUE) *stack;
0f113f3e MC	293
	294	/* SET OF, SEQUENCE OF */
	295	if (fname) {
	296	if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_SSOF) {
	297	if (flags & ASN1_TFLG_SET_OF)
	298	tname = "SET";
	299	else
	300	tname = "SEQUENCE";
	301	if (BIO_printf(out, "%*s%s OF %s {\n",
	302	indent, "", tname, tt->field_name) <= 0)
	303	return 0;
	304	} else if (BIO_printf(out, "%*s%s:\n", indent, "", fname) <= 0)
	305	return 0;
	306	}
9fdcc21f DO	307	stack = (STACK_OF(const_ASN1_VALUE) )fld;
9fdcc21f DO	308	for (i = 0; i < sk_const_ASN1_VALUE_num(stack); i++) {
0f113f3e MC	309	if ((i > 0) && (BIO_puts(out, "\n") <= 0))
	310	return 0;
	311
9fdcc21f	312	skitem = sk_const_ASN1_VALUE_value(stack, i);
0f113f3e MC	313	if (!asn1_item_print_ctx(out, &skitem, indent + 2,
	314	ASN1_ITEM_ptr(tt->item), NULL, NULL, 1,
	315	pctx))
	316	return 0;
	317	}
73a9f60d DSH	318	if (i == 0 && BIO_printf(out, "%*s<%s>\n", indent + 2, "",
73a9f60d DSH	319	stack == NULL ? "ABSENT" : "EMPTY") <= 0)
0f113f3e MC	320	return 0;
	321	if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_SEQUENCE) {
	322	if (BIO_printf(out, "%*s}\n", indent, "") <= 0)
	323	return 0;
	324	}
	325	return 1;
	326	}
	327	return asn1_item_print_ctx(out, fld, indent, ASN1_ITEM_ptr(tt->item),
	328	fname, sname, 0, pctx);
	329	}
56defd9a	330
b173acfc	331	static int asn1_print_fsname(BIO *out, int indent,
0f113f3e MC	332	const char fname, const char sname,
	333	const ASN1_PCTX *pctx)
	334	{
	335	static const char spaces[] = " ";
	336	static const int nspaces = sizeof(spaces) - 1;
b173acfc	337
0f113f3e MC	338	while (indent > nspaces) {
	339	if (BIO_write(out, spaces, nspaces) != nspaces)
	340	return 0;
	341	indent -= nspaces;
	342	}
	343	if (BIO_write(out, spaces, indent) != indent)
	344	return 0;
	345	if (pctx->flags & ASN1_PCTX_FLAGS_NO_STRUCT_NAME)
	346	sname = NULL;
	347	if (pctx->flags & ASN1_PCTX_FLAGS_NO_FIELD_NAME)
	348	fname = NULL;
	349	if (!sname && !fname)
	350	return 1;
	351	if (fname) {
	352	if (BIO_puts(out, fname) <= 0)
	353	return 0;
	354	}
	355	if (sname) {
	356	if (fname) {
	357	if (BIO_printf(out, " (%s)", sname) <= 0)
	358	return 0;
	359	} else {
	360	if (BIO_puts(out, sname) <= 0)
	361	return 0;
	362	}
	363	}
	364	if (BIO_write(out, ": ", 2) != 2)
	365	return 0;
	366	return 1;
	367	}
56defd9a	368
a773b52a	369	static int asn1_print_boolean(BIO *out, int boolval)
0f113f3e MC	370	{
	371	const char *str;
	372	switch (boolval) {
	373	case -1:
	374	str = "BOOL ABSENT";
	375	break;
56defd9a	376
0f113f3e MC	377	case 0:
	378	str = "FALSE";
	379	break;
56defd9a	380
0f113f3e MC	381	default:
	382	str = "TRUE";
	383	break;
56defd9a	384
0f113f3e	385	}
56defd9a	386
0f113f3e MC	387	if (BIO_puts(out, str) <= 0)
	388	return 0;
	389	return 1;
56defd9a	390
0f113f3e	391	}
56defd9a	392
9f5466b9	393	static int asn1_print_integer(BIO out, const ASN1_INTEGER str)
0f113f3e MC	394	{
	395	char *s;
	396	int ret = 1;
	397	s = i2s_ASN1_INTEGER(NULL, str);
5e3553c2 KR	398	if (s == NULL)
5e3553c2 KR	399	return 0;
0f113f3e MC	400	if (BIO_puts(out, s) <= 0)
	401	ret = 0;
	402	OPENSSL_free(s);
	403	return ret;
	404	}
56defd9a	405
a773b52a	406	static int asn1_print_oid(BIO out, const ASN1_OBJECT oid)
0f113f3e MC	407	{
	408	char objbuf[80];
	409	const char *ln;
	410	ln = OBJ_nid2ln(OBJ_obj2nid(oid));
	411	if (!ln)
	412	ln = "";
cbe29648	413	OBJ_obj2txt(objbuf, sizeof(objbuf), oid, 1);
0f113f3e MC	414	if (BIO_printf(out, "%s (%s)", ln, objbuf) <= 0)
	415	return 0;
	416	return 1;
	417	}
56defd9a	418
9f5466b9	419	static int asn1_print_obstring(BIO out, const ASN1_STRING str, int indent)
0f113f3e MC	420	{
	421	if (str->type == V_ASN1_BIT_STRING) {
	422	if (BIO_printf(out, " (%ld unused bits)\n", str->flags & 0x7) <= 0)
	423	return 0;
	424	} else if (BIO_puts(out, "\n") <= 0)
	425	return 0;
	426	if ((str->length > 0)
d3d5dc60	427	&& BIO_dump_indent(out, (const char *)str->data, str->length,
0f113f3e MC	428	indent + 2) <= 0)
	429	return 0;
	430	return 1;
	431	}
56defd9a	432
9fdcc21f	433	static int asn1_primitive_print(BIO out, const ASN1_VALUE *fld,
0f113f3e MC	434	const ASN1_ITEM *it, int indent,
	435	const char fname, const char sname,
	436	const ASN1_PCTX *pctx)
	437	{
	438	long utype;
	439	ASN1_STRING *str;
	440	int ret = 1, needlf = 1;
	441	const char *pname;
	442	const ASN1_PRIMITIVE_FUNCS *pf;
	443	pf = it->funcs;
	444	if (!asn1_print_fsname(out, indent, fname, sname, pctx))
	445	return 0;
	446	if (pf && pf->prim_print)
	447	return pf->prim_print(out, fld, it, indent, pctx);
ad72d9fd DSH	448	if (it->itype == ASN1_ITYPE_MSTRING) {
ad72d9fd DSH	449	str = (ASN1_STRING )fld;
0f113f3e	450	utype = str->type & ~V_ASN1_NEG;
ad72d9fd	451	} else {
0f113f3e	452	utype = it->utype;
ad72d9fd DSH	453	if (utype == V_ASN1_BOOLEAN)
	454	str = NULL;
	455	else
	456	str = (ASN1_STRING )fld;
	457	}
0f113f3e	458	if (utype == V_ASN1_ANY) {
9fdcc21f	459	const ASN1_TYPE atype = (const ASN1_TYPE )*fld;
0f113f3e	460	utype = atype->type;
9fdcc21f	461	fld = (const ASN1_VALUE *)&atype->value.asn1_value; / actually is const */
0f113f3e MC	462	str = (ASN1_STRING )fld;
	463	if (pctx->flags & ASN1_PCTX_FLAGS_NO_ANY_TYPE)
	464	pname = NULL;
	465	else
	466	pname = ASN1_tag2str(utype);
	467	} else {
	468	if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_TYPE)
	469	pname = ASN1_tag2str(utype);
	470	else
	471	pname = NULL;
	472	}
	473
	474	if (utype == V_ASN1_NULL) {
	475	if (BIO_puts(out, "NULL\n") <= 0)
	476	return 0;
	477	return 1;
	478	}
	479
	480	if (pname) {
	481	if (BIO_puts(out, pname) <= 0)
	482	return 0;
	483	if (BIO_puts(out, ":") <= 0)
	484	return 0;
	485	}
	486
	487	switch (utype) {
	488	case V_ASN1_BOOLEAN:
	489	{
	490	int boolval = (int )fld;
	491	if (boolval == -1)
	492	boolval = it->size;
a773b52a	493	ret = asn1_print_boolean(out, boolval);
0f113f3e MC	494	}
	495	break;
	496
	497	case V_ASN1_INTEGER:
	498	case V_ASN1_ENUMERATED:
a773b52a	499	ret = asn1_print_integer(out, str);
0f113f3e MC	500	break;
	501
	502	case V_ASN1_UTCTIME:
	503	ret = ASN1_UTCTIME_print(out, str);
	504	break;
	505
	506	case V_ASN1_GENERALIZEDTIME:
	507	ret = ASN1_GENERALIZEDTIME_print(out, str);
	508	break;
	509
	510	case V_ASN1_OBJECT:
a773b52a	511	ret = asn1_print_oid(out, (const ASN1_OBJECT )fld);
0f113f3e MC	512	break;
	513
	514	case V_ASN1_OCTET_STRING:
	515	case V_ASN1_BIT_STRING:
a773b52a	516	ret = asn1_print_obstring(out, str, indent);
0f113f3e MC	517	needlf = 0;
	518	break;
	519
	520	case V_ASN1_SEQUENCE:
	521	case V_ASN1_SET:
	522	case V_ASN1_OTHER:
	523	if (BIO_puts(out, "\n") <= 0)
	524	return 0;
	525	if (ASN1_parse_dump(out, str->data, str->length, indent, 0) <= 0)
	526	ret = 0;
	527	needlf = 0;
	528	break;
	529
	530	default:
	531	ret = ASN1_STRING_print_ex(out, str, pctx->str_flags);
	532
	533	}
	534	if (!ret)
	535	return 0;
	536	if (needlf && BIO_puts(out, "\n") <= 0)
	537	return 0;
	538	return 1;
	539	}