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, 48 insertions, 48 deletions

diff --git a/src/usr.bin/openssl/rsautl.c b/src/usr.bin/openssl/rsautl.c
index 2916b2d9a0..9327223123 100644
--- a/src/usr.bin/openssl/rsautl.c
+++ b/src/usr.bin/openssl/rsautl.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: rsautl.c,v 1.20 2023/03/05 13:12:53 tb Exp $ */
+/* $OpenBSD: rsautl.c,v 1.21 2023/03/06 14:32:06 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2000.
  */
@@ -87,131 +87,131 @@ static struct {
         char *passargin;
         int rev;
         int rsa_mode;
-} rsautl_config;
+} cfg;
 
 static const struct option rsautl_options[] = {
         {
                 .name = "asn1parse",
                 .desc = "ASN.1 parse the output data",
                 .type = OPTION_FLAG,
-                .opt.flag = &rsautl_config.asn1parse,
+                .opt.flag = &cfg.asn1parse,
         },
         {
                 .name = "certin",
                 .desc = "Input is a certificate containing an RSA public key",
                 .type = OPTION_VALUE,
                 .value = KEY_CERT,
-                .opt.value = &rsautl_config.key_type,
+                .opt.value = &cfg.key_type,
         },
         {
                 .name = "decrypt",
                 .desc = "Decrypt the input data using RSA private key",
                 .type = OPTION_VALUE,
                 .value = RSA_DECRYPT,
-                .opt.value = &rsautl_config.rsa_mode,
+                .opt.value = &cfg.rsa_mode,
         },
         {
                 .name = "encrypt",
                 .desc = "Encrypt the input data using RSA public key",
                 .type = OPTION_VALUE,
                 .value = RSA_ENCRYPT,
-                .opt.value = &rsautl_config.rsa_mode,
+                .opt.value = &cfg.rsa_mode,
         },
         {
                 .name = "hexdump",
                 .desc = "Hex dump the output data",
                 .type = OPTION_FLAG,
-                .opt.flag = &rsautl_config.hexdump,
+                .opt.flag = &cfg.hexdump,
         },
         {
                 .name = "in",
                 .argname = "file",
                 .desc = "Input file (default stdin)",
                 .type = OPTION_ARG,
-                .opt.arg = &rsautl_config.infile,
+                .opt.arg = &cfg.infile,
         },
         {
                 .name = "inkey",
                 .argname = "file",
                 .desc = "Input key file",
                 .type = OPTION_ARG,
-                .opt.arg = &rsautl_config.keyfile,
+                .opt.arg = &cfg.keyfile,
         },
         {
                 .name = "keyform",
                 .argname = "fmt",
                 .desc = "Input key format (DER, TXT or PEM (default))",
                 .type = OPTION_ARG_FORMAT,
-                .opt.value = &rsautl_config.keyform,
+                .opt.value = &cfg.keyform,
         },
         {
                 .name = "oaep",
                 .desc = "Use PKCS#1 OAEP padding",
                 .type = OPTION_VALUE,
                 .value = RSA_PKCS1_OAEP_PADDING,
-                .opt.value = &rsautl_config.pad,
+                .opt.value = &cfg.pad,
         },
         {
                 .name = "out",
                 .argname = "file",
                 .desc = "Output file (default stdout)",
                 .type = OPTION_ARG,
-                .opt.arg = &rsautl_config.outfile,
+                .opt.arg = &cfg.outfile,
         },
         {
                 .name = "passin",
                 .argname = "arg",
                 .desc = "Key password source",
                 .type = OPTION_ARG,
-                .opt.arg = &rsautl_config.passargin,
+                .opt.arg = &cfg.passargin,
         },
         {
                 .name = "pkcs",
                 .desc = "Use PKCS#1 v1.5 padding (default)",
                 .type = OPTION_VALUE,
                 .value = RSA_PKCS1_PADDING,
-                .opt.value = &rsautl_config.pad,
+                .opt.value = &cfg.pad,
         },
         {
                 .name = "pubin",
                 .desc = "Input is an RSA public key",
                 .type = OPTION_VALUE,
                 .value = KEY_PUBKEY,
-                .opt.value = &rsautl_config.key_type,
+                .opt.value = &cfg.key_type,
         },
         {
                 .name = "raw",
                 .desc = "Use no padding",
                 .type = OPTION_VALUE,
                 .value = RSA_NO_PADDING,
-                .opt.value = &rsautl_config.pad,
+                .opt.value = &cfg.pad,
         },
         {
                 .name = "rev",
                 .desc = "Reverse the input data",
                 .type = OPTION_FLAG,
-                .opt.flag = &rsautl_config.rev,
+                .opt.flag = &cfg.rev,
         },
         {
                 .name = "sign",
                 .desc = "Sign the input data using RSA private key",
                 .type = OPTION_VALUE,
                 .value = RSA_SIGN,
-                .opt.value = &rsautl_config.rsa_mode,
+                .opt.value = &cfg.rsa_mode,
         },
         {
                 .name = "verify",
                 .desc = "Verify the input data using RSA public key",
                 .type = OPTION_VALUE,
                 .value = RSA_VERIFY,
-                .opt.value = &rsautl_config.rsa_mode,
+                .opt.value = &cfg.rsa_mode,
         },
         {
                 .name = "x931",
                 .desc = "Use ANSI X9.31 padding",
                 .type = OPTION_VALUE,
                 .value = RSA_X931_PADDING,
-                .opt.value = &rsautl_config.pad,
+                .opt.value = &cfg.pad,
         },
 
         {NULL},
@@ -249,44 +249,44 @@ rsautl_main(int argc, char **argv)
                 exit(1);
         }
 
