Why does C getopt_long_only() not set optopt for unknown option?

Question

I am trying to use getopt_long_only() with custom error messages. The code is shown below. I tried setting opterr=0 and using a colon at the start of the optstring to disable built-in error messages. I added a block of code controlled with boolean optoptWorks = true to try to customize error messages, for example to print a message when a bad option like -z is used. However optopt is always set to 0 and the ? error message that I am using does not make sense. The ':' (colon case) errors (missing argument such as -d ) does work OK for custom messages. Turning built-in error messages off and handling in ? seems to result in optopt always being set to 0 so I can't print the offending option ( -z is not recognized ). I compiled on Debian Linux gcc 4.9.4 and also Cygwin gcc 7.3.0 and both give the same result. It seems like getopt_long_only() may not set optopt properly or am I missing something? Many examples on the web get around this by either using the built-in error messages or just printing usage without telling the user which option is not recognized.

Here is output with optoptWorks=false :

$ ./testoptget -z
testoptget: unknown option -- z

-d #            Set the debug level.
-h, --help      Print program usage.
-q              Run in quiet mode (log messages to syslog but not console).
-v, --version   Print program version.

$ ./testoptget -d
testoptget: option requires an argument -- d

-d #            Set the debug level.
-h, --help      Print program usage.
-q              Run in quiet mode (log messages to syslog but not console).
-v, --version   Print program version.

and here is output with optoptWorks=true :

$ ./testoptget -z
[ERROR] Unknown option character '\x0'.

-d #            Set the debug level.
-h, --help      Print program usage.
-q              Run in quiet mode (log messages to syslog but not console).
-v, --version   Print program version.

$ ./testoptget -d
[ERROR] Option '-d' is missing argument.

-d #            Set the debug level.
-h, --help      Print program usage.
-q              Run in quiet mode (log messages to syslog but not console).
-v, --version   Print program version.

The code follows:

/*
Test program for getopt_long_only
*/

#include <ctype.h>
#include <getopt.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int debug = 0; /* Default to not debugging */

/**
Print the program usage.
*/
void usage(void)
{
    /* Print the program name and version */
    printf("\n");
    printf("-d #            Set the debug level.\n");
    printf("-h, --help      Print program usage.\n");
    printf("-q              Run in quiet mode (log messages to syslog but not console).\n");
    printf("-v, --version   Print program version.\n\n");
    exit(0);
}

/**
Parse command line parameters and set data for program.
@param argc number of command line parameters
@param argv list of command line parameters
*/
void parseargs(int argc,char **argv)
{   /*
    See:  https://www.gnu.org/software/libc/manual/html_node/Getopt.html#Getopt
    See:  http://man7.org/linux/man-pages/man3/getopt.3.html

    Because legacy -version and --version need to be supported, use getopts_long_only.
    */

    /*
    The meaning of the following is:
    name - the name of the long option
    has_arg - whether the option has an argument like --arg param or --arg=param
    flag - the numeric value to return (set to "opt" below), if NULL or zero, return "val"
    val - the value to return (set to "opt" below) if "flag" not set, use the one-character equivalent
    */
    static struct option long_options[] = {
        { "help",    no_argument, 0, 'h' }, /* returns as if -v, index not needed */
        { "version", no_argument, 0, 'v' }, /* returns as if -h, index not needed */
        { 0,         0,           0, 0 }    /* last element of array must be zeros */
    };
    int long_index = 0;
    int opt;
    int errorCount = 0;
    /* In <unistd.h>:  external int optind, opterr, optopt */
    bool optoptWorks = false;  /* Apparently optopt gets set to 0 for unknown argument so let the getopt_long_only print the error */
    char optstring[32] = "d:hqv";
    if ( optoptWorks ) {
        /*
        If getopt_long_only works as it is supposed to...
        Set opterr to zero so getopt calls won't print an error - check for errors in '?' return value
        Also use : as first character of optstring to cause : to be used for error handling
        */
        opterr = 0;
        /* Do the following because strcat is not safe on overlapping strings */
        char optstring2[32];
        strcpy(optstring2,optstring);
        strcpy(optstring,":");
        strcat(optstring,optstring2);
    }
    while((opt = getopt_long_only(argc, argv, optstring, long_options, &long_index)) != -1) {
        switch (opt) { /* Will match single character option or long_options val or flag */
            case 'd':
                /* -d #, Set the debug level to the argument value */
                debug = atoi(optarg);
                break;
            case 'h':
                /*
                -h, print the usage and exit
                -help
                --help
                */
                usage();
                exit(0);
                break;
            case 'q':
                /* -q, indicate that messages should not be printed to stdout */
                break;
            case 'v':
                /*
                -v, print the version via standard function,
                -version
                --version
                */
                break;
            case ':':
                /*
                This is an error indicator indicated by : at the start of get_opt_long 3rd argument.
                Handle missing argument, such as -d but no argument.
                */
                fprintf(stderr, "[ERROR] Option '-%c' is missing argument.\n", optopt);
                ++errorCount;
                break;
            case '?':
                /*
                Handle unknown parameters as per getopt man page example.
                "optopt" should contain the offending argument, but perhaps matches last long argument (zero record).
                Note that legacy ? command line parameter is no longer supported.
                */
                if (isprint(optopt)) {
                    /* Printable character so print it in the warning. */
                    if ( optoptWorks ) {
                        fprintf(stderr, "[ERROR] Unknown option '-%c'.\n", optopt);
                    }
                    ++errorCount;
                }
                else {
                    /* Nonprintable character so show escape sequence. */
                    if ( optoptWorks ) {
                        fprintf(stderr, "[ERROR] Unknown option character '\\x%x'.\n", optopt);
                    }
                    ++errorCount;
                }
                break;
        } /* end switch */
    } /* end while */
    if ( errorCount > 0 ) {
        usage();
        exit(1);
    }
}

