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

#include <polarssl/base64.h>

/* Remarks regarding the "Flawfinder: ignore" comments in this file:
 *
 * - strlen:
 *
 *   It's true that strlen might crash if input is not null
 *   terminated.  But by design there is not safe way to get the
 *   length of an string in C, and defining an additional length
 *   parameter for string parameter will only transfere the problem to
 *   the caller.
 */

static void
out_of_core(void)
{
    fputs("\nfatal: out of memory\n", stderr);
    exit(2);
}
void *
xmalloc( size_t n )
{
    void *p = malloc( n );
    if( !p )
        out_of_core();
    return p;
}

void *
xrealloc( void *a, size_t n )
{
    void *p = realloc( a, n );
    if( !p )
        out_of_core();
    return p;
}

char *
xstrndup( const char *string, const size_t len )
{
    char *p = xmalloc( len + 1 );
    memcpy( p, string, len );
    p[len] = '\0';
    return p;
}

unsigned int
strv_length (char **str_array)
{
    unsigned int i = 0;

    if (!str_array)
        return 0;

    while (str_array[i])
        ++i;

    return i;
}

void strv_append (char ***pArray, const char *string, const size_t len)
{
    unsigned int old_len = 0;

    if (!*pArray) {
        *pArray = xmalloc(2 * sizeof(char*));
        (*pArray)[0] = xstrndup(string, len);
        (*pArray)[1] = NULL;
        return;
    }
    old_len = strv_length(*pArray);
    *pArray = xrealloc(*pArray, sizeof(char**) * (old_len + 2));

    (*pArray)[old_len] = xstrndup(string, len);
    (*pArray)[old_len + 1] = NULL;
}

void
str_append_str(char **pDst, size_t *dst_len, const char *appendage, const size_t len)
{
    if (!appendage)
        return;

    if (!(*pDst)) {
        *pDst = xstrndup(appendage, len);
        *dst_len = len;
    } else {
        size_t new_size = (*dst_len) + len + 1;
        char *p_old = *pDst;
        *pDst = xmalloc(new_size);
        strncpy(*pDst, p_old, *dst_len);
        strncpy(*pDst + *dst_len, appendage, len);
        *dst_len = new_size - 1;
        (*pDst)[*dst_len] = '\0';
        free (p_old);
    }
}

void
strv_free (char **str_array)
{
  if (str_array)
    {
      int i;

      for (i = 0; str_array[i] != NULL; i++)
        free (str_array[i]);

      free (str_array);
    }
}

bool
str_equal (char *s1, char *s2)
{
  size_t l1 = strlen(s1);       /* Flawfinder: ignore */
  size_t l2 = strlen(s2);       /* Flawfinder: ignore */
  if ((l1 == l2) &&
      (strcmp(s1, s2) == 0))
    return true;
  else
    return false;
}

bool
str_starts_with (char *s1, char *s2)
{
  size_t l2 = strlen(s2);       /* Flawfinder: ignore */
  if (strncmp(s1, s2, l2) == 0)
    return true;
  else
    return false;
}

void
str_trim (char **s)
{
  size_t i;
  if (*s != NULL)
    {
      while (isspace(**s))
        (*s)++;
      i = strlen(*s);           /* Flawfinder: ignore */
      while (isspace((*s)[--i]))
        (*s)[i] = '\0';
    }
}

int str_base64_decode(char **dst, size_t *dst_size, char *src,
                      size_t src_size)
{
    int ret = -1;

    if (!dst || *dst) {
        return -1;
    }

    /* Check the needed size for the buffer */
    ret = base64_decode(NULL, dst_size,
                        (unsigned char *)src, src_size);

    if (ret != 0 && ret != POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL) {
        return ret;
    }

    *dst = xmalloc(*dst_size);
    memset (*dst, 0, *dst_size);

    ret = base64_decode((unsigned char *)*dst, dst_size,
                        (unsigned char *)src, src_size);
    if (ret) {
        free (*dst);
        *dst = NULL;
        *dst_size = 0;
    }
    return ret;
}