Rename struct ${app}_config to plain cfg

All the structs are static and we need to reach into them many times.
Having a shorter name is more concise and results in less visual clutter.
It also avoids many overlong lines and we will be able to get rid of some
unfortunate line wrapping down the road.

Discussed with jsing

1 files changed, 351 insertions, 351 deletions

diff --git a/src/usr.bin/openssl/cms.c b/src/usr.bin/openssl/cms.c
index b88fd55b3c..0ddf26e5a7 100644
--- a/src/usr.bin/openssl/cms.c
+++ b/src/usr.bin/openssl/cms.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cms.c,v 1.32 2023/03/05 13:08:22 tb Exp $ */
+/* $OpenBSD: cms.c,v 1.33 2023/03/06 14:32:05 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project.
  */
@@ -149,7 +149,7 @@ static struct {
         char *to;
         int verify_retcode;
         X509_VERIFY_PARAM *vpm;
-} cms_config;
+} cfg;
 
 static const EVP_CIPHER *
 get_cipher_by_name(char *name)
@@ -198,8 +198,8 @@ cms_opt_cipher(int argc, char **argv, int *argsused)
         if (*name++ != '-')
                 return (1);
 
-        if ((cms_config.cipher = get_cipher_by_name(name)) == NULL)
-                if ((cms_config.cipher = EVP_get_cipherbyname(name)) == NULL)
+        if ((cfg.cipher = get_cipher_by_name(name)) == NULL)
+                if ((cfg.cipher = EVP_get_cipherbyname(name)) == NULL)
                         return (1);
 
         *argsused = 1;
