--- ./src/base32_prog.c_orig	2024-09-20 05:26:35.132738096 -0500
+++ ./src/base32_prog.c	2024-09-20 06:28:20.540547798 -0500
@@ -17,10 +17,14 @@
 
 #include "config.h"
 
+#ifndef _AIX
 #include <err.h>
+#endif
 #include <errno.h>
 #include <fcntl.h>
+#ifndef _AIX
 #include <getopt.h>
+#endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -28,6 +32,199 @@
 #include <sys/stat.h>
 
 #include "base32.h"
+
+#ifdef _AIX
+#define err(n, ...) \
+    { printf(__VA_ARGS__); \
+      _exit(1); \
+    } 
+
+#include <string.h>
+
+struct option
+{
+        const char *name;
+        int                     has_arg;
+        int                *flag;
+        int                     val;
+};
+
+#define no_argument 0
+#define required_argument 1
+#define optional_argument 2
+
+#define BADCH   '?'
+#define BADARG  ':'
+#define EMSG    ""
+
+
+/*
+ * getopt_long
+ *      Parse argc/argv argument vector, with long options.
+ *
+ * This implementation does not use optreset.  Instead, we guarantee that
+ * it can be restarted on a new argv array after a previous call returned -1,
+ * if the caller resets optind to 1 before the first call of the new series.
+ * (Internally, this means we must be sure to reset "place" to EMSG before
+ * returning -1.)
+ */
+int
+getopt_long(int argc, char *const argv[],
+                        const char *optstring,
+                        const struct option *longopts, int *longindex)
+{
+        static char *place = EMSG;      /* option letter processing */
+        char       *oli;                        /* option letter list index */
+
+        if (!*place)
+        {                                                       /* update scanning pointer */
+                if (optind >= argc)
+                {
+                        place = EMSG;
+                        return -1;
+                }
+
+                place = argv[optind];
+
+                if (place[0] != '-')
+                {
+                        place = EMSG;
+                        return -1;
+                }
+
+                place++;
+
+                if (place[0] && place[0] == '-' && place[1] == '\0')
+                {                                               /* found "--" */
+                        ++optind;
+                        place = EMSG;
+                        return -1;
+                }
+
+                if (place[0] && place[0] == '-' && place[1])
+                {
+                        /* long option */
+                        size_t          namelen;
+                        int                     i;
+
+                        place++;
+
+                        namelen = strcspn(place, "=");
+                        for (i = 0; longopts[i].name != NULL; i++)
+                        {
+                                if (strlen(longopts[i].name) == namelen
+                                        && strncmp(place, longopts[i].name, namelen) == 0)
+                                {
+                                        int                     has_arg = longopts[i].has_arg;
+
+                                        if (has_arg != no_argument)
+                                        {
+                                                if (place[namelen] == '=')
+                                                        optarg = place + namelen + 1;
+                                                else if (optind < argc - 1 &&
+                                                                 has_arg == required_argument)
+                                                {
+                                                        optind++;
+                                                        optarg = argv[optind];
+                                                }
+                                                else
+                                                {
+                                                        if (optstring[0] == ':')
+                                                                return BADARG;
+
+                                                        if (opterr && has_arg == required_argument)
+                                                                fprintf(stderr,
+                                                                                "%s: option requires an argument -- %s\n",
+                                                                                argv[0], place);
+
+                                                        place = EMSG;
+                                                        optind++;
+
+                                                        if (has_arg == required_argument)
+                                                                return BADCH;
+                                                        optarg = NULL;
+                                                }
+                                        }
+                                        else
+                                        {
+                                                optarg = NULL;
+                                                if (place[namelen] != 0)
+                                                {
+                                                        /* XXX error? */
+                                                }
+                                        }
+
+                                        optind++;
+
+                                        if (longindex)
+                                                *longindex = i;
+
+                                        place = EMSG;
+
+                                        if (longopts[i].flag == NULL)
+                                                return longopts[i].val;
+                                        else
+                                        {
+                                                *longopts[i].flag = longopts[i].val;
+                                                return 0;
+                                        }
+                                }
+                        }
+
+                        if (opterr && optstring[0] != ':')
+                                fprintf(stderr,
+                                                "%s: illegal option -- %s\n", argv[0], place);
+                        place = EMSG;
+                        optind++;
+                        return BADCH;
+                }
+        }
+
+       /* short option */
+       optopt = (int) *place++;
+
+        oli = strchr(optstring, optopt);
+        if (!oli)
+        {
+                if (!*place)
+                       ++optind;
+                if (opterr && *optstring != ':')
+                        fprintf(stderr,
+                                        "%s: illegal option -- %c\n", argv[0], optopt);
+                return BADCH;
+        }
+
+        if (oli[1] != ':')
+        {                                                       /* don't need argument */
+                optarg = NULL;
+                if (!*place)
+                        ++optind;
+        }
+        else
+        {                                                       /* need an argument */
+                if (*place)                             /* no white space */
+                        optarg = place;
+                else if (argc <= ++optind)
+                {                                               /* no arg */
+                        place = EMSG;
+                        if (*optstring == ':')
+                                return BADARG;
+                        if (opterr)
+                                fprintf(stderr,
+                                                "%s: option requires an argument -- %c\n",
+                                                argv[0], optopt);
+                        return BADCH;
+                }
+                else
+                        /* white space */
+                        optarg = argv[optind];
+                place = EMSG;
+                ++optind;
+        }
+        return optopt;
+}
+#endif
+
 
 /*
  * Convert arbitrary input from a file to base-32 encoded output on stdout.
