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

diff --git a/src/usr.bin/openssl/asn1pars.c b/src/usr.bin/openssl/asn1pars.c
index 6f7fa18512..5824b0ea14 100644
--- a/src/usr.bin/openssl/asn1pars.c
+++ b/src/usr.bin/openssl/asn1pars.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: asn1pars.c,v 1.12 2022/11/11 17:07:38 joshua Exp $ */
+/* $OpenBSD: asn1pars.c,v 1.13 2023/03/06 14:32:05 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -86,14 +86,14 @@ static struct {
         int offset;
         char *oidfile;
         STACK_OF(OPENSSL_STRING) *osk;
-} asn1pars_config;
+} cfg;
 
 static int
 asn1pars_opt_dlimit(char *arg)
 {
         const char *errstr;
 
-        asn1pars_config.dump = strtonum(arg, 1, INT_MAX, &errstr);
+        cfg.dump = strtonum(arg, 1, INT_MAX, &errstr);
         if (errstr) {
                 fprintf(stderr, "-dlimit must be from 1 to INT_MAX: %s\n",
                     errstr);
@@ -107,7 +107,7 @@ asn1pars_opt_length(char *arg)
 {
         const char *errstr;
 
-        asn1pars_config.length = strtonum(arg, 1, UINT_MAX, &errstr);
+        cfg.length = strtonum(arg, 1, UINT_MAX, &errstr);
         if (errstr) {
                 fprintf(stderr, "-length must be from 1 to UINT_MAX: %s\n",
                     errstr);
@@ -119,7 +119,7 @@ asn1pars_opt_length(char *arg)
 static int
 asn1pars_opt_strparse(char *arg)
 {
-        if (sk_OPENSSL_STRING_push(asn1pars_config.osk, arg) == 0) {
+        if (sk_OPENSSL_STRING_push(cfg.osk, arg) == 0) {
                 fprintf(stderr, "-strparse cannot add argument\n");
                 return (-1);
         }
@@ -132,7 +132,7 @@ static const struct option asn1pars_options[] = {
                 .desc = "Dump unknown data in hex form",
                 .type = OPTION_VALUE,
                 .value = -1,
-                .opt.value = &asn1pars_config.dump,
+                .opt.value = &cfg.dump,
         },
         {
                 .name = "dlimit",
@@ -146,34 +146,34 @@ static const struct option asn1pars_options[] = {
                 .argname = "file",
                 .desc = "File to generate ASN.1 structure from",
                 .type = OPTION_ARG,
-                .opt.arg = &asn1pars_config.genconf,
+                .opt.arg = &cfg.genconf,
         },
         {
                 .name = "genstr",
                 .argname = "string",
                 .desc = "String to generate ASN.1 structure from",
                 .type = OPTION_ARG,
-                .opt.arg = &asn1pars_config.genstr,
+                .opt.arg = &cfg.genstr,
         },
         {
                 .name = "i",
                 .desc = "Indent output according to depth of structures",
                 .type = OPTION_FLAG,
-                .opt.flag = &asn1pars_config.indent,
+                .opt.flag = &cfg.indent,
         },
         {
                 .name = "in",
                 .argname = "file",
                 .desc = "The input file (default stdin)",
                 .type = OPTION_ARG,
-                .opt.arg = &asn1pars_config.infile,
+                .opt.arg = &cfg.infile,
         },
         {
                 .name = "inform",
                 .argname = "fmt",
                 .desc = "Input format (DER, TXT or PEM (default))",
                 .type = OPTION_ARG_FORMAT,
-                .opt.value = &asn1pars_config.informat,
+                .opt.value = &cfg.informat,
         },
         {
                 .name = "length",
@@ -186,28 +186,28 @@ static const struct option asn1pars_options[] = {
                 .name = "noout",
                 .desc = "Do not produce any output",
                 .type = OPTION_FLAG,
-                .opt.flag = &asn1pars_config.noout,
+                .opt.flag = &cfg.noout,
         },
         {
                 .name = "offset",
                 .argname = "num",
                 .desc = "Offset to begin parsing",
                 .type = OPTION_ARG_INT,
-                .opt.value = &asn1pars_config.offset,
+                .opt.value = &cfg.offset,
         },
         {
                 .name = "oid",
                 .argname = "file",
                 .desc = "File containing additional object identifiers (OIDs)",
                 .type = OPTION_ARG,
-                .opt.arg = &asn1pars_config.oidfile,
+                .opt.arg = &cfg.oidfile,
         },
         {
                 .name = "out",
                 .argname = "file",
                 .desc = "Output file in DER format",
                 .type = OPTION_ARG,
-                .opt.arg = &asn1pars_config.derfile,
+                .opt.arg = &cfg.derfile,
         },
         {
                 .name = "strparse",
@@ -252,10 +252,10 @@ asn1parse_main(int argc, char **argv)
                 exit(1);
         }
 
-        memset(&asn1pars_config, 0, sizeof(asn1pars_config));
+        memset(&cfg, 0, sizeof(cfg));
 
-        asn1pars_config.informat = FORMAT_PEM;
-        if ((asn1pars_config.osk = sk_OPENSSL_STRING_new_null()) == NULL) {
+        cfg.informat = FORMAT_PEM;
+        if ((cfg.osk = sk_OPENSSL_STRING_new_null()) == NULL) {
                 BIO_printf(bio_err, "Memory allocation failure\n");
                 goto end;
         }
@@ -273,28 +273,28 @@ asn1parse_main(int argc, char **argv)
         }
         BIO_set_fp(out, stdout, BIO_NOCLOSE | BIO_FP_TEXT);
 
-        if (asn1pars_config.oidfile != NULL) {
-                if (BIO_read_filename(in, asn1pars_config.oidfile) <= 0) {
+        if (cfg.oidfile != NULL) {
+                if (BIO_read_filename(in, cfg.oidfile) <= 0) {
                         BIO_printf(bio_err, "problems opening %s\n",
-                            asn1pars_config.oidfile);
+                            cfg.oidfile);
                         ERR_print_errors(bio_err);
                         goto end;
                 }
                 OBJ_create_objects(in);
         }
-        if (asn1pars_config.infile == NULL)
+        if (cfg.infile == NULL)
                 BIO_set_fp(in, stdin, BIO_NOCLOSE);
         else {
-                if (BIO_read_filename(in, asn1pars_config.infile) <= 0) {
-                        perror(asn1pars_config.infile);
+                if (BIO_read_filename(in, cfg.infile) <= 0) {
+                        perror(cfg.infile);
                         goto end;
                 }
         }
 
-        if (asn1pars_config.derfile) {
-                if (!(derout = BIO_new_file(asn1pars_config.derfile, "wb"))) {
+        if (cfg.derfile) {
+                if (!(derout = BIO_new_file(cfg.derfile, "wb"))) {
                         BIO_printf(bio_err, "problems opening %s\n",
-                            asn1pars_config.derfile);
+                            cfg.derfile);
                         ERR_print_errors(bio_err);
                         goto end;
                 }
@@ -304,16 +304,16 @@ asn1parse_main(int argc, char **argv)
         if (!BUF_MEM_grow(buf, BUFSIZ * 8))
                 goto end;       /* Pre-allocate :-) */
 
