1 files changed, 96 insertions, 68 deletions

diff --git a/src/lib/libcrypto/ts/ts_asn1.c b/src/lib/libcrypto/ts/ts_asn1.c
index 40b730c5e2..9e16b01f93 100644
--- a/src/lib/libcrypto/ts/ts_asn1.c
+++ b/src/lib/libcrypto/ts/ts_asn1.c
@@ -9,7 +9,7 @@
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer. 
+ *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
@@ -66,27 +66,35 @@ ASN1_SEQUENCE(TS_MSG_IMPRINT) = {
 
 IMPLEMENT_ASN1_FUNCTIONS_const(TS_MSG_IMPRINT)
 IMPLEMENT_ASN1_DUP_FUNCTION(TS_MSG_IMPRINT)
+
 #ifndef OPENSSL_NO_BIO
-TS_MSG_IMPRINT *d2i_TS_MSG_IMPRINT_bio(BIO *bp, TS_MSG_IMPRINT **a)
-        {
-        return ASN1_d2i_bio_of(TS_MSG_IMPRINT, TS_MSG_IMPRINT_new, d2i_TS_MSG_IMPRINT, bp, a);
-        }
+TS_MSG_IMPRINT *
+d2i_TS_MSG_IMPRINT_bio(BIO *bp, TS_MSG_IMPRINT **a)
+{
+        return ASN1_d2i_bio_of(TS_MSG_IMPRINT, TS_MSG_IMPRINT_new,
+            d2i_TS_MSG_IMPRINT, bp, a);
+}
 
-int i2d_TS_MSG_IMPRINT_bio(BIO *bp, TS_MSG_IMPRINT *a)
+int
+i2d_TS_MSG_IMPRINT_bio(BIO *bp, TS_MSG_IMPRINT *a)
 {
         return ASN1_i2d_bio_of_const(TS_MSG_IMPRINT, i2d_TS_MSG_IMPRINT, bp, a);
 }
 #endif
+
 #ifndef OPENSSL_NO_FP_API
-TS_MSG_IMPRINT *d2i_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT **a)
-        {
-        return ASN1_d2i_fp_of(TS_MSG_IMPRINT, TS_MSG_IMPRINT_new, d2i_TS_MSG_IMPRINT, fp, a);
-        }
+TS_MSG_IMPRINT *
+d2i_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT **a)
+{
+        return ASN1_d2i_fp_of(TS_MSG_IMPRINT, TS_MSG_IMPRINT_new,
+            d2i_TS_MSG_IMPRINT, fp, a);
+}
 
