Having a problem with Field validation in Ncurses form - c++

Question

I'm having some problems with field validation in a ncurses form, that hopefully someone have an explanation for.
The issue is with the below attached code. Specifically in the field called 'AuthorityCode' in the function validateField().
The ENUM Auth_codes is set to it's three values and when entering correct values (one of the enum values) it works fine. It also validates most of the incorrect values (values not in the ENUM). However, for some reason it accepts a single number '1', '2', '3', '4', '5', '6' or '8' in the field, but not a '7' or '9'. It doesn't seem like any single letter gets accepted and also not any combination of more than one number, only the above numbers.
All the other validations (including other enums), seems to be working as they should.
Does anyone have an explanation for this behaviour or can find a problem in my code?
const char* Auth_codes[]
{ "Add", "Update", "Delete" };
const char* Return_codes[]
{ "Accepted", "Denied" };
const char* Priorities[]
{ "3", "5", "6", "8" };
void createForm(WINDOW *win_body, vector<string> &input, int selection)
{
int rows;
int cols;
int i;
int cury = 0;
int curx = 1;
int nb_fields;
WINDOW *inner;
formClose = false;
getmaxyx(win_body, rows, cols);
nb_fields = input.size()
fields = (FIELD**) malloc(sizeof(FIELD *) * (nb_fields + 1));
assert(fields);
for (i = 0; i < nb_fields; i++)
{
fields[i] = new_field(1, 10, cury, curx, 0, 0);
assert(fields[i] != NULL);
set_field_buffer(fields[i], 0, "");
field_opts_on(fields[i], O_ACTIVE);
field_opts_on(fields[i], O_EDIT);
field_opts_off(fields[i], O_AUTOSKIP);
set_field_back(fields[i], A_UNDERLINE);
validateField(fields[i], input[i].c_str()); // Set correct field validation based on label value
curx = 1; // Set position for next label field
cury = cury + 1; // Next line
}
fields[i] = NULL;
form = new_form(fields);
assert(form != NULL);
win_form = derwin(win_body, rows - 10, cols - 4, 3, 2);
box(win_form, 0, 0);
assert(form != NULL && win_form != NULL);
set_form_win(form, win_form);
inner = derwin(win_form, form->rows + 1, form->cols + 1, 1, 1);
assert(inner != NULL);
set_form_sub(form, inner);
assert(post_form(form) == E_OK);
assert(post_menu(menu) == E_OK);
refresh();
wrefresh(win_body);
wrefresh(win_form);
while (formClose == false)
process_input(getch());
delete_form();
}
void validateField(FIELD *field, const char *name)
{
if (strcmp(name, "AdviceNoteNumber") == 0)
{
set_field_type(field, // Field to alter
TYPE_ALNUM, // Type to associate
0); // Minimum field width
}
else if (strcmp(name, "AssignmentId") == 0 || strcmp(name, "AssignmentReferenceId") == 0
|| strcmp(name, "TransportAssignmentId") == 0)
{
set_field_type(field, // Field to alter
TYPE_INTEGER, // Type to associate
0, // Number of padding zeroes
10000, // Min value
99999); // Max value
}
else if (strcmp(name, "AuthorityCode") == 0)
{
set_field_type(field, // Field to alter
TYPE_ENUM, // Type to associate
Auth_codes, // List of values
0, // Not case sensitive
1); // Unique prefix
}
else if (strcmp(name, "ReturnCode") == 0)
{
set_field_type(field, // Field to alter
TYPE_ENUM, // Type to associate
Return_codes, // List of values
0, // Not case sensitive
1); // Unique prefix
}
else if (strcmp(name, "Priority") == 0)
{
set_field_type(field, // Field to alter
TYPE_ENUM, // Type to associate
Priorities, // List of values
0, // Not case sensitive
1); // Unique prefix
}

Answer 1

set_field_type(field, // Field to alter
TYPE_ENUM, // Type to associate
Priorities, // List of values
0,
1); // Unique prefix
The third parameter to set_field_type is a list of acceptable enum values, specified as a char **.
That can't be a list of pointers of some unspecified size. Clearly, the number of acceptable enum values, the number of pointers here, has to be defined in some form or fashion. It is not explicitly called out in set_field_types documentation how the number of acceptable enum values is defined, this is just a char ** parameter. But it is an accepted practice, in C and C++, to assume that a list of pointers is terminated by a NULL pointer; part of a textbook's typical definition of what NULL pointer means falls, somewhat, within those boundaries. set_field_type's documentation implies this.
const char* Priorities[]=
{ "3", "5", "6", "8" };
The parameter is a list of four char *s, that gets passed as is. By the time it makes it into set_field_type it's just some char ** value. There's nothing here that explicitly defines it as four pointers, so set_field_type tries to figure out how many enum values there is, starts looking here, counts four pointers, then keeps counting, and counting, forging ahead into random memory, attempting to interpret each value as one char * after another, until it hits something that it thinks is a NULL value, somewhere, and in the meantime attempts to interpret each intermediate value as a char *, pointing to somewhere.
If it doesn't crash by now, it'll start seeing phantom valid enum values, leading to demons flying out of your nose.