-        if (asn1pars_config.genstr || asn1pars_config.genconf) {
-                num = do_generate(bio_err, asn1pars_config.genstr,
-                    asn1pars_config.genconf, buf);
+        if (cfg.genstr || cfg.genconf) {
+                num = do_generate(bio_err, cfg.genstr,
+                    cfg.genconf, buf);
                 if (num < 0) {
                         ERR_print_errors(bio_err);
                         goto end;
                 }
         } else {
 
-                if (asn1pars_config.informat == FORMAT_PEM) {
+                if (cfg.informat == FORMAT_PEM) {
                         BIO *tmp;
 
                         if ((b64 = BIO_new(BIO_f_base64())) == NULL)
@@ -337,20 +337,20 @@ asn1parse_main(int argc, char **argv)
 
         /* If any structs to parse go through in sequence */
 
-        if (sk_OPENSSL_STRING_num(asn1pars_config.osk)) {
+        if (sk_OPENSSL_STRING_num(cfg.osk)) {
                 tmpbuf = (unsigned char *) str;
                 tmplen = num;
-                for (i = 0; i < sk_OPENSSL_STRING_num(asn1pars_config.osk);
+                for (i = 0; i < sk_OPENSSL_STRING_num(cfg.osk);
                      i++) {
                         ASN1_TYPE *atmp;
                         int typ;
                         j = strtonum(
-                            sk_OPENSSL_STRING_value(asn1pars_config.osk, i),
+                            sk_OPENSSL_STRING_value(cfg.osk, i),
                             1, INT_MAX, &errstr);
                         if (errstr) {
                                 BIO_printf(bio_err,
                                     "'%s' is an invalid number: %s\n",
-                                    sk_OPENSSL_STRING_value(asn1pars_config.osk,
+                                    sk_OPENSSL_STRING_value(cfg.osk,
                                     i), errstr);
                                 continue;
                         }
@@ -380,28 +380,28 @@ asn1parse_main(int argc, char **argv)
                 str = (char *) tmpbuf;
                 num = tmplen;
         }
-        if (asn1pars_config.offset >= num) {
+        if (cfg.offset >= num) {
                 BIO_printf(bio_err, "Error: offset too large\n");
                 goto end;
         }
-        num -= asn1pars_config.offset;
+        num -= cfg.offset;
 
-        if ((asn1pars_config.length == 0) ||
-            ((long)asn1pars_config.length > num))
-                asn1pars_config.length = (unsigned int) num;
+        if ((cfg.length == 0) ||
+            ((long)cfg.length > num))
+                cfg.length = (unsigned int) num;
         if (derout) {
-                if (BIO_write(derout, str + asn1pars_config.offset,
-                    asn1pars_config.length) != (int)asn1pars_config.length) {
+                if (BIO_write(derout, str + cfg.offset,
+                    cfg.length) != (int)cfg.length) {
                         BIO_printf(bio_err, "Error writing output\n");
                         ERR_print_errors(bio_err);
                         goto end;
                 }
         }
-        if (!asn1pars_config.noout &&
+        if (!cfg.noout &&
             !ASN1_parse_dump(out,
-            (unsigned char *)&(str[asn1pars_config.offset]),
-            asn1pars_config.length, asn1pars_config.indent,
-            asn1pars_config.dump)) {
+            (unsigned char *)&(str[cfg.offset]),
+            cfg.length, cfg.indent,
+            cfg.dump)) {
                 ERR_print_errors(bio_err);
                 goto end;
         }
@@ -415,7 +415,7 @@ asn1parse_main(int argc, char **argv)
                 ERR_print_errors(bio_err);
         BUF_MEM_free(buf);
         ASN1_TYPE_free(at);
-        sk_OPENSSL_STRING_free(asn1pars_config.osk);
+        sk_OPENSSL_STRING_free(cfg.osk);
         OBJ_cleanup();
 
         return (ret);