1 files changed, 64 insertions, 75 deletions

diff --git a/src/lib/libcrypto/ts/ts.h b/src/lib/libcrypto/ts/ts.h
index 88e0111453..3c5ab727db 100644
--- a/src/lib/libcrypto/ts/ts.h
+++ b/src/lib/libcrypto/ts/ts.h
@@ -10,7 +10,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
@@ -103,11 +103,10 @@ MessageImprint ::= SEQUENCE  {
      hashedMessage                OCTET STRING  }
 */
 
-typedef struct TS_msg_imprint_st
-        {
+typedef struct TS_msg_imprint_st {
         X509_ALGOR *hash_algo;
         ASN1_OCTET_STRING *hashed_msg;
-        } TS_MSG_IMPRINT;
+} TS_MSG_IMPRINT;
 
 /*
 TimeStampReq ::= SEQUENCE  {
@@ -121,15 +120,14 @@ TimeStampReq ::= SEQUENCE  {
    extensions               [0] IMPLICIT Extensions    OPTIONAL  }
 */
 
-typedef struct TS_req_st
-        {
+typedef struct TS_req_st {
         ASN1_INTEGER *version;
         TS_MSG_IMPRINT *msg_imprint;
         ASN1_OBJECT *policy_id;         /* OPTIONAL */
         ASN1_INTEGER *nonce;            /* OPTIONAL */
         ASN1_BOOLEAN cert_req;          /* DEFAULT FALSE */
         STACK_OF(X509_EXTENSION) *extensions;   /* [0] OPTIONAL */
-        } TS_REQ;
+} TS_REQ;
 
 /*
 Accuracy ::= SEQUENCE {
@@ -138,12 +136,11 @@ Accuracy ::= SEQUENCE {
                 micros     [1] INTEGER  (1..999) OPTIONAL  }
 */
 
-typedef struct TS_accuracy_st
-        {
+typedef struct TS_accuracy_st {
         ASN1_INTEGER *seconds;
         ASN1_INTEGER *millis;
         ASN1_INTEGER *micros;
-        } TS_ACCURACY;
+} TS_ACCURACY;
 
 /*
 TSTInfo ::= SEQUENCE  {
@@ -165,8 +162,7 @@ TSTInfo ::= SEQUENCE  {
     extensions                   [1] IMPLICIT Extensions  OPTIONAL   }
 */
 
-typedef struct TS_tst_info_st
-        {
+typedef struct TS_tst_info_st {
         ASN1_INTEGER *version;
         ASN1_OBJECT *policy_id;
         TS_MSG_IMPRINT *msg_imprint;
@@ -177,7 +173,7 @@ typedef struct TS_tst_info_st
         ASN1_INTEGER *nonce;
         GENERAL_NAME *tsa;
         STACK_OF(X509_EXTENSION) *extensions;
-        } TS_TST_INFO;  
+} TS_TST_INFO;
 
 /*
 PKIStatusInfo ::= SEQUENCE {
@@ -212,12 +208,11 @@ PKIFreeText ::= SEQUENCE SIZE (1..MAX) OF UTF8String
 #define TS_INFO_ADD_INFO_NOT_AVAILABLE  17
 #define TS_INFO_SYSTEM_FAILURE          25
 
-typedef struct TS_status_info_st
-        {
+typedef struct TS_status_info_st {
         ASN1_INTEGER *status;
         STACK_OF(ASN1_UTF8STRING) *text;
         ASN1_BIT_STRING *failure_info;
-        } TS_STATUS_INFO;
+} TS_STATUS_INFO;
 
 DECLARE_STACK_OF(ASN1_UTF8STRING)
 DECLARE_ASN1_SET_OF(ASN1_UTF8STRING)
@@ -228,12 +223,11 @@ TimeStampResp ::= SEQUENCE  {
      timeStampToken          TimeStampToken     OPTIONAL }
 */
 
-typedef struct TS_resp_st
-        {
+typedef struct TS_resp_st {
         TS_STATUS_INFO *status_info;
         PKCS7 *token;
         TS_TST_INFO *tst_info;
-        } TS_RESP;
+} TS_RESP;
 
 /* The structure below would belong to the ESS component. */
 