/**
Main program.
@param argc number of command line parameters
@param argv list of command line parameters
@param arge list of environment variables
*/
int main(int argc,char **argv,char **arge)
{
    /* Parse command arguments */
    parseargs(argc,argv);

    /* Normal program termination */
    return(0);
}

Answer 1

optopt is indeed set to zero when unknown long option is found, see here . However seems to me you can use optind - 1 as the index in argv to print the offending option, as optind is incremented here right before getopt returns '?' .

As far as I understood, your goal is to just specify custom error messages.

Also from man getopt_long:

If the first character (following any optional '+' or '-' described above) of optstring is a colon (':'), then getopt() likewise does not print an error message. In addition, it returns ':' instead of '?' to indicate a missing option argument. This allows the caller to distinguish the two different types of errors.

The documentation you referenced is about getopt not about getopt_long_only . The man getopt_long_only indeed says that getopt_long() function works like getopt() but the optopt is set to the "option character". In case of long options there is no "option character" but an "option string" (as I would call it) - seems to me logical to set optopt as zero.

So depending on the initial character in optstring, the : or ? is returned, as implemented here and here and here .

The following program is your's with comments removed, shorted usage function, substituted exit for return and added printing offending option with just printf("%s", argv[opting - 1]); :

#include <ctype.h>
#include <getopt.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int debug = 0;

void usage(void) { printf("-- insert usage here --\n"); }

void parseargs(int argc,char **argv)
{
    static struct option long_options[] = {
        { "help",    no_argument, 0, 'h' },
        { "version", no_argument, 0, 'v' },
        { 0,         0,           0, 0 }
    };
    int long_index = 0;
    int opt;
    int errorCount = 0;

    optind = 1;

    while((opt = getopt_long_only(argc, argv, ":d:hqv", long_options, &long_index)) != -1) {
        switch (opt) {
            case 'd':
                debug = atoi(optarg);
                break;
            case 'h':
                usage();
                return;
                break;
            case 'q':
                break;
            case 'v':
                break;
            case ':':
                fprintf(stderr, "[ERROR] Option '-%c' is missing argument.\n", optopt);
                ++errorCount;
                break;
            case '?':
                if (optopt == 0) {
                    fprintf(stderr, "[ERROR] Unknown option '%s'.\n", argv[optind - 1]);
                } else {
                    fprintf(stderr, "[ERROR] Error parsing option '-%c'\n", optopt);
                }
                ++errorCount;
                break;
        }
    }
    if ( errorCount > 0 ) {
        usage();
        return;
    }
}

int main(int argc, char **argv)
{

#define SIZE(x) (sizeof(x)/sizeof(*x))
    struct {
        int argc;
        char **argv;
    } tests[] = {
        { 2, (char*[]){ argv[0], (char[]){"-z"}, NULL, } },
        { 2, (char*[]){ argv[0], (char[]){"-d"},  NULL, } },
    };

    for (int i = 0; i < SIZE(tests); ++i) {
        printf("\n## test tests[i].argv[1] = %s\n", tests[i].argv[1]);
        parseargs(tests[i].argc, tests[i].argv);
    }

    return 0;
}

Outputs:

## test tests[i].argv[1] = -z
[ERROR] Unknown option '-z'.
-- insert usage here --

## test tests[i].argv[1] = -d
[ERROR] Option '-d' is missing argument.
-- insert usage here --

If optstring is set to "d:hqv" without the leading : , then it falls into the ? case, ie. then the program returns:

## test tests[i].argv[1] = -z
./a.out: unrecognized option '-z'
[ERROR] Unknown option '-z'.
-- insert usage here --

## test tests[i].argv[1] = -d
./a.out: option requires an argument -- 'd'
[ERROR] Error parsing option '-d'
-- insert usage here --