Why am I getting a segmentation fault when I use switch-case statement with hash-strings? [closed] - c++

Question

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed last month.
Improve this question
I am trying to create a CLI (Command Line Interface). I currently don't have a good idea of what I want from it.
Note: The faults started appearing when I used a switch-case statement with hash-strings to run the commands. Also, there are no errors when compiled. The faults may start anywhere, because I have used printf to print a message representing argc and argv when the cli is run.
Below is the code I used:
codeycat.cpp
#include <map>
#include <iostream>
using namespace std;
static enum Functions {
undef,
comm_test,
comm_commands
} functions;
static map<string, Functions> mapStringValues;
static void Initialize();
bool samestr(const char *svar, const char *str)
{
if (strcmp(svar, str) == 0)
{
return true;
}
else
{
return false;
}
}
string construct_version(int major, int minor, int patch)
{
string strmajor = to_string(major);
string strminor = to_string(minor);
string strpatch = to_string(patch);
string version = strmajor + "." + strminor + "." + strpatch;
return version;
}
int test(string command)
{
int code = system(command.c_str());
return code;
}
void commands()
{
printf("(test, commands)\n");
}
int main(int argc, char *argv[])
{
string doc = "Usage: codeycat [options...] [function] [args...]\n"
"Options:\n"
"\t--help -h: Show this message and exit\n"
"\t--version -v: Show version and exit\n";
string version = construct_version(1, 0, 0);
printf("arg count: %d, args: %s %s %s", argc, argv[0], argv[1], argv[2]);
if (argc < 2)
{
printf("%s", doc.c_str());
return 1;
}
const char command[PATH_MAX] = {*argv[2]};
switch (mapStringValues[command])
{
case undef:
printf("Command not found: %s", command);
case comm_test:
test(argv[3]);
case comm_commands:
cout << "Hello" << endl;
// commands();
}
return 0;
}
void Initialize()
{
mapStringValues["undef"] = undef;
mapStringValues["test"] = comm_test;
mapStringValues["commands"] = comm_commands;
}
Running % ./codeycat of course returns a return code 1 (error), but running % ./codeycat with options --help, --version, -h, -v or running its functions don't work.
Here are the outputs:
./codeycat
arg count: 1, args: ./codeycat (null) COLORTERM=truecolorUsage: codeycat [options...] [function] [args...]
Options:
--help -h: Show this message and exit
--version -v: Show version and exit
./codeycat --help
[1] 12372 segmentation fault ./codeycat --help
./codeycat -h
[1] 12416 segmentation fault ./codeycat -h
./codeycat --version
[1] 12459 segmentation fault ./codeycat --version
./codeycat -v
[1] 12501 segmentation fault ./codeycat -v
./codeycat test 'echo Hello'
[1] 12544 segmentation fault ./codeycat test 'echo Hello'
./codeycat commands
[1] 12587 segmentation fault ./codeycat commands

Answer 1

You can't read from argv without first checking argc. argv is an array of length argc, so any index greater than or equal to argc is out of bounds. This line
printf("arg count: %d, args: %s %s %s", argc, argv[0], argv[1], argv[2]);
Doesn't crash because some printf implementations print "(null)" if you pass a null pointer to the %s specifier.
When you don't pass any arguments, you return early because argc is 1 and you print the doc and return 1.
However, when you do pass an argument, you don't return early, which means you reach this line
const char command[PATH_MAX] = {*argv[2]};
This crashes because you are reading from argv[2] when argc is less than 2. If you pass 2 CLI arguments, this line won't crash. Additionally, this doesn't create a string, it creates an array of size PATH_MAX with element 0 being the first character of argv[2]. If you want to index mapStringValues with argv[2], you need to create an std::string. Also, argv[2] is the second argument, so if you want the first argument to be the command(which is usually the case), then you should read from argv[1].
string command = argv[1];
Switch statement cases don't break automatically, which means that at the end of "case undef:", you will enter "case comm_test".
switch (mapStringValues[command])
{
case undef:
printf("Command not found: %s", command);
// this will fall through to case comm_test,
case comm_test:
test(argv[3]);
case comm_commands:
cout << "Hello" << endl;
// commands();
}
test(argv[3]) will be called even if the initial case is undef.
You need to add break statements to prevent the cases from falling through
switch (mapStringValues[command])
{
case undef:
printf("Command not found: %s", command);
// add break to prevent fallthrough
break;
case comm_test:
test(argv[3]);
break;
case comm_commands:
cout << "Hello" << endl;
break;
// commands();
}
Lastly, you never called Initialize(), so the map is always empty, meaning that every command will result in not being found. You need to call the Initialize() function to initialize the map