@@ -244,11 +238,10 @@ IssuerSerial ::= SEQUENCE {
         }
 */
 
-typedef struct ESS_issuer_serial
-        {
+typedef struct ESS_issuer_serial {
         STACK_OF(GENERAL_NAME)  *issuer;
         ASN1_INTEGER            *serial;
-        } ESS_ISSUER_SERIAL;
+} ESS_ISSUER_SERIAL;
 
 /*
 ESSCertID ::=  SEQUENCE {
@@ -257,11 +250,10 @@ ESSCertID ::=  SEQUENCE {
 }
 */
 
-typedef struct ESS_cert_id
-        {
+typedef struct ESS_cert_id {
         ASN1_OCTET_STRING *hash;        /* Always SHA-1 digest. */
         ESS_ISSUER_SERIAL *issuer_serial;
-        } ESS_CERT_ID;
+} ESS_CERT_ID;
 
 DECLARE_STACK_OF(ESS_CERT_ID)
 DECLARE_ASN1_SET_OF(ESS_CERT_ID)
@@ -273,11 +265,10 @@ SigningCertificate ::=  SEQUENCE {
 }
 */
 
-typedef struct ESS_signing_cert
-        {
+typedef struct ESS_signing_cert {
         STACK_OF(ESS_CERT_ID) *cert_ids;
         STACK_OF(POLICYINFO) *policy_info;
-        } ESS_SIGNING_CERT;
+} ESS_SIGNING_CERT;
 
 
 TS_REQ  *TS_REQ_new(void);
@@ -296,7 +287,7 @@ TS_MSG_IMPRINT	*TS_MSG_IMPRINT_new(void);
 void            TS_MSG_IMPRINT_free(TS_MSG_IMPRINT *a);
 int             i2d_TS_MSG_IMPRINT(const TS_MSG_IMPRINT *a, unsigned char **pp);
 TS_MSG_IMPRINT  *d2i_TS_MSG_IMPRINT(TS_MSG_IMPRINT **a,
-                                    const unsigned char **pp, long length);
+                    const unsigned char **pp, long length);
 
 TS_MSG_IMPRINT  *TS_MSG_IMPRINT_dup(TS_MSG_IMPRINT *a);
 
@@ -320,15 +311,15 @@ int	i2d_TS_RESP_bio(BIO *fp, TS_RESP *a);
 TS_STATUS_INFO  *TS_STATUS_INFO_new(void);
 void            TS_STATUS_INFO_free(TS_STATUS_INFO *a);
 int             i2d_TS_STATUS_INFO(const TS_STATUS_INFO *a, unsigned char **pp);
-TS_STATUS_INFO  *d2i_TS_STATUS_INFO(TS_STATUS_INFO **a, 
-                                    const unsigned char **pp, long length);
+TS_STATUS_INFO  *d2i_TS_STATUS_INFO(TS_STATUS_INFO **a,
+                    const unsigned char **pp, long length);
 TS_STATUS_INFO  *TS_STATUS_INFO_dup(TS_STATUS_INFO *a);
 
 TS_TST_INFO     *TS_TST_INFO_new(void);
 void            TS_TST_INFO_free(TS_TST_INFO *a);
 int             i2d_TS_TST_INFO(const TS_TST_INFO *a, unsigned char **pp);
 TS_TST_INFO     *d2i_TS_TST_INFO(TS_TST_INFO **a, const unsigned char **pp,
-                                    long length);
+                    long length);
 TS_TST_INFO     *TS_TST_INFO_dup(TS_TST_INFO *a);
 
 TS_TST_INFO     *d2i_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO **a);
