fgets and chdir acting strangely together in C

Question

I am currently creating a simple shell for homework and I've run into a problem. Here is a snippet of code with the pieces that pertain to the problem (I may have forgotten some pieces please tell me if you see anything missing):

eatWrd returns the first word from a string, and takes that word out of the string.

wrdCount, as implied, returns the number of words in a string.

if either of these codes are necessary for a response I can post them, just please tell me, I am almost 100% positive they are not the cause of the problem.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAX 100

int main(void)
{
  char input[MAX];
  char *argm[MAX];
  memset(input, 0, sizeof(input));
  memset(argm, 0, sizeof(argm));

  while(1){
    printf("cmd:\n");
    fgets(input, MAX-1, stdin);

    for(i=0;i < wrdCount(input); i++){
      argm[i] = eatWrd(input);
    }
    argm[i] = NULL;

    if (!strncmp(argm[0],"cd" , 2)){
      chdir(argm[1]);
    }

    if (!strncmp(argm[0],"exit", 4)){
      exit(0);
    }

    memset(input, 0, sizeof(input));
    memset(argm, 0, sizeof(argm));
  }
}

Anyways, this loop works for lots of other commands using execvp, (such as cat, ls, etc.), when I use cd, it works as expected, except when I try to exit the shell, it takes multiple exit calls to actually get out. (as it turns out, the number of exit calls is exactly equal to the number of times I call cd). It only takes one exit call when I don't use cd during a session. I'm not really sure what's going on, any help is appreciated, thanks.

Here is eatWrd:

char* eatWrd(char * cmd)
{
  int i = 0;            // i keeps track of position in cmd
  int count = 0;        // count keeps track of position of second word
  char rest[MAX_LINE];  // rest will hold cmd without the first word

  char * word = (char *) malloc(MAX_LINE);   //word will hold the first word
  sscanf(cmd, "%s", word);                   //scan the first word into word

  // iterate through white spaces, then first word, then the following white spaces
  while(cmd[i] == ' ' || cmd[i] == '\t'){
    i++;
    count++;
  }

  while(cmd[i] != ' ' && cmd[i] != '\t' && cmd[i] != '\n' && cmd[i] != '\0'){
    i++;
    count++;
  }

  while(cmd[i] == ' ' || cmd[i] == '\t'){
    i++;
    count++;
  }

  // copy the rest of cmd into rest
  while(cmd[i] != '\n' && cmd[i] != '\0'){
    rest[i-count] = cmd[i];
    i++;
  }
  rest[i-count] = '\0';

  memset(cmd, 0, MAX_LINE);
  strcpy(cmd, rest);        //move rest into cmd
  return word;              //return word
}

And here is wrdCount:

int wrdCount(char *sent)
{
  char *i = sent;
  int words = 0;

  //keep iterating through the string, 
  //increasing the count if a word and white spaces are passed,
  // until the string is finished.
  while(1){
    while(*i == ' ' || *i == '\t') i++;

    if(*i == '\n' || *i == '\0') break;

    words++;

    while(*i != ' ' && *i != '\t' && *i != '\n' && *i != '\0') i++;
  }
  return words;
}

Answer 1

This variation on your code works for me:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <unistd.h>
#define MAX 100

char *eatWrd(char **line) {
    char *next_c = *line;
    char *word_start = NULL;

    while (isspace(*next_c)) next_c += 1;

    if (*next_c) {
        word_start = next_c;
        do {
            next_c += 1;
        } while (*next_c && ! isspace(*next_c));
        *next_c = '\0';
        *line = next_c + 1;
    }

    return word_start;
}

int main(void)
{
    char input[MAX];
    char *argm[MAX];

    while(1) {
        int word_count = 0;
        char *next_input = input;

        printf("cmd:\n");
        fgets(input, MAX, stdin);

        do {
              argm[word_count] = eatWrd(&next_input);
        } while (argm[word_count++]);
        /* The above always overcounts by one */
        word_count -= 1;

        if (!strcmp(argm[0], "cd")){
            chdir(argm[1]);
        } else if (!strcmp(argm[0], "exit")) {
            exit(0);
        }
    }
}

Note my variation on eatWrd(), which does not have to move any data around, and which does not require pre-parsing the string to determine how many words to expect. I suppose your implementation would be more complex, so as to handle quoting or some such, but it could absolutely follow the same general approach.

Note, too, my correction to the command-matching conditions, using !strcmp() instead of strncmp().