free allocated memory in function

Question

i have function which is written in c ,in this function i allocate 2 string as temp and found, but i cant free temp string. i think it may due to using of temp in result array. can any one helps me. here is the function.

void split(char* input, char* delim, char** result,int size) {

    char* tmp = malloc((strlen(input)) * sizeof(char));
    char* found = malloc((strlen(input)) * sizeof(char)); 
    
    tmp=strcpy(tmp, input);

    // #pragma omp parallel for
    for (int i=0; i<size; i++) {
        found = strstr(tmp, delim);
        if (found != NULL) {

            int length = found - tmp;
            result[i]=malloc((length+1) * sizeof(char));
            result[i] = strncpy(result[i], tmp, length);
            *(result[i] + length) = '\0';
            tmp = found + strlen(delim);

        } else {

            result[i]=malloc(strlen(tmp) * sizeof(char));
            result[i] =strncpy(result[i], tmp, strlen(tmp));
  
        }
    }

    // free(tmp);
    free(found);
}

here size is number of sub strings after split

when i remove the comment of this line: // free(tmp); then this err occurs:

munmap_chunk(): invalid pointer
Aborted (core dumped)

can i ask you to help me for writing correct split function

Answer 1

You do assignments to tmp. That means the pointer tmp might no longer point to the same location that malloc returned.

You need to pass the exact same pointer to free that was returned by malloc.

You have the same problem with found, you assign to it and possible change where it points.

Passing an invalid pointer to free leads to undefined behavior.

---

You also have another problem: You go out of bounds of the original memory allocated and pointed to by tmp. That's because you seem to have forgotten that strings in C are really called null-terminated strings.

When you allocate memory for a string, you need to include space for the null-terminator at the end. And it's not counted by strlen.

Going out of bounds of allocated memory also leads to undefined behavior.

Answer 2

The function does not make a sense.

For starters it invokes undefined behavior

char* tmp = malloc((strlen(input)) * sizeof(char));
char* found = malloc((strlen(input)) * sizeof(char)); 

tmp=strcpy(tmp, input);
//...

because you allocated to enough memory to store the terminating zero character '\0' of the string input in the character array tmp.

Secondly the function has a memory leak because at first memory was allocated and its address was assigned to the pointer found and then the pointer found was reassigned in the call of strstr in the for loop.

char* found = malloc((strlen(input)) * sizeof(char)); 

//...

// #pragma omp parallel for
for (int i=0; i<size; i++) {
    found = strstr(tmp, delim);
    //...  

So the address of the early allocated memory is lost and the memory can not be freed.

And this for loop

for (int i=0; i<size; i++) {

is just senseless.

You may not call free neither for tmp nor for found. The pointer found does not point to a dynamically allocated memory and the pointer tmp is being changed within the for loop.

Answer 3

here is my new function. i wrote it in recursive mode.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int get_number_of_occurence(char* string, char* delim) {

    char* found = strstr(string, delim);
 
    if(found == NULL || strcmp(found,delim) ==0 ||found =="" ){
        
        return 0;

    }else{
      
        return 1+get_number_of_occurence(found+strlen(delim), delim);
      
    }
}

int split(char* input, char* delim, char** result,int array_idx) {

    char* found= strstr(input, delim);

    if (found==""||strlen(input)==0){
        return 0;

    }else if(found == NULL){
    
        result[array_idx]=malloc(strlen(input)+1 * sizeof(char));
        strncpy(result[array_idx], input, strlen(input));
        *(result[array_idx] + strlen(input)) = '\0';
        return 0;

    }else{

        int length = found - input;
        result[array_idx]=malloc((length+1) * sizeof(char));
        strncpy(result[array_idx], input, length);
        *(result[array_idx] + length) = '\0';
        return split(found+strlen(delim),delim,result,array_idx+1); 
    }
}
int main () {

char * delim = "ooo";
char * input="ssooonn";

int size = get_number_of_occurence(input, delim);
printf("size is : %d \n",size);

char *splitted_values[size+1];

split(input, delim,splitted_values,0);

for (int i=0; i<(size+1); i++) {
    printf("%s\n",splitted_values[i]);
    free(splitted_values[i]);
}

}

in this code, first i count the number of occurrence of delimiter.

then i create array in that size and fill it with the help of split function.

thanks for helping.