@@ -340,30 +331,30 @@ TS_ACCURACY	*TS_ACCURACY_new(void);
 void            TS_ACCURACY_free(TS_ACCURACY *a);
 int             i2d_TS_ACCURACY(const TS_ACCURACY *a, unsigned char **pp);
 TS_ACCURACY     *d2i_TS_ACCURACY(TS_ACCURACY **a, const unsigned char **pp,
-                                    long length);
+                    long length);
 TS_ACCURACY     *TS_ACCURACY_dup(TS_ACCURACY *a);
 
 ESS_ISSUER_SERIAL *ESS_ISSUER_SERIAL_new(void);
 void              ESS_ISSUER_SERIAL_free(ESS_ISSUER_SERIAL *a);
 int               i2d_ESS_ISSUER_SERIAL(const ESS_ISSUER_SERIAL *a,
-                                        unsigned char **pp);
+                    unsigned char **pp);
 ESS_ISSUER_SERIAL *d2i_ESS_ISSUER_SERIAL(ESS_ISSUER_SERIAL **a,
-                                         const unsigned char **pp, long length);
+                    const unsigned char **pp, long length);
 ESS_ISSUER_SERIAL *ESS_ISSUER_SERIAL_dup(ESS_ISSUER_SERIAL *a);
 
 ESS_CERT_ID     *ESS_CERT_ID_new(void);
 void            ESS_CERT_ID_free(ESS_CERT_ID *a);
 int             i2d_ESS_CERT_ID(const ESS_CERT_ID *a, unsigned char **pp);
 ESS_CERT_ID     *d2i_ESS_CERT_ID(ESS_CERT_ID **a, const unsigned char **pp,
-                                 long length);
+                    long length);
 ESS_CERT_ID     *ESS_CERT_ID_dup(ESS_CERT_ID *a);
 
 ESS_SIGNING_CERT *ESS_SIGNING_CERT_new(void);
 void             ESS_SIGNING_CERT_free(ESS_SIGNING_CERT *a);
-int              i2d_ESS_SIGNING_CERT(const ESS_SIGNING_CERT *a, 
-                                      unsigned char **pp);
+int              i2d_ESS_SIGNING_CERT(const ESS_SIGNING_CERT *a,
+                    unsigned char **pp);
 ESS_SIGNING_CERT *d2i_ESS_SIGNING_CERT(ESS_SIGNING_CERT **a,
-                                       const unsigned char **pp, long length);
+                    const unsigned char **pp, long length);
 ESS_SIGNING_CERT *ESS_SIGNING_CERT_dup(ESS_SIGNING_CERT *a);
 
 void ERR_load_TS_strings(void);
@@ -485,19 +476,18 @@ struct TS_resp_ctx;
 typedef ASN1_INTEGER *(*TS_serial_cb)(struct TS_resp_ctx *, void *);
 
 /* This must return the seconds and microseconds since Jan 1, 1970 in
-   the sec and usec variables allocated by the caller. 
+   the sec and usec variables allocated by the caller.
    Return non-zero for success and zero for failure. */
 typedef int (*TS_time_cb)(struct TS_resp_ctx *, void *, long *sec, long *usec);
 
 /* This must process the given extension.
  * It can modify the TS_TST_INFO object of the context.
- * Return values: !0 (processed), 0 (error, it must set the 
+ * Return values: !0 (processed), 0 (error, it must set the
  * status info/failure info of the response).
  */
 typedef int (*TS_extension_cb)(struct TS_resp_ctx *, X509_EXTENSION *, void *);
 
-typedef struct TS_resp_ctx
-        {
+typedef struct TS_resp_ctx {
         X509            *signer_cert;
         EVP_PKEY        *signer_key;
         STACK_OF(X509)  *certs; /* Certs to include in signed data. */
@@ -514,10 +504,10 @@ typedef struct TS_resp_ctx
         /* Callback functions. */
         TS_serial_cb serial_cb;
         void *serial_cb_data;   /* User data for serial_cb. */
-        
+
         TS_time_cb time_cb;
         void *time_cb_data;     /* User data for time_cb. */
-        
+
         TS_extension_cb extension_cb;
         void *extension_cb_data;        /* User data for extension_cb. */
 
@@ -525,7 +515,7 @@ typedef struct TS_resp_ctx
         TS_REQ          *request;
         TS_RESP         *response;
         TS_TST_INFO     *tst_info;
-        } TS_RESP_CTX;
+} TS_RESP_CTX;
 
 DECLARE_STACK_OF(EVP_MD)
 DECLARE_ASN1_SET_OF(EVP_MD)
@@ -546,23 +536,23 @@ int TS_RESP_CTX_set_def_policy(TS_RESP_CTX *ctx, ASN1_OBJECT *def_policy);
 /* No additional certs are included in the response by default. */
 int TS_RESP_CTX_set_certs(TS_RESP_CTX *ctx, STACK_OF(X509) *certs);
 
