Test functions

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

size_t count(char **array);
char **explode(char *delimeter, char *string);

void GET_INIT(void);
char *GET_VALUE(char *arg);

char ***GET_ARGS;

int main(int argc, char *argv[])
{
    GET_INIT();

    printf("%s\n", GET_VALUE("a"));

    return 0;
}

char **explode(char *delimeter, char *string)
{
    char *token;
    size_t size = 2;
    size_t str_size = 0;
    size_t position = 0;
    char **array = malloc(sizeof(char *) * size);

    if (array == NULL)
        exit(EXIT_FAILURE);

    if (strlen(string) != 0)
    {
        while (token = strtok_r(string, delimeter, &string))
        {
            array[position] = malloc(str_size);
            if (array[position] == NULL)
                exit(EXIT_FAILURE);
            strcpy(array[position], token);
            position++;
            size++;
            array = realloc(array, sizeof(char *) * size);
            if (array == NULL)
                exit(EXIT_FAILURE);
        }
    }

    array[position] = NULL;

    return array;
}

size_t count(char **array)
{
    size_t i = 0;
    while (array[i] != NULL)
        i++;

    return i;
}

void GET_INIT(void)
{
    char **array = explode("&", getenv("QUERY_STRING"));
    char **tmp_array = NULL;
    size_t size = count(array);
    int pos = 0;

    GET_ARGS = malloc(size + 1);

    if (GET_ARGS == NULL)
        exit(EXIT_FAILURE);

    for (pos; pos < size; pos++)
    {
        tmp_array = explode("=", array[pos]);
        if (tmp_array != NULL)
        {
            GET_ARGS[pos] = malloc(sizeof(char *) * 2);
            if (GET_ARGS[pos] == NULL)
                exit(EXIT_FAILURE);

            if (tmp_array[0] == NULL)
            {
                GET_ARGS[pos][0] = NULL;
            }
            else
            {
                GET_ARGS[pos][0] = malloc(strlen(tmp_array[0]) + 1);
                if (GET_ARGS[pos][0] == NULL)
                    exit(EXIT_FAILURE);
                strcpy(GET_ARGS[pos][0], tmp_array[0]);
            }

            if (tmp_array[1] == NULL)
            {
                GET_ARGS[pos][1] = NULL;
            }
            else
            {
                GET_ARGS[pos][1] = malloc(strlen(tmp_array[1]) + 1);
                if (GET_ARGS[pos][1] == NULL)
                    exit(EXIT_FAILURE);
                strcpy(GET_ARGS[pos][1], tmp_array[1]);
            }
        }
    }

    GET_ARGS[pos] = NULL;

    if (tmp_array != NULL)
    {
        free(tmp_array);
    }
    free(array);
}

char *GET_VALUE(char *arg)
{
    for (int i = 0; GET_ARGS[i] != NULL; i++)
    {
        if (!strcmp(GET_ARGS[i][0], arg))
        {
            if (GET_ARGS[i][1] == NULL)
            {
                return NULL;
            }
            else
            {
                return GET_ARGS[i][1];
            }
        }
    }

    return NULL;
}