-        memset(&rsautl_config, 0, sizeof(rsautl_config));
-        rsautl_config.keyform = FORMAT_PEM;
-        rsautl_config.key_type = KEY_PRIVKEY;
-        rsautl_config.pad = RSA_PKCS1_PADDING;
-        rsautl_config.rsa_mode = RSA_VERIFY;
+        memset(&cfg, 0, sizeof(cfg));
+        cfg.keyform = FORMAT_PEM;
+        cfg.key_type = KEY_PRIVKEY;
+        cfg.pad = RSA_PKCS1_PADDING;
+        cfg.rsa_mode = RSA_VERIFY;
 
         if (options_parse(argc, argv, rsautl_options, NULL, NULL) != 0) {
                 rsautl_usage();
                 return (1);
         }
 
-        if (rsautl_config.rsa_mode == RSA_SIGN ||
-            rsautl_config.rsa_mode == RSA_DECRYPT)
+        if (cfg.rsa_mode == RSA_SIGN ||
+            cfg.rsa_mode == RSA_DECRYPT)
                 need_priv = 1;
 
-        if (need_priv && rsautl_config.key_type != KEY_PRIVKEY) {
+        if (need_priv && cfg.key_type != KEY_PRIVKEY) {
                 BIO_printf(bio_err, "A private key is needed for this operation\n");
                 goto end;
         }
-        if (!app_passwd(bio_err, rsautl_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;
         }
 
-        switch (rsautl_config.key_type) {
+        switch (cfg.key_type) {
         case KEY_PRIVKEY:
-                pkey = load_key(bio_err, rsautl_config.keyfile,
-                    rsautl_config.keyform, 0, passin, "Private Key");
+                pkey = load_key(bio_err, cfg.keyfile,
+                    cfg.keyform, 0, passin, "Private Key");
                 break;
 
         case KEY_PUBKEY:
-                pkey = load_pubkey(bio_err, rsautl_config.keyfile,
-                    rsautl_config.keyform, 0, NULL, "Public Key");
+                pkey = load_pubkey(bio_err, cfg.keyfile,
+                    cfg.keyform, 0, NULL, "Public Key");
                 break;
 
         case KEY_CERT:
-                x = load_cert(bio_err, rsautl_config.keyfile,
-                    rsautl_config.keyform, NULL, "Certificate");
+                x = load_cert(bio_err, cfg.keyfile,
+                    cfg.keyform, NULL, "Certificate");
                 if (x) {
                         pkey = X509_get_pubkey(x);
                         X509_free(x);
@@ -305,8 +305,8 @@ rsautl_main(int argc, char **argv)
                 ERR_print_errors(bio_err);
                 goto end;
         }
-        if (rsautl_config.infile) {
-                if (!(in = BIO_new_file(rsautl_config.infile, "rb"))) {
+        if (cfg.infile) {
+                if (!(in = BIO_new_file(cfg.infile, "rb"))) {
                         BIO_printf(bio_err, "Error Reading Input File\n");
                         ERR_print_errors(bio_err);
                         goto end;
@@ -314,8 +314,8 @@ rsautl_main(int argc, char **argv)
         } else
                 in = BIO_new_fp(stdin, BIO_NOCLOSE);
 
-        if (rsautl_config.outfile) {
-                if (!(out = BIO_new_file(rsautl_config.outfile, "wb"))) {
+        if (cfg.outfile) {
+                if (!(out = BIO_new_file(cfg.outfile, "wb"))) {
                         BIO_printf(bio_err, "Error Reading Output File\n");
                         ERR_print_errors(bio_err);
                         goto end;
@@ -343,7 +343,7 @@ rsautl_main(int argc, char **argv)
                 BIO_printf(bio_err, "Error reading input Data\n");
                 exit(1);
         }
-        if (rsautl_config.rev) {
+        if (cfg.rev) {
                 int i;
                 unsigned char ctmp;
                 for (i = 0; i < rsa_inlen / 2; i++) {
@@ -353,25 +353,25 @@ rsautl_main(int argc, char **argv)
                 }
         }
 
-        switch (rsautl_config.rsa_mode) {
+        switch (cfg.rsa_mode) {
         case RSA_VERIFY:
                 rsa_outlen = RSA_public_decrypt(rsa_inlen, rsa_in, rsa_out,
-                    rsa, rsautl_config.pad);
+                    rsa, cfg.pad);
                 break;
 
         case RSA_SIGN:
                 rsa_outlen = RSA_private_encrypt(rsa_inlen, rsa_in, rsa_out,
-                    rsa, rsautl_config.pad);
+                    rsa, cfg.pad);
                 break;
 
         case RSA_ENCRYPT:
                 rsa_outlen = RSA_public_encrypt(rsa_inlen, rsa_in, rsa_out,
-                    rsa, rsautl_config.pad);
+                    rsa, cfg.pad);
                 break;
 
         case RSA_DECRYPT:
                 rsa_outlen = RSA_private_decrypt(rsa_inlen, rsa_in, rsa_out,
-                    rsa, rsautl_config.pad);
+                    rsa, cfg.pad);
                 break;
         }
 
@@ -381,11 +381,11 @@ rsautl_main(int argc, char **argv)
                 goto end;
         }
         ret = 0;
-        if (rsautl_config.asn1parse) {
+        if (cfg.asn1parse) {
                 if (!ASN1_parse_dump(out, rsa_out, rsa_outlen, 1, -1)) {
                         ERR_print_errors(bio_err);
                 }
-        } else if (rsautl_config.hexdump)
+        } else if (cfg.hexdump)
                 BIO_dump(out, (char *) rsa_out, rsa_outlen);
         else
                 BIO_write(out, rsa_out, rsa_outlen);