-int i2d_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT *a)
-        {
+int
+i2d_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT *a)
+{
         return ASN1_i2d_fp_of_const(TS_MSG_IMPRINT, i2d_TS_MSG_IMPRINT, fp, a);
-        }
+}
 #endif
 
 ASN1_SEQUENCE(TS_REQ) = {
@@ -100,27 +108,33 @@ ASN1_SEQUENCE(TS_REQ) = {
 
 IMPLEMENT_ASN1_FUNCTIONS_const(TS_REQ)
 IMPLEMENT_ASN1_DUP_FUNCTION(TS_REQ)
+
 #ifndef OPENSSL_NO_BIO
-TS_REQ *d2i_TS_REQ_bio(BIO *bp, TS_REQ **a)
-        {
+TS_REQ *
+d2i_TS_REQ_bio(BIO *bp, TS_REQ **a)
+{
         return ASN1_d2i_bio_of(TS_REQ, TS_REQ_new, d2i_TS_REQ, bp, a);
-        }
+}
 
-int i2d_TS_REQ_bio(BIO *bp, TS_REQ *a)
-        {
+int
+i2d_TS_REQ_bio(BIO *bp, TS_REQ *a)
+{
         return ASN1_i2d_bio_of_const(TS_REQ, i2d_TS_REQ, bp, a);
-        }
+}
 #endif
+
 #ifndef OPENSSL_NO_FP_API
-TS_REQ *d2i_TS_REQ_fp(FILE *fp, TS_REQ **a)
-        {
+TS_REQ *
+d2i_TS_REQ_fp(FILE *fp, TS_REQ **a)
+{
         return ASN1_d2i_fp_of(TS_REQ, TS_REQ_new, d2i_TS_REQ, fp, a);
-        }
+}
 
-int i2d_TS_REQ_fp(FILE *fp, TS_REQ *a)
-        {
+int
+i2d_TS_REQ_fp(FILE *fp, TS_REQ *a)
+{
         return ASN1_i2d_fp_of_const(TS_REQ, i2d_TS_REQ, fp, a);
-        }
+}
 #endif
 
 ASN1_SEQUENCE(TS_ACCURACY) = {
@@ -147,27 +161,35 @@ ASN1_SEQUENCE(TS_TST_INFO) = {
 
 IMPLEMENT_ASN1_FUNCTIONS_const(TS_TST_INFO)
 IMPLEMENT_ASN1_DUP_FUNCTION(TS_TST_INFO)
+
 #ifndef OPENSSL_NO_BIO
-TS_TST_INFO *d2i_TS_TST_INFO_bio(BIO *bp, TS_TST_INFO **a)
-        {
-        return ASN1_d2i_bio_of(TS_TST_INFO, TS_TST_INFO_new, d2i_TS_TST_INFO, bp, a);
-        }
+TS_TST_INFO *
+d2i_TS_TST_INFO_bio(BIO *bp, TS_TST_INFO **a)
+{
+        return ASN1_d2i_bio_of(TS_TST_INFO, TS_TST_INFO_new, d2i_TS_TST_INFO,
+            bp, a);
+}
 
-int i2d_TS_TST_INFO_bio(BIO *bp, TS_TST_INFO *a)
-        {
+int
+i2d_TS_TST_INFO_bio(BIO *bp, TS_TST_INFO *a)
+{
         return ASN1_i2d_bio_of_const(TS_TST_INFO, i2d_TS_TST_INFO, bp, a);
-        }
+}
 #endif
+
 #ifndef OPENSSL_NO_FP_API
-TS_TST_INFO *d2i_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO **a)
-        {
-        return ASN1_d2i_fp_of(TS_TST_INFO, TS_TST_INFO_new, d2i_TS_TST_INFO, fp, a);
-        }
+TS_TST_INFO *
+d2i_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO **a)
+{
+        return ASN1_d2i_fp_of(TS_TST_INFO, TS_TST_INFO_new, d2i_TS_TST_INFO,
+            fp, a);
+}
 
-int i2d_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO *a)
-        {
+int
+i2d_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO *a)
+{
         return ASN1_i2d_fp_of_const(TS_TST_INFO, i2d_TS_TST_INFO, fp, a);
-        }
+}
 #endif
 
 ASN1_SEQUENCE(TS_STATUS_INFO) = {
@@ -179,7 +201,8 @@ ASN1_SEQUENCE(TS_STATUS_INFO) = {
 IMPLEMENT_ASN1_FUNCTIONS_const(TS_STATUS_INFO)
 IMPLEMENT_ASN1_DUP_FUNCTION(TS_STATUS_INFO)
 
-static int ts_resp_set_tst_info(TS_RESP *a)
+static int
+ts_resp_set_tst_info(TS_RESP *a)
 {
         long    status;
 
@@ -194,7 +217,8 @@ static int ts_resp_set_tst_info(TS_RESP *a)
                         TS_TST_INFO_free(a->tst_info);
                 a->tst_info = PKCS7_to_TS_TST_INFO(a->token);
                 if (!a->tst_info) {
-                        TSerr(TS_F_TS_RESP_SET_TST_INFO, TS_R_PKCS7_TO_TS_TST_INFO_FAILED);
+                        TSerr(TS_F_TS_RESP_SET_TST_INFO,
+                            TS_R_PKCS7_TO_TS_TST_INFO_FAILED);
                         return 0;
                 }
         } else if (status == 0 || status == 1) {
@@ -205,10 +229,11 @@ static int ts_resp_set_tst_info(TS_RESP *a)
         return 1;
 }
 
-static int ts_resp_cb(int op, ASN1_VALUE **pval, const ASN1_ITEM *it,
-        void *exarg)
+static int
+ts_resp_cb(int op, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg)
 {
         TS_RESP *ts_resp = (TS_RESP *)*pval;
+
         if (op == ASN1_OP_NEW_POST) {
                 ts_resp->tst_info = NULL;
         } else if (op == ASN1_OP_FREE_POST) {
@@ -228,27 +253,33 @@ ASN1_SEQUENCE_cb(TS_RESP, ts_resp_cb) = {
 
 IMPLEMENT_ASN1_FUNCTIONS_const(TS_RESP)
 IMPLEMENT_ASN1_DUP_FUNCTION(TS_RESP)
+
 #ifndef OPENSSL_NO_BIO
-TS_RESP *d2i_TS_RESP_bio(BIO *bp, TS_RESP **a)
-        {
+TS_RESP *
+d2i_TS_RESP_bio(BIO *bp, TS_RESP **a)
+{
         return ASN1_d2i_bio_of(TS_RESP, TS_RESP_new, d2i_TS_RESP, bp, a);
-        }
+}
 
-int i2d_TS_RESP_bio(BIO *bp, TS_RESP *a)
-        {
+int
+i2d_TS_RESP_bio(BIO *bp, TS_RESP *a)
+{
         return ASN1_i2d_bio_of_const(TS_RESP, i2d_TS_RESP, bp, a);
-        }
+}
 #endif
+
 #ifndef OPENSSL_NO_FP_API
-TS_RESP *d2i_TS_RESP_fp(FILE *fp, TS_RESP **a)
-        {
+TS_RESP *
+d2i_TS_RESP_fp(FILE *fp, TS_RESP **a)
+{
         return ASN1_d2i_fp_of(TS_RESP, TS_RESP_new, d2i_TS_RESP, fp, a);
-        }
+}
 
-int i2d_TS_RESP_fp(FILE *fp, TS_RESP *a)
-        {
+int
+i2d_TS_RESP_fp(FILE *fp, TS_RESP *a)
+{
         return ASN1_i2d_fp_of_const(TS_RESP, i2d_TS_RESP, fp, a);
-        }
+}
 #endif
 
 ASN1_SEQUENCE(ESS_ISSUER_SERIAL) = {
@@ -276,7 +307,8 @@ IMPLEMENT_ASN1_FUNCTIONS_const(ESS_SIGNING_CERT)
 IMPLEMENT_ASN1_DUP_FUNCTION(ESS_SIGNING_CERT)
 
 /* Getting encapsulated TS_TST_INFO object from PKCS7. */
-TS_TST_INFO *PKCS7_to_TS_TST_INFO(PKCS7 *token)
+TS_TST_INFO *
+PKCS7_to_TS_TST_INFO(PKCS7 *token)
 {
         PKCS7_SIGNED *pkcs7_signed;
         PKCS7 *enveloped;
@@ -284,35 +316,31 @@ TS_TST_INFO *PKCS7_to_TS_TST_INFO(PKCS7 *token)
         ASN1_OCTET_STRING *tst_info_der;
         const unsigned char *p;
 
-        if (!PKCS7_type_is_signed(token))
-                {
+        if (!PKCS7_type_is_signed(token)) {
                 TSerr(TS_F_PKCS7_TO_TS_TST_INFO, TS_R_BAD_PKCS7_TYPE);
                 return NULL;
-                }
+        }
 
         /* Content must be present. */
-        if (PKCS7_get_detached(token))
-                {
+        if (PKCS7_get_detached(token)) {
                 TSerr(TS_F_PKCS7_TO_TS_TST_INFO, TS_R_DETACHED_CONTENT);
                 return NULL;
-                }
+        }
 
         /* We have a signed data with content. */
         pkcs7_signed = token->d.sign;
         enveloped = pkcs7_signed->contents;
-        if (OBJ_obj2nid(enveloped->type) != NID_id_smime_ct_TSTInfo)
-                {
+        if (OBJ_obj2nid(enveloped->type) != NID_id_smime_ct_TSTInfo) {
                 TSerr(TS_F_PKCS7_TO_TS_TST_INFO, TS_R_BAD_PKCS7_TYPE);
                 return NULL;
-                }
+        }
 
         /* We have a DER encoded TST_INFO as the signed data. */
         tst_info_wrapper = enveloped->d.other;
-        if (tst_info_wrapper->type != V_ASN1_OCTET_STRING)
-                {
+        if (tst_info_wrapper->type != V_ASN1_OCTET_STRING) {
                 TSerr(TS_F_PKCS7_TO_TS_TST_INFO, TS_R_BAD_TYPE);
                 return NULL;
-                }
+        }
 
         /* We have the correct ASN1_OCTET_STRING type. */
         tst_info_der = tst_info_wrapper->value.octet_string;