/*

   Unix SMB/CIFS implementation.

   Samba utility functions

   Copyright (C) Andrew Tridgell 1992-2001

   Copyright (C) Simo Sorce      2001-2002

   Copyright (C) Martin Pool     2003

   Copyright (C) James Peach   2005

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "replace.h"

#include "lib/util/samba_util.h"

#include "system/locale.h"

#include "smb_strtox.h"

#undef strncasecmp

#undef strcasemp

/**

 * @file

 * @brief String utilities.

 **/

/**

 * Parse a string containing a boolean value.

 *

 * val will be set to the read value.

 *

 * @retval true if a boolean value was parsed, false otherwise.

 */

_PUBLIC_ bool conv_str_bool(const char * str, bool * val)

{

  char *  end = NULL;

  long  lval;

  if (str == NULL || *str == '\0') {

    return false;

  }

  lval = strtol(str, &end, 10 /* base */);

  if (end == NULL || *end != '\0' || end == str) {

    return set_boolean(str, val);

  }

  *val = (lval) ? true : false;

  return true;

}

/**

 * Convert a size specification like 16K into an integral number of bytes.

 **/

_PUBLIC_ bool conv_str_size_error(const char * str, uint64_t * val)

{

  char *        end = NULL;

  unsigned long long  lval;

  int error = 0;

  if (str == NULL || *str == '\0') {

    return false;

  }

  lval = smb_strtoull(str, &end, 10, &error, SMB_STR_STANDARD);

  if (error != 0) {

    return false;

  }

  if (*end) {

    if (strwicmp(end, "K") == 0) {

      lval *= 1024ULL;

    } else if (strwicmp(end, "M") == 0) {

      lval *= (1024ULL * 1024ULL);

    } else if (strwicmp(end, "G") == 0) {

      lval *= (1024ULL * 1024ULL * 1024ULL);

    } else if (strwicmp(end, "T") == 0) {

      lval *= (1024ULL * 1024ULL * 1024ULL * 1024ULL);

    } else if (strwicmp(end, "P") == 0) {

      lval *= (1024ULL * 1024ULL * 1024ULL * 1024ULL * 1024ULL);

    } else {

      return false;

    }

  }

  *val = (uint64_t)lval;

  return true;

}

/**

 * Parse a uint64_t value from a string

 *

 * val will be set to the value read.

 *

 * @retval true if parsing was successful, false otherwise

 */

_PUBLIC_ bool conv_str_u64(const char * str, uint64_t * val)

{

  unsigned long long  lval;

  int error = 0;

  if (str == NULL || *str == '\0') {

    return false;

  }

  lval = smb_strtoull(str, NULL, 10, &error, SMB_STR_FULL_STR_CONV);

  if (error != 0) {

    return false;

  }

  *val = (uint64_t)lval;

  return true;

}

/**

 * Compare 2 strings.

 *

 * @note The comparison is case-insensitive.

 **/

_PUBLIC_ bool strequal(const char *s1, const char *s2)

{

  if (s1 == s2)

    return true;

  if (!s1 || !s2)

    return false;

  return strcasecmp_m(s1,s2) == 0;

}

/**

 * @file

 * @brief String utilities.

 **/

/**

 * Get the next token from a string, return False if none found.

 * Handles double-quotes.

 *

 * Based on a routine by GJC@VILLAGE.COM.

 * Extensively modified by Andrew.Tridgell@anu.edu.au

 **/

static bool next_token_internal_talloc(TALLOC_CTX *ctx,

        const char **ptr,

                                char **pp_buff,

                                const char *sep,

                                bool ltrim)

{

  const char *s;

  const char *saved_s;

  char *pbuf;

  bool quoted;

  size_t len=1;

  *pp_buff = NULL;

  if (!ptr) {

    return(false);

  }

  s = *ptr;

  /* default to simple separators */

  if (!sep) {

    sep = " \t\n\r";

  }

  /* find the first non sep char, if left-trimming is requested */

  if (ltrim) {

    while (*s && strchr_m(sep,*s)) {

      s++;

    }

  }

  /* nothing left? */

  if (!*s) {

    return false;

  }

  /* When restarting we need to go from here. */

  saved_s = s;

  /* Work out the length needed. */

  for (quoted = false; *s &&

      (quoted || !strchr_m(sep,*s)); s++) {

    if (*s == '\"') {

      quoted = !quoted;

    } else {

      len++;

    }

  }

  /* We started with len = 1 so we have space for the nul. */

  *pp_buff = talloc_array(ctx, char, len);

  if (!*pp_buff) {

    return false;

  }

  /* copy over the token */

  pbuf = *pp_buff;

  s = saved_s;

  for (quoted = false; *s &&

      (quoted || !strchr_m(sep,*s)); s++) {

    if ( *s == '\"' ) {

      quoted = !quoted;

    } else {

      *pbuf++ = *s;

    }

  }

  *ptr = (*s) ? s+1 : s;

  *pbuf = 0;

  return true;

}

bool next_token_talloc(TALLOC_CTX *ctx,

      const char **ptr,

      char **pp_buff,

      const char *sep)

{

  return next_token_internal_talloc(ctx, ptr, pp_buff, sep, true);

}

/*

 * Get the next token from a string, return false if none found.  Handles

 * double-quotes.  This version does not trim leading separator characters

 * before looking for a token.

 */

bool next_token_no_ltrim_talloc(TALLOC_CTX *ctx,

      const char **ptr,

      char **pp_buff,

      const char *sep)

{

  return next_token_internal_talloc(ctx, ptr, pp_buff, sep, false);

}

/**

 Set a boolean variable from the text value stored in the passed string.

 Returns true in success, false if the passed string does not correctly

 represent a boolean.

**/

_PUBLIC_ bool set_boolean(const char *boolean_string, bool *boolean)

{

  if (strwicmp(boolean_string, "yes") == 0 ||

      strwicmp(boolean_string, "true") == 0 ||

      strwicmp(boolean_string, "on") == 0 ||

      strwicmp(boolean_string, "1") == 0) {

    *boolean = true;

    return true;

  } else if (strwicmp(boolean_string, "no") == 0 ||

       strwicmp(boolean_string, "false") == 0 ||

       strwicmp(boolean_string, "off") == 0 ||

       strwicmp(boolean_string, "0") == 0) {

    *boolean = false;

    return true;

  }

  return false;

}