-/* Adds a new acceptable policy, only the default policy 
+/* Adds a new acceptable policy, only the default policy
    is accepted by default. */
 int TS_RESP_CTX_add_policy(TS_RESP_CTX *ctx, ASN1_OBJECT *policy);
 
-/* Adds a new acceptable message digest. Note that no message digests 
+/* Adds a new acceptable message digest. Note that no message digests
    are accepted by default. The md argument is shared with the caller. */
 int TS_RESP_CTX_add_md(TS_RESP_CTX *ctx, const EVP_MD *md);
 
 /* Accuracy is not included by default. */
 int TS_RESP_CTX_set_accuracy(TS_RESP_CTX *ctx,
-                             int secs, int millis, int micros);
+    int secs, int millis, int micros);
 
-/* Clock precision digits, i.e. the number of decimal digits: 
-   '0' means sec, '3' msec, '6' usec, and so on. Default is 0. */ 
+/* Clock precision digits, i.e. the number of decimal digits:
+   '0' means sec, '3' msec, '6' usec, and so on. Default is 0. */
 int TS_RESP_CTX_set_clock_precision_digits(TS_RESP_CTX *ctx,
-                                           unsigned clock_precision_digits);
-/* At most we accept usec precision. */ 
+    unsigned clock_precision_digits);
+/* At most we accept usec precision. */
 #define TS_MAX_CLOCK_PRECISION_DIGITS   6
 
 /* No flags are set by default. */
@@ -574,19 +564,19 @@ void TS_RESP_CTX_set_serial_cb(TS_RESP_CTX *ctx, TS_serial_cb cb, void *data);
 /* Default callback uses the gettimeofday() and gmtime() system calls. */
 void TS_RESP_CTX_set_time_cb(TS_RESP_CTX *ctx, TS_time_cb cb, void *data);
 
-/* Default callback rejects all extensions. The extension callback is called 
+/* Default callback rejects all extensions. The extension callback is called
  * when the TS_TST_INFO object is already set up and not signed yet. */
 /* FIXME: extension handling is not tested yet. */
-void TS_RESP_CTX_set_extension_cb(TS_RESP_CTX *ctx, 
-                                  TS_extension_cb cb, void *data);
+void TS_RESP_CTX_set_extension_cb(TS_RESP_CTX *ctx,
+    TS_extension_cb cb, void *data);
 
 /* The following methods can be used in the callbacks. */
-int TS_RESP_CTX_set_status_info(TS_RESP_CTX *ctx, 
-                                int status, const char *text);
+int TS_RESP_CTX_set_status_info(TS_RESP_CTX *ctx,
+    int status, const char *text);
 
 /* Sets the status info only if it is still TS_STATUS_GRANTED. */
-int TS_RESP_CTX_set_status_info_cond(TS_RESP_CTX *ctx, 
-                                     int status, const char *text);
+int TS_RESP_CTX_set_status_info_cond(TS_RESP_CTX *ctx,
+    int status, const char *text);
 
 int TS_RESP_CTX_add_failure_info(TS_RESP_CTX *ctx, int failure);
 
@@ -595,7 +585,7 @@ TS_REQ *TS_RESP_CTX_get_request(TS_RESP_CTX *ctx);
 
 TS_TST_INFO *TS_RESP_CTX_get_tst_info(TS_RESP_CTX *ctx);
 
-/* 
+/*
  * Creates the signed TS_TST_INFO and puts it in TS_RESP.
  * In case of errors it sets the status info properly.
  * Returns NULL only in case of memory allocation/fatal error.
@@ -608,7 +598,7 @@ TS_RESP *TS_RESP_create_response(TS_RESP_CTX *ctx, BIO *req_bio);
  */
 
 int TS_RESP_verify_signature(PKCS7 *token, STACK_OF(X509) *certs,
-                             X509_STORE *store, X509 **signer_out);
+    X509_STORE *store, X509 **signer_out);
 
 /* Context structure for the generic verify method. */
 
@@ -648,8 +638,7 @@ int TS_RESP_verify_signature(PKCS7 *token, STACK_OF(X509) *certs,
                                  | TS_VFY_SIGNER        \
                                  | TS_VFY_TSA_NAME)
 