@@ -209,9 +209,9 @@ cms_opt_cipher(int argc, char **argv, int *argsused)
 static int
 cms_opt_econtent_type(char *arg)
 {
-        ASN1_OBJECT_free(cms_config.econtent_type);
+        ASN1_OBJECT_free(cfg.econtent_type);
 
-        if ((cms_config.econtent_type = OBJ_txt2obj(arg, 0)) == NULL) {
+        if ((cfg.econtent_type = OBJ_txt2obj(arg, 0)) == NULL) {
                 BIO_printf(bio_err, "Invalid OID %s\n", arg);
                 return (1);
         }
@@ -221,33 +221,33 @@ cms_opt_econtent_type(char *arg)
 static int
 cms_opt_inkey(char *arg)
 {
-        if (cms_config.keyfile == NULL) {
-                cms_config.keyfile = arg;
+        if (cfg.keyfile == NULL) {
+                cfg.keyfile = arg;
                 return (0);
         }
 
-        if (cms_config.signerfile == NULL) {
+        if (cfg.signerfile == NULL) {
                 BIO_puts(bio_err, "Illegal -inkey without -signer\n");
                 return (1);
         }
 
-        if (cms_config.sksigners == NULL)
-                cms_config.sksigners = sk_OPENSSL_STRING_new_null();
-        if (cms_config.sksigners == NULL)
+        if (cfg.sksigners == NULL)
+                cfg.sksigners = sk_OPENSSL_STRING_new_null();
+        if (cfg.sksigners == NULL)
                 return (1);
-        if (!sk_OPENSSL_STRING_push(cms_config.sksigners, cms_config.signerfile))
+        if (!sk_OPENSSL_STRING_push(cfg.sksigners, cfg.signerfile))
                 return (1);
 
-        cms_config.signerfile = NULL;
+        cfg.signerfile = NULL;
 
-        if (cms_config.skkeys == NULL)
-                cms_config.skkeys = sk_OPENSSL_STRING_new_null();
-        if (cms_config.skkeys == NULL)
+        if (cfg.skkeys == NULL)
+                cfg.skkeys = sk_OPENSSL_STRING_new_null();
+        if (cfg.skkeys == NULL)
                 return (1);
-        if (!sk_OPENSSL_STRING_push(cms_config.skkeys, cms_config.keyfile))
+        if (!sk_OPENSSL_STRING_push(cfg.skkeys, cfg.keyfile))
                 return (1);
 
-        cms_config.keyfile = arg;
+        cfg.keyfile = arg;
         return (0);
 }
 
@@ -256,14 +256,14 @@ cms_opt_keyopt(char *arg)
 {
         int keyidx = -1;
 
-        if (cms_config.operation == SMIME_ENCRYPT) {
-                if (cms_config.encerts != NULL)
-                        keyidx += sk_X509_num(cms_config.encerts);
+        if (cfg.operation == SMIME_ENCRYPT) {
+                if (cfg.encerts != NULL)
+                        keyidx += sk_X509_num(cfg.encerts);
         } else {
-                if (cms_config.keyfile != NULL || cms_config.signerfile != NULL)
+                if (cfg.keyfile != NULL || cfg.signerfile != NULL)
                         keyidx++;
-                if (cms_config.skkeys != NULL)
-                        keyidx += sk_OPENSSL_STRING_num(cms_config.skkeys);
+                if (cfg.skkeys != NULL)
+                        keyidx += sk_OPENSSL_STRING_num(cfg.skkeys);
         }
 
         if (keyidx < 0) {
@@ -271,8 +271,8 @@ cms_opt_keyopt(char *arg)
                 return (1);
         }
 
-        if (cms_config.key_param == NULL ||
-            cms_config.key_param->idx != keyidx) {
+        if (cfg.key_param == NULL ||
+            cfg.key_param->idx != keyidx) {
                 struct cms_key_param *nparam;
 
                 if ((nparam = calloc(1, sizeof(struct cms_key_param))) == NULL)
@@ -285,15 +285,15 @@ cms_opt_keyopt(char *arg)
                 }
 
                 nparam->next = NULL;
-                if (cms_config.key_first == NULL)
-                        cms_config.key_first = nparam;
+                if (cfg.key_first == NULL)
+                        cfg.key_first = nparam;
                 else
-                        cms_config.key_param->next = nparam;
+                        cfg.key_param->next = nparam;
 
-                cms_config.key_param = nparam;
+                cfg.key_param = nparam;
         }
 
-        if (!sk_OPENSSL_STRING_push(cms_config.key_param->param, arg))
+        if (!sk_OPENSSL_STRING_push(cfg.key_param->param, arg))
                 return (1);
 
         return (0);
@@ -302,7 +302,7 @@ cms_opt_keyopt(char *arg)
 static int
 cms_opt_md(char *arg)
 {
-        if ((cms_config.sign_md = EVP_get_digestbyname(arg)) == NULL) {
+        if ((cfg.sign_md = EVP_get_digestbyname(arg)) == NULL) {
                 BIO_printf(bio_err, "Unknown digest %s\n", arg);
                 return (1);
         }
@@ -312,38 +312,38 @@ cms_opt_md(char *arg)
 static int
 cms_opt_print(void)
 {
-        cms_config.noout = 1;
-        cms_config.print = 1;
+        cfg.noout = 1;
+        cfg.print = 1;
         return (0);
 }
 
 static int
 cms_opt_pwri_pass(char *arg)
 {
-        cms_config.pwri_pass = (unsigned char *)arg;
+        cfg.pwri_pass = (unsigned char *)arg;
         return (0);
 }
 
 static int
 cms_opt_recip(char *arg)
 {
-        if (cms_config.operation == SMIME_ENCRYPT) {
-                if (cms_config.encerts == NULL) {
-                        if ((cms_config.encerts = sk_X509_new_null()) == NULL)
+        if (cfg.operation == SMIME_ENCRYPT) {
+                if (cfg.encerts == NULL) {
+                        if ((cfg.encerts = sk_X509_new_null()) == NULL)
                                 return (1);
                 }
 
-                cms_config.cert = load_cert(bio_err, arg, FORMAT_PEM,
+                cfg.cert = load_cert(bio_err, arg, FORMAT_PEM,
                     NULL, "recipient certificate file");
-                if (cms_config.cert == NULL)
+                if (cfg.cert == NULL)
                         return (1);
 
-                if (!sk_X509_push(cms_config.encerts, cms_config.cert))
+                if (!sk_X509_push(cfg.encerts, cfg.cert))
                         return (1);
 
-                cms_config.cert = NULL;
+                cfg.cert = NULL;
         } else {
-                cms_config.recipfile = arg;
+                cfg.recipfile = arg;
         }
         return (0);
 }
@@ -351,11 +351,11 @@ cms_opt_recip(char *arg)
 static int
 cms_opt_receipt_request_from(char *arg)
 {
-        if (cms_config.rr_from == NULL)
-                cms_config.rr_from = sk_OPENSSL_STRING_new_null();
-        if (cms_config.rr_from == NULL)
+        if (cfg.rr_from == NULL)
+                cfg.rr_from = sk_OPENSSL_STRING_new_null();
+        if (cfg.rr_from == NULL)
                 return (1);
-        if (!sk_OPENSSL_STRING_push(cms_config.rr_from, arg))
+        if (!sk_OPENSSL_STRING_push(cfg.rr_from, arg))
                 return (1);
 
         return (0);
@@ -364,11 +364,11 @@ cms_opt_receipt_request_from(char *arg)
 static int
 cms_opt_receipt_request_to(char *arg)
 {
-        if (cms_config.rr_to == NULL)
-                cms_config.rr_to = sk_OPENSSL_STRING_new_null();
-        if (cms_config.rr_to == NULL)
+        if (cfg.rr_to == NULL)
+                cfg.rr_to = sk_OPENSSL_STRING_new_null();
+        if (cfg.rr_to == NULL)
                 return (1);
-        if (!sk_OPENSSL_STRING_push(cms_config.rr_to, arg))
+        if (!sk_OPENSSL_STRING_push(cfg.rr_to, arg))
                 return (1);
 
         return (0);
@@ -379,13 +379,13 @@ cms_opt_secretkey(char *arg)
 {
         long ltmp;
 
-        free(cms_config.secret_key);
+        free(cfg.secret_key);
 
-        if ((cms_config.secret_key = string_to_hex(arg, &ltmp)) == NULL) {
+        if ((cfg.secret_key = string_to_hex(arg, &ltmp)) == NULL) {
                 BIO_printf(bio_err, "Invalid key %s\n", arg);
                 return (1);
         }
-        cms_config.secret_keylen = (size_t)ltmp;
+        cfg.secret_keylen = (size_t)ltmp;
         return (0);
 }
 
@@ -394,44 +394,44 @@ cms_opt_secretkeyid(char *arg)
 {
         long ltmp;
 
-        free(cms_config.secret_keyid);
+        free(cfg.secret_keyid);
 
-        if ((cms_config.secret_keyid = string_to_hex(arg, &ltmp)) == NULL) {
+        if ((cfg.secret_keyid = string_to_hex(arg, &ltmp)) == NULL) {
                 BIO_printf(bio_err, "Invalid id %s\n", arg);
                 return (1);
         }
-        cms_config.secret_keyidlen = (size_t)ltmp;
+        cfg.secret_keyidlen = (size_t)ltmp;
         return (0);
 }
 
 static int
 cms_opt_signer(char *arg)
 {
-        if (cms_config.signerfile == NULL) {
-                cms_config.signerfile = arg;
+        if (cfg.signerfile == NULL) {
+                cfg.signerfile = arg;
                 return (0);
         }
 
-        if (cms_config.sksigners == NULL)
-                cms_config.sksigners = sk_OPENSSL_STRING_new_null();
-        if (cms_config.sksigners == NULL)
+        if (cfg.sksigners == NULL)
+                cfg.sksigners = sk_OPENSSL_STRING_new_null();
+        if (cfg.sksigners == NULL)
                 return (1);
-        if (!sk_OPENSSL_STRING_push(cms_config.sksigners, cms_config.signerfile))
+        if (!sk_OPENSSL_STRING_push(cfg.sksigners, cfg.signerfile))
                 return (1);
 
-        if (cms_config.keyfile == NULL)
-                cms_config.keyfile = cms_config.signerfile;
+        if (cfg.keyfile == NULL)
+                cfg.keyfile = cfg.signerfile;
 
-        if (cms_config.skkeys == NULL)
-                cms_config.skkeys = sk_OPENSSL_STRING_new_null();
-        if (cms_config.skkeys == NULL)
+        if (cfg.skkeys == NULL)
+                cfg.skkeys = sk_OPENSSL_STRING_new_null();
+        if (cfg.skkeys == NULL)
                 return (1);
-        if (!sk_OPENSSL_STRING_push(cms_config.skkeys, cms_config.keyfile))
+        if (!sk_OPENSSL_STRING_push(cfg.skkeys, cfg.keyfile))
                 return (1);
 
-        cms_config.keyfile = NULL;
+        cfg.keyfile = NULL;
 
-        cms_config.signerfile = arg;
+        cfg.signerfile = arg;
         return (0);
 }
 
@@ -441,7 +441,7 @@ cms_opt_verify_param(int argc, char **argv, int *argsused)
         int oargc = argc;
         int badarg = 0;
 
-        if (!args_verify(&argv, &argc, &badarg, bio_err, &cms_config.vpm))
+        if (!args_verify(&argv, &argc, &badarg, bio_err, &cfg.vpm))
                 return (1);
         if (badarg)
                 return (1);
@@ -454,8 +454,8 @@ cms_opt_verify_param(int argc, char **argv, int *argsused)
 static int
 cms_opt_verify_receipt(char *arg)
 {
-        cms_config.operation = SMIME_VERIFY_RECEIPT;
-        cms_config.rctfile = arg;
+        cfg.operation = SMIME_VERIFY_RECEIPT;
+        cfg.rctfile = arg;
         return (0);
 }
 
@@ -539,20 +539,20 @@ static const struct option cms_options[] = {
                 .argname = "file",
                 .desc = "Certificate Authority file",
                 .type = OPTION_ARG,
-                .opt.arg = &cms_config.CAfile,
+                .opt.arg = &cfg.CAfile,
         },
         {
                 .name = "CApath",
                 .argname = "path",
                 .desc = "Certificate Authority path",
                 .type = OPTION_ARG,
-                .opt.arg = &cms_config.CApath,
+                .opt.arg = &cfg.CApath,
         },
         {
                 .name = "binary",
                 .desc = "Do not translate message to text",
                 .type = OPTION_VALUE_OR,
-                .opt.value = &cms_config.flags,
+                .opt.value = &cfg.flags,
                 .value = CMS_BINARY,
         },
         {
@@ -560,27 +560,27 @@ static const struct option cms_options[] = {
                 .argname = "file",
                 .desc = "Other certificates file",
                 .type = OPTION_ARG,
-                .opt.arg = &cms_config.certfile,
+                .opt.arg = &cfg.certfile,
         },
         {
                 .name = "certsout",
                 .argname = "file",
                 .desc = "Certificate output file",
                 .type = OPTION_ARG,
-                .opt.arg = &cms_config.certsoutfile,
+                .opt.arg = &cfg.certsoutfile,
         },
         {
                 .name = "cmsout",
                 .desc = "Output CMS structure",
                 .type = OPTION_VALUE,
-                .opt.value = &cms_config.operation,
+                .opt.value = &cfg.operation,
                 .value = SMIME_CMSOUT,
         },
         {
                 .name = "compress",
                 .desc = "Create CMS CompressedData type",
                 .type = OPTION_VALUE,
-                .opt.value = &cms_config.operation,
+                .opt.value = &cfg.operation,
                 .value = SMIME_COMPRESS,
         },
         {
@@ -588,55 +588,55 @@ static const struct option cms_options[] = {
                 .argname = "file",
                 .desc = "Supply or override content for detached signature",
                 .type = OPTION_ARG,
-                .opt.arg = &cms_config.contfile,
+                .opt.arg = &cfg.contfile,
         },
         {
                 .name = "crlfeol",
                 .desc = "Use CRLF as EOL termination instead of CR only",
                 .type = OPTION_VALUE_OR,
-                .opt.value = &cms_config.flags,
+                .opt.value = &cfg.flags,
                 .value = CMS_CRLFEOL,
         },
         {
                 .name = "data_create",
                 .desc = "Create CMS Data type",
                 .type = OPTION_VALUE,
-                .opt.value = &cms_config.operation,
+                .opt.value = &cfg.operation,
                 .value = SMIME_DATA_CREATE,
         },
         {
                 .name = "data_out",
                 .desc = "Output content from the input CMS Data type",
                 .type = OPTION_VALUE,
-                .opt.value = &cms_config.operation,
+                .opt.value = &cfg.operation,
                 .value = SMIME_DATAOUT,
         },
         {
                 .name = "debug_decrypt",
                 .desc = "Set the CMS_DEBUG_DECRYPT flag when decrypting",
                 .type = OPTION_VALUE_OR,
-                .opt.value = &cms_config.flags,
+                .opt.value = &cfg.flags,
                 .value = CMS_DEBUG_DECRYPT,
         },
         {
                 .name = "decrypt",
                 .desc = "Decrypt encrypted message",
                 .type = OPTION_VALUE,
-                .opt.value = &cms_config.operation,
+                .opt.value = &cfg.operation,
                 .value = SMIME_DECRYPT,
         },
         {
                 .name = "digest_create",
                 .desc = "Create CMS DigestedData type",
                 .type = OPTION_VALUE,
-                .opt.value = &cms_config.operation,
+                .opt.value = &cfg.operation,
                 .value = SMIME_DIGEST_CREATE,
         },
         {
                 .name = "digest_verify",
                 .desc = "Verify CMS DigestedData type and output the content",
                 .type = OPTION_VALUE,
-                .opt.value = &cms_config.operation,
+                .opt.value = &cfg.operation,
                 .value = SMIME_DIGEST_VERIFY,
         },
         {
@@ -650,21 +650,21 @@ static const struct option cms_options[] = {
                 .name = "encrypt",
                 .desc = "Encrypt message",
                 .type = OPTION_VALUE,
-                .opt.value = &cms_config.operation,
+                .opt.value = &cfg.operation,
                 .value = SMIME_ENCRYPT,
         },
         {
                 .name = "EncryptedData_decrypt",
                 .desc = "Decrypt CMS EncryptedData",
                 .type = OPTION_VALUE,
-                .opt.value = &cms_config.operation,
+                .opt.value = &cfg.operation,
                 .value = SMIME_ENCRYPTED_DECRYPT,
         },
         {
                 .name = "EncryptedData_encrypt",
                 .desc = "Encrypt content using supplied symmetric key and algorithm",
                 .type = OPTION_VALUE,
-                .opt.value = &cms_config.operation,
+                .opt.value = &cfg.operation,
                 .value = SMIME_ENCRYPTED_ENCRYPT,
         },
         {
@@ -672,20 +672,20 @@ static const struct option cms_options[] = {
                 .argname = "addr",
                 .desc = "From address",
                 .type = OPTION_ARG,
-                .opt.arg = &cms_config.from,
+                .opt.arg = &cfg.from,
         },
         {
                 .name = "in",
                 .argname = "file",
                 .desc = "Input file",
                 .type = OPTION_ARG,
-                .opt.arg = &cms_config.infile,
+                .opt.arg = &cfg.infile,
         },
         {
                 .name = "indef",
                 .desc = "Same as -stream",
                 .type = OPTION_VALUE_OR,
-                .opt.value = &cms_config.flags,
+                .opt.value = &cfg.flags,
                 .value = CMS_STREAM,
         },
         {
@@ -693,7 +693,7 @@ static const struct option cms_options[] = {
                 .argname = "fmt",
                 .desc = "Input format (DER, PEM or SMIME (default))",
                 .type = OPTION_ARG_FORMAT,
-                .opt.value = &cms_config.informat,
+                .opt.value = &cfg.informat,
         },
         {
                 .name = "inkey",
@@ -707,13 +707,13 @@ static const struct option cms_options[] = {
                 .argname = "fmt",
                 .desc = "Input key format (DER or PEM (default))",
                 .type = OPTION_ARG_FORMAT,
-                .opt.value = &cms_config.keyform,
+                .opt.value = &cfg.keyform,
         },
         {
                 .name = "keyid",
                 .desc = "Use subject key identifier",
                 .type = OPTION_VALUE_OR,
-                .opt.value = &cms_config.flags,
+                .opt.value = &cfg.flags,
                 .value = CMS_USE_KEYID,
         },
         {
@@ -734,90 +734,90 @@ static const struct option cms_options[] = {
                 .name = "no_attr_verify",
                 .desc = "Do not verify the signer's attribute of a signature",
                 .type = OPTION_VALUE_OR,
-                .opt.value = &cms_config.flags,
+                .opt.value = &cfg.flags,
                 .value = CMS_NO_ATTR_VERIFY,
         },
         {
                 .name = "no_content_verify",
                 .desc = "Do not verify the content of a signed message",
                 .type = OPTION_VALUE_OR,
-                .opt.value = &cms_config.flags,
+                .opt.value = &cfg.flags,
                 .value = CMS_NO_CONTENT_VERIFY,
         },
         {
                 .name = "no_signer_cert_verify",
                 .desc = "Do not verify the signer's certificate",
                 .type = OPTION_VALUE_OR,
-                .opt.value = &cms_config.flags,
+                .opt.value = &cfg.flags,
                 .value = CMS_NO_SIGNER_CERT_VERIFY,
         },
         {
                 .name = "noattr",
                 .desc = "Do not include any signed attributes",
                 .type = OPTION_VALUE_OR,
-                .opt.value = &cms_config.flags,
+                .opt.value = &cfg.flags,
                 .value = CMS_NOATTR,
         },
         {
                 .name = "nocerts",
                 .desc = "Do not include signer's certificate when signing",
                 .type = OPTION_VALUE_OR,
-                .opt.value = &cms_config.flags,
+                .opt.value = &cfg.flags,
                 .value = CMS_NOCERTS,
         },
         {
                 .name = "nodetach",
                 .desc = "Use opaque signing",
                 .type = OPTION_VALUE_AND,
-                .opt.value = &cms_config.flags,
+                .opt.value = &cfg.flags,
                 .value = ~CMS_DETACHED,
         },
         {
                 .name = "noindef",
                 .desc = "Disable CMS streaming",
                 .type = OPTION_VALUE_AND,
-                .opt.value = &cms_config.flags,
+                .opt.value = &cfg.flags,
                 .value = ~CMS_STREAM,
         },
         {
                 .name = "nointern",
                 .desc = "Do not search certificates in message for signer",
                 .type = OPTION_VALUE_OR,
-                .opt.value = &cms_config.flags,
+                .opt.value = &cfg.flags,
                 .value = CMS_NOINTERN,
         },
         {
                 .name = "nooldmime",
                 .desc = "Output old S/MIME content type",
                 .type = OPTION_VALUE_OR,
-                .opt.value = &cms_config.flags,
+                .opt.value = &cfg.flags,
                 .value = CMS_NOOLDMIMETYPE,
         },
         {
                 .name = "noout",
                 .desc = "Do not output the parsed CMS structure",
                 .type = OPTION_FLAG,
-                .opt.flag = &cms_config.noout,
+                .opt.flag = &cfg.noout,
         },
         {
                 .name = "nosigs",
                 .desc = "Do not verify message signature",
                 .type = OPTION_VALUE_OR,
-                .opt.value = &cms_config.flags,
+                .opt.value = &cfg.flags,
                 .value = CMS_NOSIGS,
         },
         {
                 .name = "nosmimecap",
                 .desc = "Omit the SMIMECapabilities attribute",
                 .type = OPTION_VALUE_OR,
-                .opt.value = &cms_config.flags,
+                .opt.value = &cfg.flags,
                 .value = CMS_NOSMIMECAP,
         },
         {
                 .name = "noverify",
                 .desc = "Do not verify signer's certificate",
                 .type = OPTION_VALUE_OR,
-                .opt.value = &cms_config.flags,
+                .opt.value = &cfg.flags,
                 .value = CMS_NO_SIGNER_CERT_VERIFY,
         },
         {
@@ -825,21 +825,21 @@ static const struct option cms_options[] = {
                 .argname = "file",
                 .desc = "Output file",
                 .type = OPTION_ARG,
-                .opt.arg = &cms_config.outfile,
+                .opt.arg = &cfg.outfile,
         },
         {
                 .name = "outform",
                 .argname = "fmt",
                 .desc = "Output format (DER, PEM or SMIME (default))",
                 .type = OPTION_ARG_FORMAT,
-                .opt.value = &cms_config.outformat,
+                .opt.value = &cfg.outformat,
         },
         {
                 .name = "passin",
                 .argname = "src",
                 .desc = "Private key password source",
                 .type = OPTION_ARG,
-                .opt.arg = &cms_config.passargin,
+                .opt.arg = &cfg.passargin,
         },
         {
                 .name = "print",
@@ -859,20 +859,20 @@ static const struct option cms_options[] = {
                 .argname = "fmt",
                 .desc = "Receipt file format (DER, PEM or SMIME (default))",
                 .type = OPTION_ARG_FORMAT,
-                .opt.value = &cms_config.rctformat,
+                .opt.value = &cfg.rctformat,
         },
         {
                 .name = "receipt_request_all",
                 .desc = "Indicate requests should be provided by all recipients",
                 .type = OPTION_VALUE,
-                .opt.value = &cms_config.rr_allorfirst,
+                .opt.value = &cfg.rr_allorfirst,
                 .value = 0,
         },
         {
                 .name = "receipt_request_first",
                 .desc = "Indicate requests should be provided by first tier recipient",
                 .type = OPTION_VALUE,
-                .opt.value = &cms_config.rr_allorfirst,
+                .opt.value = &cfg.rr_allorfirst,
                 .value = 1,
         },
         {
@@ -886,7 +886,7 @@ static const struct option cms_options[] = {
                 .name = "receipt_request_print",
                 .desc = "Print out the contents of any signed receipt requests",
                 .type = OPTION_FLAG,
-                .opt.flag = &cms_config.rr_print,
+                .opt.flag = &cfg.rr_print,
         },
         {
                 .name = "receipt_request_to",
@@ -906,7 +906,7 @@ static const struct option cms_options[] = {
                 .name = "resign",
                 .desc = "Resign a signed message",
                 .type = OPTION_VALUE,
-                .opt.value = &cms_config.operation,
+                .opt.value = &cfg.operation,
                 .value = SMIME_RESIGN,
         },
         {
@@ -927,14 +927,14 @@ static const struct option cms_options[] = {
                 .name = "sign",
                 .desc = "Sign message",
                 .type = OPTION_VALUE,
-                .opt.value = &cms_config.operation,
+                .opt.value = &cfg.operation,
                 .value = SMIME_SIGN,
         },
         {
                 .name = "sign_receipt",
                 .desc = "Generate a signed receipt for the message",
                 .type = OPTION_VALUE,
-                .opt.value = &cms_config.operation,
+                .opt.value = &cfg.operation,
                 .value = SMIME_SIGN_RECEIPT,
         },
         {
@@ -948,7 +948,7 @@ static const struct option cms_options[] = {
                 .name = "stream",
                 .desc = "Enable CMS streaming",
                 .type = OPTION_VALUE_OR,
-                .opt.value = &cms_config.flags,
+                .opt.value = &cfg.flags,
                 .value = CMS_STREAM,
         },
         {
@@ -956,13 +956,13 @@ static const struct option cms_options[] = {
                 .argname = "s",
                 .desc = "Subject",
                 .type = OPTION_ARG,
-                .opt.arg = &cms_config.subject,
+                .opt.arg = &cfg.subject,
         },
         {
                 .name = "text",
                 .desc = "Include or delete text MIME headers",
                 .type = OPTION_VALUE_OR,
-                .opt.value = &cms_config.flags,
+                .opt.value = &cfg.flags,
                 .value = CMS_TEXT,
         },
         {
@@ -970,20 +970,20 @@ static const struct option cms_options[] = {
                 .argname = "addr",
                 .desc = "To address",
                 .type = OPTION_ARG,
-                .opt.arg = &cms_config.to,
+                .opt.arg = &cfg.to,
         },
         {
                 .name = "uncompress",
                 .desc = "Uncompress CMS CompressedData type",
                 .type = OPTION_VALUE,
-                .opt.value = &cms_config.operation,
+                .opt.value = &cfg.operation,
                 .value = SMIME_UNCOMPRESS,
         },
         {
                 .name = "verify",
                 .desc = "Verify signed message",
                 .type = OPTION_VALUE,
-                .opt.value = &cms_config.operation,
+                .opt.value = &cfg.operation,
                 .value = SMIME_VERIFY,
         },
         {
@@ -997,7 +997,7 @@ static const struct option cms_options[] = {
                 .name = "verify_retcode",
                 .desc = "Set verification error code to exit code",
                 .type = OPTION_FLAG,
-                .opt.flag = &cms_config.verify_retcode,
+                .opt.flag = &cfg.verify_retcode,
         },
         {
                 .name = "check_ss_sig",
@@ -1170,84 +1170,84 @@ cms_main(int argc, char **argv)
                 exit(1);
         }
 
-        memset(&cms_config, 0, sizeof(cms_config));
-        cms_config.flags = CMS_DETACHED;
-        cms_config.rr_allorfirst = -1;
-        cms_config.informat = FORMAT_SMIME;
-        cms_config.outformat = FORMAT_SMIME;
-        cms_config.rctformat = FORMAT_SMIME;
-        cms_config.keyform = FORMAT_PEM;
+        memset(&cfg, 0, sizeof(cfg));
+        cfg.flags = CMS_DETACHED;
+        cfg.rr_allorfirst = -1;
+        cfg.informat = FORMAT_SMIME;
+        cfg.outformat = FORMAT_SMIME;
+        cfg.rctformat = FORMAT_SMIME;
+        cfg.keyform = FORMAT_PEM;
         if (options_parse(argc, argv, cms_options, NULL, &argsused) != 0) {
                 goto argerr;
         }
         args = argv + argsused;
         ret = 1;
 
-        if (((cms_config.rr_allorfirst != -1) || cms_config.rr_from != NULL) &&
-            cms_config.rr_to == NULL) {
+        if (((cfg.rr_allorfirst != -1) || cfg.rr_from != NULL) &&
+            cfg.rr_to == NULL) {
                 BIO_puts(bio_err, "No Signed Receipts Recipients\n");
                 goto argerr;
         }
-        if (!(cms_config.operation & SMIME_SIGNERS) &&
-            (cms_config.rr_to != NULL || cms_config.rr_from != NULL)) {
+        if (!(cfg.operation & SMIME_SIGNERS) &&
+            (cfg.rr_to != NULL || cfg.rr_from != NULL)) {
                 BIO_puts(bio_err, "Signed receipts only allowed with -sign\n");
                 goto argerr;
         }
-        if (!(cms_config.operation & SMIME_SIGNERS) &&
-            (cms_config.skkeys != NULL || cms_config.sksigners != NULL)) {
+        if (!(cfg.operation & SMIME_SIGNERS) &&
+            (cfg.skkeys != NULL || cfg.sksigners != NULL)) {
                 BIO_puts(bio_err, "Multiple signers or keys not allowed\n");
                 goto argerr;
         }
-        if (cms_config.operation & SMIME_SIGNERS) {
-                if (cms_config.keyfile != NULL &&
-                    cms_config.signerfile == NULL) {
+        if (cfg.operation & SMIME_SIGNERS) {
+                if (cfg.keyfile != NULL &&
+                    cfg.signerfile == NULL) {
                         BIO_puts(bio_err, "Illegal -inkey without -signer\n");
                         goto argerr;
                 }
                 /* Check to see if any final signer needs to be appended */
-                if (cms_config.signerfile != NULL) {
-                        if (cms_config.sksigners == NULL &&
-                            (cms_config.sksigners =
+                if (cfg.signerfile != NULL) {
+                        if (cfg.sksigners == NULL &&
+                            (cfg.sksigners =
                             sk_OPENSSL_STRING_new_null()) == NULL)
                                 goto end;
-                        if (!sk_OPENSSL_STRING_push(cms_config.sksigners,
-                            cms_config.signerfile))
+                        if (!sk_OPENSSL_STRING_push(cfg.sksigners,
+                            cfg.signerfile))
                                 goto end;
-                        if (cms_config.skkeys == NULL &&
-                            (cms_config.skkeys =
+                        if (cfg.skkeys == NULL &&
+                            (cfg.skkeys =
                             sk_OPENSSL_STRING_new_null()) == NULL)
                                 goto end;
-                        if (cms_config.keyfile == NULL)
-                                cms_config.keyfile = cms_config.signerfile;
-                        if (!sk_OPENSSL_STRING_push(cms_config.skkeys,
-                            cms_config.keyfile))
+                        if (cfg.keyfile == NULL)
+                                cfg.keyfile = cfg.signerfile;
+                        if (!sk_OPENSSL_STRING_push(cfg.skkeys,
+                            cfg.keyfile))
                                 goto end;
                 }
-                if (cms_config.sksigners == NULL) {
+                if (cfg.sksigners == NULL) {
                         BIO_printf(bio_err,
                             "No signer certificate specified\n");
                         badarg = 1;
                 }
-                cms_config.signerfile = NULL;
-                cms_config.keyfile = NULL;
-        } else if (cms_config.operation == SMIME_DECRYPT) {
-                if (cms_config.recipfile == NULL &&
-                    cms_config.keyfile == NULL &&
-                    cms_config.secret_key == NULL &&
-                    cms_config.pwri_pass == NULL) {
+                cfg.signerfile = NULL;
+                cfg.keyfile = NULL;
+        } else if (cfg.operation == SMIME_DECRYPT) {
+                if (cfg.recipfile == NULL &&
+                    cfg.keyfile == NULL &&
+                    cfg.secret_key == NULL &&
+                    cfg.pwri_pass == NULL) {
                         BIO_printf(bio_err,
                             "No recipient certificate or key specified\n");
                         badarg = 1;
                 }
-        } else if (cms_config.operation == SMIME_ENCRYPT) {
-                if (*args == NULL && cms_config.secret_key == NULL &&
-                    cms_config.pwri_pass == NULL &&
-                    cms_config.encerts == NULL) {
+        } else if (cfg.operation == SMIME_ENCRYPT) {
+                if (*args == NULL && cfg.secret_key == NULL &&
+                    cfg.pwri_pass == NULL &&
+                    cfg.encerts == NULL) {
                         BIO_printf(bio_err,
                             "No recipient(s) certificate(s) specified\n");
                         badarg = 1;
                 }
-        } else if (!cms_config.operation) {
+        } else if (!cfg.operation) {
                 badarg = 1;
         }
 
@@ -1257,103 +1257,103 @@ cms_main(int argc, char **argv)
                 goto end;
         }
 
-        if (!app_passwd(bio_err, cms_config.passargin, NULL, &passin, NULL)) {
+        if (!app_passwd(bio_err, cfg.passargin, NULL, &passin, NULL)) {
                 BIO_printf(bio_err, "Error getting password\n");
                 goto end;
         }
         ret = 2;
 
-        if (!(cms_config.operation & SMIME_SIGNERS))
-                cms_config.flags &= ~CMS_DETACHED;
+        if (!(cfg.operation & SMIME_SIGNERS))
+                cfg.flags &= ~CMS_DETACHED;
 
-        if (cms_config.operation & SMIME_OP) {
-                if (cms_config.outformat == FORMAT_ASN1)
+        if (cfg.operation & SMIME_OP) {
+                if (cfg.outformat == FORMAT_ASN1)
                         outmode = "wb";
         } else {
-                if (cms_config.flags & CMS_BINARY)
+                if (cfg.flags & CMS_BINARY)
                         outmode = "wb";
         }
 
-        if (cms_config.operation & SMIME_IP) {
-                if (cms_config.informat == FORMAT_ASN1)
+        if (cfg.operation & SMIME_IP) {
+                if (cfg.informat == FORMAT_ASN1)
                         inmode = "rb";
         } else {
-                if (cms_config.flags & CMS_BINARY)
+                if (cfg.flags & CMS_BINARY)
                         inmode = "rb";
         }
 
-        if (cms_config.operation == SMIME_ENCRYPT) {
-                if (cms_config.cipher == NULL) {
+        if (cfg.operation == SMIME_ENCRYPT) {
+                if (cfg.cipher == NULL) {
 #ifndef OPENSSL_NO_DES
-                        cms_config.cipher = EVP_des_ede3_cbc();
+                        cfg.cipher = EVP_des_ede3_cbc();
 #else
                         BIO_printf(bio_err, "No cipher selected\n");
                         goto end;
 #endif
                 }
-                if (cms_config.secret_key != NULL &&
-                    cms_config.secret_keyid == NULL) {
+                if (cfg.secret_key != NULL &&
+                    cfg.secret_keyid == NULL) {
                         BIO_printf(bio_err, "No secret key id\n");
                         goto end;
                 }
-                if (*args != NULL && cms_config.encerts == NULL)
-                        if ((cms_config.encerts = sk_X509_new_null()) == NULL)
+                if (*args != NULL && cfg.encerts == NULL)
+                        if ((cfg.encerts = sk_X509_new_null()) == NULL)
                                 goto end;
                 while (*args) {
-                        if ((cms_config.cert = load_cert(bio_err, *args,
+                        if ((cfg.cert = load_cert(bio_err, *args,
                             FORMAT_PEM, NULL,
                             "recipient certificate file")) == NULL)
                                 goto end;
-                        if (!sk_X509_push(cms_config.encerts, cms_config.cert))
+                        if (!sk_X509_push(cfg.encerts, cfg.cert))
                                 goto end;
-                        cms_config.cert = NULL;
+                        cfg.cert = NULL;
                         args++;
                 }
         }
-        if (cms_config.certfile != NULL) {
-                if ((other = load_certs(bio_err, cms_config.certfile,
+        if (cfg.certfile != NULL) {
+                if ((other = load_certs(bio_err, cfg.certfile,
                     FORMAT_PEM, NULL, "certificate file")) == NULL) {
                         ERR_print_errors(bio_err);
                         goto end;
                 }
         }
-        if (cms_config.recipfile != NULL &&
-            (cms_config.operation == SMIME_DECRYPT)) {
-                if ((recip = load_cert(bio_err, cms_config.recipfile,
+        if (cfg.recipfile != NULL &&
+            (cfg.operation == SMIME_DECRYPT)) {
+                if ((recip = load_cert(bio_err, cfg.recipfile,
                     FORMAT_PEM, NULL, "recipient certificate file")) == NULL) {
                         ERR_print_errors(bio_err);
                         goto end;
                 }
         }
-        if (cms_config.operation == SMIME_SIGN_RECEIPT) {
-                if ((signer = load_cert(bio_err, cms_config.signerfile,
+        if (cfg.operation == SMIME_SIGN_RECEIPT) {
+                if ((signer = load_cert(bio_err, cfg.signerfile,
                     FORMAT_PEM, NULL,
                     "receipt signer certificate file")) == NULL) {
                         ERR_print_errors(bio_err);
                         goto end;
                 }
         }
-        if (cms_config.operation == SMIME_DECRYPT) {
-                if (cms_config.keyfile == NULL)
-                        cms_config.keyfile = cms_config.recipfile;
-        } else if ((cms_config.operation == SMIME_SIGN) ||
-            (cms_config.operation == SMIME_SIGN_RECEIPT)) {
-                if (cms_config.keyfile == NULL)
-                        cms_config.keyfile = cms_config.signerfile;
+        if (cfg.operation == SMIME_DECRYPT) {
+                if (cfg.keyfile == NULL)
+                        cfg.keyfile = cfg.recipfile;
+        } else if ((cfg.operation == SMIME_SIGN) ||
+            (cfg.operation == SMIME_SIGN_RECEIPT)) {
+                if (cfg.keyfile == NULL)
+                        cfg.keyfile = cfg.signerfile;
         } else {
-                cms_config.keyfile = NULL;
+                cfg.keyfile = NULL;
         }
 
-        if (cms_config.keyfile != NULL) {
-                key = load_key(bio_err, cms_config.keyfile, cms_config.keyform,
+        if (cfg.keyfile != NULL) {
+                key = load_key(bio_err, cfg.keyfile, cfg.keyform,
                     0, passin, "signing key file");
                 if (key == NULL)
                         goto end;
         }
-        if (cms_config.infile != NULL) {
-                if ((in = BIO_new_file(cms_config.infile, inmode)) == NULL) {
+        if (cfg.infile != NULL) {
+                if ((in = BIO_new_file(cfg.infile, inmode)) == NULL) {
                         BIO_printf(bio_err,
-                            "Can't open input file %s\n", cms_config.infile);
+                            "Can't open input file %s\n", cfg.infile);
                         goto end;
                 }
         } else {
@@ -1361,12 +1361,12 @@ cms_main(int argc, char **argv)
                         goto end;
         }
 
-        if (cms_config.operation & SMIME_IP) {
-                if (cms_config.informat == FORMAT_SMIME)
+        if (cfg.operation & SMIME_IP) {
+                if (cfg.informat == FORMAT_SMIME)
                         cms = SMIME_read_CMS(in, &indata);
-                else if (cms_config.informat == FORMAT_PEM)
+                else if (cfg.informat == FORMAT_PEM)
                         cms = PEM_read_bio_CMS(in, NULL, NULL, NULL);
-                else if (cms_config.informat == FORMAT_ASN1)
+                else if (cfg.informat == FORMAT_ASN1)
                         cms = d2i_CMS_bio(in, NULL);
                 else {
                         BIO_printf(bio_err, "Bad input format for CMS file\n");
@@ -1377,24 +1377,24 @@ cms_main(int argc, char **argv)
                         BIO_printf(bio_err, "Error reading S/MIME message\n");
                         goto end;
                 }
-                if (cms_config.contfile != NULL) {
+                if (cfg.contfile != NULL) {
                         BIO_free(indata);
-                        if ((indata = BIO_new_file(cms_config.contfile,
+                        if ((indata = BIO_new_file(cfg.contfile,
                             "rb")) == NULL) {
                                 BIO_printf(bio_err,
                                     "Can't read content file %s\n",
-                                    cms_config.contfile);
+                                    cfg.contfile);
                                 goto end;
                         }
                 }
-                if (cms_config.certsoutfile != NULL) {
+                if (cfg.certsoutfile != NULL) {
                         STACK_OF(X509) *allcerts;
                         if ((allcerts = CMS_get1_certs(cms)) == NULL)
                                 goto end;
-                        if (!save_certs(cms_config.certsoutfile, allcerts)) {
+                        if (!save_certs(cfg.certsoutfile, allcerts)) {
                                 BIO_printf(bio_err,
                                     "Error writing certs to %s\n",
-                                    cms_config.certsoutfile);
+                                    cfg.certsoutfile);
                                 sk_X509_pop_free(allcerts, X509_free);
                                 ret = 5;
                                 goto end;
@@ -1402,19 +1402,19 @@ cms_main(int argc, char **argv)
                         sk_X509_pop_free(allcerts, X509_free);
                 }
         }
-        if (cms_config.rctfile != NULL) {
-                char *rctmode = (cms_config.rctformat == FORMAT_ASN1) ?
+        if (cfg.rctfile != NULL) {
+                char *rctmode = (cfg.rctformat == FORMAT_ASN1) ?
                     "rb" : "r";
-                if ((rctin = BIO_new_file(cms_config.rctfile, rctmode)) == NULL) {
+                if ((rctin = BIO_new_file(cfg.rctfile, rctmode)) == NULL) {
                         BIO_printf(bio_err,
-                            "Can't open receipt file %s\n", cms_config.rctfile);
+                            "Can't open receipt file %s\n", cfg.rctfile);
                         goto end;
                 }
-                if (cms_config.rctformat == FORMAT_SMIME)
+                if (cfg.rctformat == FORMAT_SMIME)
                         rcms = SMIME_read_CMS(rctin, NULL);
-                else if (cms_config.rctformat == FORMAT_PEM)
+                else if (cfg.rctformat == FORMAT_PEM)
                         rcms = PEM_read_bio_CMS(rctin, NULL, NULL, NULL);
-                else if (cms_config.rctformat == FORMAT_ASN1)
+                else if (cfg.rctformat == FORMAT_ASN1)
                         rcms = d2i_CMS_bio(rctin, NULL);
                 else {
                         BIO_printf(bio_err, "Bad input format for receipt\n");
@@ -1426,10 +1426,10 @@ cms_main(int argc, char **argv)
                         goto end;
                 }
         }
-        if (cms_config.outfile != NULL) {
-                if ((out = BIO_new_file(cms_config.outfile, outmode)) == NULL) {
+        if (cfg.outfile != NULL) {
+                if ((out = BIO_new_file(cfg.outfile, outmode)) == NULL) {
                         BIO_printf(bio_err,
-                            "Can't open output file %s\n", cms_config.outfile);
+                            "Can't open output file %s\n", cfg.outfile);
                         goto end;
                 }
         } else {
@@ -1437,42 +1437,42 @@ cms_main(int argc, char **argv)
                         goto end;
         }
 
-        if ((cms_config.operation == SMIME_VERIFY) ||
-            (cms_config.operation == SMIME_VERIFY_RECEIPT)) {
-                if ((store = setup_verify(bio_err, cms_config.CAfile,
-                    cms_config.CApath)) == NULL)
+        if ((cfg.operation == SMIME_VERIFY) ||
+            (cfg.operation == SMIME_VERIFY_RECEIPT)) {
+                if ((store = setup_verify(bio_err, cfg.CAfile,
+                    cfg.CApath)) == NULL)
                         goto end;
                 X509_STORE_set_verify_cb(store, cms_cb);
-                if (cms_config.vpm != NULL) {
-                        if (!X509_STORE_set1_param(store, cms_config.vpm))
+                if (cfg.vpm != NULL) {
+                        if (!X509_STORE_set1_param(store, cfg.vpm))
                                 goto end;
                 }
         }
         ret = 3;
 
-        if (cms_config.operation == SMIME_DATA_CREATE) {
-                cms = CMS_data_create(in, cms_config.flags);
-        } else if (cms_config.operation == SMIME_DIGEST_CREATE) {
-                cms = CMS_digest_create(in, cms_config.sign_md,
-                    cms_config.flags);
-        } else if (cms_config.operation == SMIME_COMPRESS) {
-                cms = CMS_compress(in, -1, cms_config.flags);
-        } else if (cms_config.operation == SMIME_ENCRYPT) {
+        if (cfg.operation == SMIME_DATA_CREATE) {
+                cms = CMS_data_create(in, cfg.flags);
+        } else if (cfg.operation == SMIME_DIGEST_CREATE) {
+                cms = CMS_digest_create(in, cfg.sign_md,
+                    cfg.flags);
+        } else if (cfg.operation == SMIME_COMPRESS) {
+                cms = CMS_compress(in, -1, cfg.flags);
+        } else if (cfg.operation == SMIME_ENCRYPT) {
                 int i;
-                cms_config.flags |= CMS_PARTIAL;
-                cms = CMS_encrypt(NULL, in, cms_config.cipher,
-                    cms_config.flags);
+                cfg.flags |= CMS_PARTIAL;
+                cms = CMS_encrypt(NULL, in, cfg.cipher,
+                    cfg.flags);
                 if (cms == NULL)
                         goto end;
-                for (i = 0; i < sk_X509_num(cms_config.encerts); i++) {
+                for (i = 0; i < sk_X509_num(cfg.encerts); i++) {
                         CMS_RecipientInfo *ri;
                         struct cms_key_param *kparam;
-                        int tflags = cms_config.flags;
+                        int tflags = cfg.flags;
                         X509 *x;
 
-                        if ((x = sk_X509_value(cms_config.encerts, i)) == NULL)
+                        if ((x = sk_X509_value(cfg.encerts, i)) == NULL)
                                 goto end;
-                        for (kparam = cms_config.key_first; kparam != NULL;
+                        for (kparam = cfg.key_first; kparam != NULL;
                             kparam = kparam->next) {
                                 if (kparam->idx == i) {
                                         tflags |= CMS_KEY_PARAM;
@@ -1492,18 +1492,18 @@ cms_main(int argc, char **argv)
                         }
                 }
 
-                if (cms_config.secret_key != NULL) {
+                if (cfg.secret_key != NULL) {
                         if (CMS_add0_recipient_key(cms, NID_undef,
-                            cms_config.secret_key, cms_config.secret_keylen,
-                            cms_config.secret_keyid, cms_config.secret_keyidlen,
+                            cfg.secret_key, cfg.secret_keylen,
+                            cfg.secret_keyid, cfg.secret_keyidlen,
                             NULL, NULL, NULL) == NULL)
                                 goto end;
                         /* NULL these because call absorbs them */
-                        cms_config.secret_key = NULL;
-                        cms_config.secret_keyid = NULL;
+                        cfg.secret_key = NULL;
+                        cfg.secret_keyid = NULL;
                 }
-                if (cms_config.pwri_pass != NULL) {
-                        pwri_tmp = strdup(cms_config.pwri_pass);
+                if (cfg.pwri_pass != NULL) {
+                        pwri_tmp = strdup(cfg.pwri_pass);
                         if (pwri_tmp == NULL)
                                 goto end;
                         if (CMS_add0_recipient_password(cms, -1, NID_undef,
@@ -1511,16 +1511,16 @@ cms_main(int argc, char **argv)
                                 goto end;
                         pwri_tmp = NULL;
                 }
-                if (!(cms_config.flags & CMS_STREAM)) {
-                        if (!CMS_final(cms, in, NULL, cms_config.flags))
+                if (!(cfg.flags & CMS_STREAM)) {
+                        if (!CMS_final(cms, in, NULL, cfg.flags))
                                 goto end;
                 }
-        } else if (cms_config.operation == SMIME_ENCRYPTED_ENCRYPT) {
-                cms = CMS_EncryptedData_encrypt(in, cms_config.cipher,
-                    cms_config.secret_key, cms_config.secret_keylen,
-                    cms_config.flags);
+        } else if (cfg.operation == SMIME_ENCRYPTED_ENCRYPT) {
+                cms = CMS_EncryptedData_encrypt(in, cfg.cipher,
+                    cfg.secret_key, cfg.secret_keylen,
+                    cfg.flags);
 
-        } else if (cms_config.operation == SMIME_SIGN_RECEIPT) {
+        } else if (cfg.operation == SMIME_SIGN_RECEIPT) {
                 CMS_ContentInfo *srcms = NULL;
                 STACK_OF(CMS_SignerInfo) *sis;
                 CMS_SignerInfo *si;
@@ -1531,36 +1531,36 @@ cms_main(int argc, char **argv)
                 if (si == NULL)
                         goto end;
                 srcms = CMS_sign_receipt(si, signer, key, other,
-                    cms_config.flags);
+                    cfg.flags);
                 if (srcms == NULL)
                         goto end;
                 CMS_ContentInfo_free(cms);
                 cms = srcms;
-        } else if (cms_config.operation & SMIME_SIGNERS) {
+        } else if (cfg.operation & SMIME_SIGNERS) {
                 int i;
                 /*
                  * If detached data content we enable streaming if S/MIME
                  * output format.
                  */
-                if (cms_config.operation == SMIME_SIGN) {
+                if (cfg.operation == SMIME_SIGN) {
 
-                        if (cms_config.flags & CMS_DETACHED) {
-                                if (cms_config.outformat == FORMAT_SMIME)
-                                        cms_config.flags |= CMS_STREAM;
+                        if (cfg.flags & CMS_DETACHED) {
+                                if (cfg.outformat == FORMAT_SMIME)
+                                        cfg.flags |= CMS_STREAM;
                         }
-                        cms_config.flags |= CMS_PARTIAL;
-                        cms = CMS_sign(NULL, NULL, other, in, cms_config.flags);
+                        cfg.flags |= CMS_PARTIAL;
+                        cms = CMS_sign(NULL, NULL, other, in, cfg.flags);
                         if (cms == NULL)
                                 goto end;
-                        if (cms_config.econtent_type != NULL)
+                        if (cfg.econtent_type != NULL)
                                 if (!CMS_set1_eContentType(cms,
-                                    cms_config.econtent_type))
+                                    cfg.econtent_type))
                                         goto end;
 
-                        if (cms_config.rr_to != NULL) {
-                                rr = make_receipt_request(cms_config.rr_to,
-                                    cms_config.rr_allorfirst,
-                                    cms_config.rr_from);
+                        if (cfg.rr_to != NULL) {
+                                rr = make_receipt_request(cfg.rr_to,
+                                    cfg.rr_allorfirst,
+                                    cfg.rr_from);
                                 if (rr == NULL) {
                                         BIO_puts(bio_err,
                                             "Signed Receipt Request Creation Error\n");
@@ -1568,28 +1568,28 @@ cms_main(int argc, char **argv)
                                 }
                         }
                 } else {
-                        cms_config.flags |= CMS_REUSE_DIGEST;
+                        cfg.flags |= CMS_REUSE_DIGEST;
                 }
 
-                for (i = 0; i < sk_OPENSSL_STRING_num(cms_config.sksigners); i++) {
+                for (i = 0; i < sk_OPENSSL_STRING_num(cfg.sksigners); i++) {
                         CMS_SignerInfo *si;
                         struct cms_key_param *kparam;
-                        int tflags = cms_config.flags;
+                        int tflags = cfg.flags;
 
-                        cms_config.signerfile = sk_OPENSSL_STRING_value(
-                            cms_config.sksigners, i);
-                        cms_config.keyfile = sk_OPENSSL_STRING_value(
-                            cms_config.skkeys, i);
+                        cfg.signerfile = sk_OPENSSL_STRING_value(
+                            cfg.sksigners, i);
+                        cfg.keyfile = sk_OPENSSL_STRING_value(
+                            cfg.skkeys, i);
 
-                        signer = load_cert(bio_err, cms_config.signerfile,
+                        signer = load_cert(bio_err, cfg.signerfile,
                             FORMAT_PEM, NULL, "signer certificate");
                         if (signer == NULL)
                                 goto end;
-                        key = load_key(bio_err, cms_config.keyfile,
-                            cms_config.keyform, 0, passin, "signing key file");
+                        key = load_key(bio_err, cfg.keyfile,
+                            cfg.keyform, 0, passin, "signing key file");
                         if (key == NULL)
                                 goto end;
-                        for (kparam = cms_config.key_first; kparam != NULL;
+                        for (kparam = cfg.key_first; kparam != NULL;
                             kparam = kparam->next) {
                                 if (kparam->idx == i) {
                                         tflags |= CMS_KEY_PARAM;
@@ -1597,7 +1597,7 @@ cms_main(int argc, char **argv)
                                 }
                         }
                         si = CMS_add1_signer(cms, signer, key,
-                            cms_config.sign_md, tflags);
+                            cfg.sign_md, tflags);
                         if (si == NULL)
                                 goto end;
                         if (kparam != NULL) {
@@ -1616,9 +1616,9 @@ cms_main(int argc, char **argv)
                         key = NULL;
                 }
                 /* If not streaming or resigning finalize structure */
-                if ((cms_config.operation == SMIME_SIGN) &&
-                    !(cms_config.flags & CMS_STREAM)) {
-                        if (!CMS_final(cms, in, NULL, cms_config.flags))
+                if ((cfg.operation == SMIME_SIGN) &&
+                    !(cfg.flags & CMS_STREAM)) {
+                        if (!CMS_final(cms, in, NULL, cfg.flags))
                                 goto end;
                 }
         }
@@ -1627,15 +1627,15 @@ cms_main(int argc, char **argv)
                 goto end;
         }
         ret = 4;
-        if (cms_config.operation == SMIME_DECRYPT) {
-                if (cms_config.flags & CMS_DEBUG_DECRYPT)
+        if (cfg.operation == SMIME_DECRYPT) {
+                if (cfg.flags & CMS_DEBUG_DECRYPT)
                         CMS_decrypt(cms, NULL, NULL, NULL, NULL,
-                            cms_config.flags);
+                            cfg.flags);
 
-                if (cms_config.secret_key != NULL) {
-                        if (!CMS_decrypt_set1_key(cms, cms_config.secret_key,
-                            cms_config.secret_keylen, cms_config.secret_keyid,
-                            cms_config.secret_keyidlen)) {
+                if (cfg.secret_key != NULL) {
+                        if (!CMS_decrypt_set1_key(cms, cfg.secret_key,
+                            cfg.secret_keylen, cfg.secret_keyid,
+                            cfg.secret_keyidlen)) {
                                 BIO_puts(bio_err,
                                     "Error decrypting CMS using secret key\n");
                                 goto end;
@@ -1648,95 +1648,95 @@ cms_main(int argc, char **argv)
                                 goto end;
                         }
                 }
-                if (cms_config.pwri_pass != NULL) {
+                if (cfg.pwri_pass != NULL) {
                         if (!CMS_decrypt_set1_password(cms,
-                            cms_config.pwri_pass, -1)) {
+                            cfg.pwri_pass, -1)) {
                                 BIO_puts(bio_err,
                                     "Error decrypting CMS using password\n");
                                 goto end;
                         }
                 }
                 if (!CMS_decrypt(cms, NULL, NULL, indata, out,
-                    cms_config.flags)) {
+                    cfg.flags)) {
                         BIO_printf(bio_err, "Error decrypting CMS structure\n");
                         goto end;
                 }
-        } else if (cms_config.operation == SMIME_DATAOUT) {
-                if (!CMS_data(cms, out, cms_config.flags))
+        } else if (cfg.operation == SMIME_DATAOUT) {
+                if (!CMS_data(cms, out, cfg.flags))
                         goto end;
-        } else if (cms_config.operation == SMIME_UNCOMPRESS) {
-                if (!CMS_uncompress(cms, indata, out, cms_config.flags))
+        } else if (cfg.operation == SMIME_UNCOMPRESS) {
+                if (!CMS_uncompress(cms, indata, out, cfg.flags))
                         goto end;
-        } else if (cms_config.operation == SMIME_DIGEST_VERIFY) {
-                if (CMS_digest_verify(cms, indata, out, cms_config.flags) > 0)
+        } else if (cfg.operation == SMIME_DIGEST_VERIFY) {
+                if (CMS_digest_verify(cms, indata, out, cfg.flags) > 0)
                         BIO_printf(bio_err, "Verification successful\n");
                 else {
                         BIO_printf(bio_err, "Verification failure\n");
                         goto end;
                 }
-        } else if (cms_config.operation == SMIME_ENCRYPTED_DECRYPT) {
-                if (!CMS_EncryptedData_decrypt(cms, cms_config.secret_key,
-                    cms_config.secret_keylen, indata, out, cms_config.flags))
+        } else if (cfg.operation == SMIME_ENCRYPTED_DECRYPT) {
+                if (!CMS_EncryptedData_decrypt(cms, cfg.secret_key,
+                    cfg.secret_keylen, indata, out, cfg.flags))
                         goto end;
-        } else if (cms_config.operation == SMIME_VERIFY) {
+        } else if (cfg.operation == SMIME_VERIFY) {
                 if (CMS_verify(cms, other, store, indata, out,
-                    cms_config.flags) > 0) {
+                    cfg.flags) > 0) {
                         BIO_printf(bio_err, "Verification successful\n");
                 } else {
                         BIO_printf(bio_err, "Verification failure\n");
-                        if (cms_config.verify_retcode)
+                        if (cfg.verify_retcode)
                                 ret = verify_err + 32;
                         goto end;
                 }
-                if (cms_config.signerfile != NULL) {
+                if (cfg.signerfile != NULL) {
                         STACK_OF(X509) *signers;
                         if ((signers = CMS_get0_signers(cms)) == NULL)
                                 goto end;
-                        if (!save_certs(cms_config.signerfile, signers)) {
+                        if (!save_certs(cfg.signerfile, signers)) {
                                 BIO_printf(bio_err,
                                     "Error writing signers to %s\n",
-                                    cms_config.signerfile);
+                                    cfg.signerfile);
                                 sk_X509_free(signers);
                                 ret = 5;
                                 goto end;
                         }
                         sk_X509_free(signers);
                 }
-                if (cms_config.rr_print)
+                if (cfg.rr_print)
                         receipt_request_print(bio_err, cms);
 
-        } else if (cms_config.operation == SMIME_VERIFY_RECEIPT) {
+        } else if (cfg.operation == SMIME_VERIFY_RECEIPT) {
                 if (CMS_verify_receipt(rcms, cms, other, store,
-                    cms_config.flags) > 0) {
+                    cfg.flags) > 0) {
                         BIO_printf(bio_err, "Verification successful\n");
                 } else {
                         BIO_printf(bio_err, "Verification failure\n");
                         goto end;
                 }
         } else {
-                if (cms_config.noout) {
-                        if (cms_config.print &&
+                if (cfg.noout) {
+                        if (cfg.print &&
                             !CMS_ContentInfo_print_ctx(out, cms, 0, NULL))
                                 goto end;
-                } else if (cms_config.outformat == FORMAT_SMIME) {
-                        if (cms_config.to != NULL)
-                                BIO_printf(out, "To: %s\n", cms_config.to);
-                        if (cms_config.from != NULL)
-                                BIO_printf(out, "From: %s\n", cms_config.from);
-                        if (cms_config.subject != NULL)
+                } else if (cfg.outformat == FORMAT_SMIME) {
+                        if (cfg.to != NULL)
+                                BIO_printf(out, "To: %s\n", cfg.to);
+                        if (cfg.from != NULL)
+                                BIO_printf(out, "From: %s\n", cfg.from);
+                        if (cfg.subject != NULL)
                                 BIO_printf(out, "Subject: %s\n",
-                                    cms_config.subject);
-                        if (cms_config.operation == SMIME_RESIGN)
+                                    cfg.subject);
+                        if (cfg.operation == SMIME_RESIGN)
                                 ret = SMIME_write_CMS(out, cms, indata,
-                                    cms_config.flags);
+                                    cfg.flags);
                         else
                                 ret = SMIME_write_CMS(out, cms, in,
-                                    cms_config.flags);
-                } else if (cms_config.outformat == FORMAT_PEM) {
+                                    cfg.flags);
+                } else if (cfg.outformat == FORMAT_PEM) {
                         ret = PEM_write_bio_CMS_stream(out, cms, in,
-                            cms_config.flags);
-                } else if (cms_config.outformat == FORMAT_ASN1) {
-                        ret = i2d_CMS_bio_stream(out, cms, in, cms_config.flags);
+                            cfg.flags);
+                } else if (cfg.outformat == FORMAT_ASN1) {
+                        ret = i2d_CMS_bio_stream(out, cms, in, cfg.flags);
                 } else {
                         BIO_printf(bio_err, "Bad output format for CMS file\n");
                         goto end;
@@ -1752,27 +1752,27 @@ cms_main(int argc, char **argv)
         if (ret)
                 ERR_print_errors(bio_err);
 
-        sk_X509_pop_free(cms_config.encerts, X509_free);
+        sk_X509_pop_free(cfg.encerts, X509_free);
         sk_X509_pop_free(other, X509_free);
-        X509_VERIFY_PARAM_free(cms_config.vpm);
-        sk_OPENSSL_STRING_free(cms_config.sksigners);
-        sk_OPENSSL_STRING_free(cms_config.skkeys);
-        free(cms_config.secret_key);
-        free(cms_config.secret_keyid);
+        X509_VERIFY_PARAM_free(cfg.vpm);
+        sk_OPENSSL_STRING_free(cfg.sksigners);
+        sk_OPENSSL_STRING_free(cfg.skkeys);
+        free(cfg.secret_key);
+        free(cfg.secret_keyid);
         free(pwri_tmp);
-        ASN1_OBJECT_free(cms_config.econtent_type);
+        ASN1_OBJECT_free(cfg.econtent_type);
         CMS_ReceiptRequest_free(rr);
-        sk_OPENSSL_STRING_free(cms_config.rr_to);
-        sk_OPENSSL_STRING_free(cms_config.rr_from);
-        for (cms_config.key_param = cms_config.key_first; cms_config.key_param;) {
+        sk_OPENSSL_STRING_free(cfg.rr_to);
+        sk_OPENSSL_STRING_free(cfg.rr_from);
+        for (cfg.key_param = cfg.key_first; cfg.key_param;) {
                 struct cms_key_param *tparam;
-                sk_OPENSSL_STRING_free(cms_config.key_param->param);
-                tparam = cms_config.key_param->next;
-                free(cms_config.key_param);
-                cms_config.key_param = tparam;
+                sk_OPENSSL_STRING_free(cfg.key_param->param);
+                tparam = cfg.key_param->next;
+                free(cfg.key_param);
+                cfg.key_param = tparam;
         }
         X509_STORE_free(store);
-        X509_free(cms_config.cert);
+        X509_free(cfg.cert);
         X509_free(recip);
         X509_free(signer);
         EVP_PKEY_free(key);