C99: Why is my string changing?

Question

I have a function that is basically a rewritten strtok_r because that function is causing me grief.

char *betterStrtok(char *str, char *delim, char **loc)
{
    int iter = 0;
    char *tmp;
    if(str)
    {
        char mod[strlen(str) + 2];
        char *out = malloc(strlen(str) + 2);
        char curr = str[0];
        strcpy(mod, str);
        while(curr)
        {
            tmp = strchr(delim, curr);
            if(tmp)
            {
                mod[iter] = 0;
                strcpy(out, mod);
                *loc = &mod[iter + 1];
                //printf("Inside function: \"%s\"\n", *loc);
                return out;
            }
            if(curr)
            {
                curr = mod[++iter];
            }
            else
            {
                *loc = &mod[0];
                strcpy(out, mod);
                return out;
            }
        }
        return NULL;
    }
    else
    {
        char mod[strlen(*loc) + 2];
        strcpy(mod, *loc);
        char *tloc = malloc(sizeof loc + 2);
        char *out = malloc(strlen(*loc) + 2);
        char curr = mod[0];
        while(curr)
        {
            tmp = strchr(delim, curr);
            if(tmp)
            {
                mod[iter] = 0;
                strcpy(out, mod);
                tloc = &mod[iter + 1];
                strcpy(*loc, tloc);
                return out;
            }
            if(curr)
            {
                curr = mod[++iter];
            }
            else
            {
                *loc = &mod[0];
                strcpy(out, mod);
                return out;
            }
        }
        return NULL;
    }
}

So my issue is *loc has the appropriate thing in it after the first pass, and when I check what's in it outside the function, it's mostly there except the last character is something weird. Let's say this is the setup:

char *addr = malloc(60);
char **supaddr = &addr;
char *strtotok = "Hello, world!";
char *thetok;
thetok = betterStrtok(strtotok, ",", supaddr);
printf("Outside function: \"%s\"\n", addr);

Adding print statements right before the return and right after calling the function shows something like this:

Inside function: " world!"
Outside function: " w"

The question is: how can I prevent the string from changing or how can I do something else so I can save the "rest" of the original string without returning it?

Answer 1

If you start replacing standard library (or POSIX) functions with your own implementations, first look hard at how the facility is used. For example, compare fgets() and getline().

If I were you, I'd probably use

size_t  extract_token(const char *src_ptr, const size_t src_len,
                      char **token_ptr, size_t *token_size, size_t *token_len);

which extracts a token from a src_len -byte buffer at src_ptr. (Unlike string-based methods, this can handle embedded nul bytes.)

The return value is the number of characters consumed from src_ptr. The token is copied (expanded?) to dynamically allocated token_ptr. The allocated length is in token_size, and the length of the token in token_len.

If extract_token() encounters only whitespace but no token, it returns the number of whitespace chars consumed, with zero assigned to token_len. For simplicity, let's assume the function always sets errno; to zero if success, to a nonzero error code if an error occurs.

A simple loop that tokenizes lines read from standard input would be

char   *line_ptr = NULL;
size_t  line_size = 0;
ssize_t line_len;
long    line_num = 0;

char   *token_ptr = NULL;
size_t  token_size = 0;
size_t  token_len;

char   *cur, *end;
size_t  n;

while (1) {

    line_len = getline(&line_ptr, &line_size, stdin);
    line_num++;

    if (line_len < 1) {
        if (ferror(stdin) || !feof(stdin)) {
            fprintf(stderr, "Standard input: Line %ld: Read error.\n", line_num);
            return EXIT_FAILURE;
        }
        break;
    }

    cur = line_ptr;
    end = line_ptr + line_len;

    while (1) {

        if (cur >= end) {
            errno = 0;
            cur = end;
            break;
        }

        n = extract_token(cur, (size_t)(end - cur),
                          &token_ptr, &token_size, &token_len);
        if (errno) {
            /* cur + n is the offending character in input */
            fprintf(stderr, "Standard input: Line %ld: Cannot tokenize line.\n", line_num);
            exit(EXIT_FAILURE);
        }

        /* Do something with token;
            token_ptr  points to the token,
            token_len  is the length of the token
            token_size is the size allocated for the token
        */
    }                
}

/* Since the line and token buffers are no longer needed,
   free them. I like to clear the variables too, just in
   case.
*/
free(line_ptr);
line_ptr = NULL;
line_size = 0;

free(token_ptr);
token_ptr = NULL;
token_size = 0;

Note that when reading files with clear record-and-field formatting, like CSV files, I do prefer to read the tokens directly from the file using a getline()-like interface, either

int next_field(char **ptr, size_t *size, size_t *len, FILE *in);
int next_record(FILE *in);

or

int next_wfield(wchar_t **ptr, size_t *size, size_t *len, FILE *in);
int next_wrecord(FILE *in);

where next_field() (or next_wfield() for wide input) obtains the next field in the current record, preferably handling de-quoting and de-escaping, and next_wrecord() skips any leftover fields in the current record, and moves to the beginning of next record.

Using fgetc() or fgetwc() the code implementing the above is quite straightforward (even if CSV quoting rules are implemented), although it won't be as fast as possible using more advanced methods. Because CSV and other such file formats are not optimal anyway, the slight loss in speed is normally neglible/unnoticeable. Most importantly, if you try it out, you'll see that code that uses next_field()/next_record() is quite robust, and easy to read, write, and maintain in the long term.

Answer 2

The answer was in the comments. Turns out if I changed mod to a pointer it worked perfectly.