C - Array value disappearing while setting the last at NULL - c

Question

I'm having a little problem with a (pretty big) c program and figured out that the problem does not come from my program itself but the way I create my array, I think.
My problem is the following, I need to create an array who's identical to the one containing environment variables (extern char **environ) and then add another value at the end.
Here is a code that I've done to check if the environ is well copied or not:
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
int ft_length(char **arr)
{
int i = 0;
while (arr[i])
i++;
return (i);
}
int main(void)
{
extern char **environ;
char **env;
int err;
int x;
err = 0;
x = 0;
env = (char**)malloc(sizeof(char*) * ft_length(environ) + 2);
while (environ[x])
{
// printf("%s\n", environ[x]);
env[x] = (char*)malloc(sizeof(char) * strlen(environ[x]) + 1);
bzero(env[x], strlen(environ[x]));
strncpy(env[x], environ[x], strlen(environ[x]));
// printf("%s\n", env[x]);
x++;
}
env[x] = (char*)malloc(sizeof(char) * 4);
env[x] = "ccc\0";
env[++x] = NULL;
x = 0;
while (environ[x])
{
if (strcmp(environ[x], env[x]) != 0)
{
err++;
printf("error on env[%d]\n", x);
printf("environ[%d] : |%s|\n", x, environ[x]);
printf("env[%d] : |%s|\n", x, env[x]);
printf("----------------\n");
}
x++;
}
while (env[x])
{
if (strcmp(env[x], "ccc") != 0)
{
err++;
printf("env[%d] contain |%s| instead of |ccc|\n", x, env[x]);
}
x++;
}
printf("done with %d error(s)\n", err);
return (1);
}
When I run this code on Mac OSX, env[0] is empty at the end, and that happen when I set the last array value to NULL (env[++x] = NULL). But, well, I need this one to be NULL if I want to print my array without segfault.
So, first I wanted to know if my code is wrong somewhere?
I tried to run this code on my Linux computer (Ubuntu 16.04) too and it seems there is no problem.

Answer 1

malloc(sizeof(char*) * ft_length(environ) + 2)
If you need two additional elements in the array, that'd be
malloc(sizeof(char*) * (ft_length(environ) + 2));
Or use calloc:
calloc (ft_length(environ) + 2, sizeof(char*));
In addition
env[x] = (char*)malloc(sizeof(char) * 4);
env[x] = "ccc\0";
is another pitfall everybody seems to fall in. You assign a pointer value to env[x], then immediately regret and assign another pointer value to it, forgetting the first one, creating a memory leak in process, and making your env impossible to free as the new string is not pointing to a dynamically allocated memory. This is particularly baffling as you seem to correctly (even if with much redundancy) copy a string a few lines earlier.
env[x] = malloc(4); // sizeof(char) is always one; casting not needed
// also see below
strcpy (env[x], "ccc"); // of course no `\0` is needed
Since you have code that dynamically allocates a copy of a string in two places, you may want to make this code into a function, or perhaps use an existing (albeit non-standard) function strdup. This is particularly important because there's no good way to copy a string literal otherwise.
env[x] = malloc(4);
strcpy (env[x], "ccc");
Assumes the length. What if the literal will change?
env[x] = malloc(strlen("ccc")+1);
strcpy (env[x], "ccc");
What if someone changes one literal and forgets the other?
const char ccc[] = "ccc";
env[x] = malloc(sizeof(ccc));
strcpy (env[x], ccc);
This works but you have an extra line that declares a variable. This doesn't sound like much but why?
env[x] = strdup("ccc");
Looks better, maintains better.
If you write your own strdup don't do this
out = (char*)malloc(sizeof(char) * strlen(in) + 1);
bzero(out, strlen(in));
strncpy(out, in, strlen(in));
but rather
out = malloc(strlen(in) + 1);
strcpy(out, in);
bzero is redundant because it will zero out exactly the bytes that strcpy will overwrite with non-zero values at the next line. The strncpy + strlen combo is plain wrong as it doesn't null-terminate the destination string. strncpy(out, in, strlen(in)+1) would be correct but redundant, as it does exactly the same thing as plain strcpy(out, in).