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);