-typedef struct TS_verify_ctx
-        {
+typedef struct TS_verify_ctx {
         /* Set this to the union of TS_VFY_... flags you want to carry out. */
         unsigned        flags;
 
@@ -660,7 +649,7 @@ typedef struct TS_verify_ctx
         /* Must be set only with TS_VFY_POLICY. */
         ASN1_OBJECT     *policy;
 
-        /* Must be set only with TS_VFY_IMPRINT. If md_alg is NULL, 
+        /* Must be set only with TS_VFY_IMPRINT. If md_alg is NULL,
            the algorithm from the response is used. */
         X509_ALGOR      *md_alg;
         unsigned char   *imprint;
@@ -674,7 +663,7 @@ typedef struct TS_verify_ctx
 
         /* Must be set only with TS_VFY_TSA_NAME. */
         GENERAL_NAME    *tsa_name;
-        } TS_VERIFY_CTX;
+} TS_VERIFY_CTX;
 
 int TS_RESP_verify_response(TS_VERIFY_CTX *ctx, TS_RESP *response);
 int TS_RESP_verify_token(TS_VERIFY_CTX *ctx, PKCS7 *token);
@@ -690,7 +679,7 @@ void TS_VERIFY_CTX_init(TS_VERIFY_CTX *ctx);
 void TS_VERIFY_CTX_free(TS_VERIFY_CTX *ctx);
 void TS_VERIFY_CTX_cleanup(TS_VERIFY_CTX *ctx);
 
-/* 
+/*
  * If ctx is NULL, it allocates and returns a new object, otherwise
  * it returns ctx. It initialises all the members as follows:
  * flags = TS_VFY_ALL_IMPRINT & ~(TS_VFY_TSA_NAME | TS_VFY_SIGNATURE)
@@ -730,27 +719,27 @@ STACK_OF(X509) *TS_CONF_load_certs(const char *file);
 EVP_PKEY *TS_CONF_load_key(const char *file, const char *pass);
 const char *TS_CONF_get_tsa_section(CONF *conf, const char *section);
 int TS_CONF_set_serial(CONF *conf, const char *section, TS_serial_cb cb,
-                       TS_RESP_CTX *ctx);
+    TS_RESP_CTX *ctx);
 int TS_CONF_set_crypto_device(CONF *conf, const char *section,
-                              const char *device);
+    const char *device);
 int TS_CONF_set_default_engine(const char *name);
 int TS_CONF_set_signer_cert(CONF *conf, const char *section,
-                            const char *cert, TS_RESP_CTX *ctx);
+    const char *cert, TS_RESP_CTX *ctx);
 int TS_CONF_set_certs(CONF *conf, const char *section, const char *certs,
-                      TS_RESP_CTX *ctx);
+    TS_RESP_CTX *ctx);
 int TS_CONF_set_signer_key(CONF *conf, const char *section,
-                           const char *key, const char *pass, TS_RESP_CTX *ctx);
+    const char *key, const char *pass, TS_RESP_CTX *ctx);
 int TS_CONF_set_def_policy(CONF *conf, const char *section,
-                           const char *policy, TS_RESP_CTX *ctx);
+    const char *policy, TS_RESP_CTX *ctx);
 int TS_CONF_set_policies(CONF *conf, const char *section, TS_RESP_CTX *ctx);
 int TS_CONF_set_digests(CONF *conf, const char *section, TS_RESP_CTX *ctx);
 int TS_CONF_set_accuracy(CONF *conf, const char *section, TS_RESP_CTX *ctx);
 int TS_CONF_set_clock_precision_digits(CONF *conf, const char *section,
-                                       TS_RESP_CTX *ctx);
+    TS_RESP_CTX *ctx);
 int TS_CONF_set_ordering(CONF *conf, const char *section, TS_RESP_CTX *ctx);
 int TS_CONF_set_tsa_name(CONF *conf, const char *section, TS_RESP_CTX *ctx);
 int TS_CONF_set_ess_cert_id_chain(CONF *conf, const char *section,
-                                  TS_RESP_CTX *ctx);
+    TS_RESP_CTX *ctx);
 
 /* -------------------------------------------------- */
 /* BEGIN ERROR CODES */