// SPDX-License-Identifier: GPL-2.0+

/*

 * Generic network code. Moved from net.c

 *

 * Copyright 1994 - 2000 Neil Russell.

 * Copyright 2000 Roland Borde

 * Copyright 2000 Paolo Scaffardi

 * Copyright 2000-2002 Wolfgang Denk, wd@denx.de

 * Copyright 2009 Dirk Behme, dirk.behme@googlemail.com

 */

#include <net.h>

#include <net6.h>

#include <vsprintf.h>

struct in_addr string_to_ip(const char *s)

{

  struct in_addr addr;

  char *e;

  int i;

  addr.s_addr = 0;

  if (s == NULL)

    return addr;

  for (addr.s_addr = 0, i = 0; i < 4; ++i) {

    ulong val = s ? dectoul(s, &e) : 0;

    if (val > 255) {

      addr.s_addr = 0;

      return addr;

    }

    if (i != 3 && *e != '.') {

      addr.s_addr = 0;

      return addr;

    }

    addr.s_addr <<= 8;

    addr.s_addr |= (val & 0xFF);

    if (s) {

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

    }

  }

  addr.s_addr = htonl(addr.s_addr);

  return addr;

}

#if IS_ENABLED(CONFIG_IPV6)

int string_to_ip6(const char *str, size_t len, struct in6_addr *addr)

{

  int colon_count = 0;

  int found_double_colon = 0;

  int xstart = 0;   /* first zero (double colon) */

  int section_num = 7;  /* num words the double colon represents */

  int i;

  const char *s = str;

  const char *const e = s + len;

  struct in_addr zero_ip = {.s_addr = 0};

  if (!str)

    return -1;

  /* First pass, verify the syntax and locate the double colon */

  while (s < e) {

    while (s < e && isxdigit((int)*s))

      s++;

    if (*s == '\0')

      break;

    if (*s != ':') {

      if (*s == '.' && section_num >= 2) {

        struct in_addr v4;

        while (s != str && *(s - 1) != ':')

          --s;

        v4 = string_to_ip(s);

        if (memcmp(&zero_ip, &v4,

             sizeof(struct in_addr)) != 0) {

          section_num -= 2;

          break;

        }

      }

      /* This could be a valid address */

      break;

    }

    if (s == str) {

      /* The address begins with a colon */

      if (*++s != ':')

        /* Must start with a double colon or a number */

        goto out_err;

    } else {

      s++;

      if (found_double_colon)

        section_num--;

      else

        xstart++;

    }

    if (*s == ':') {

      if (found_double_colon)

        /* Two double colons are not allowed */

        goto out_err;

      found_double_colon = 1;

      section_num -= xstart;

      s++;

    }

    if (++colon_count == 7)

      /* Found all colons */

      break;

    ++s;

  }

  if (colon_count == 0)

    goto out_err;

  if (*--s == ':')

    section_num++;

  /* Second pass, read the address */

  s = str;

  for (i = 0; i < 8; i++) {

    int val = 0;

    char *end;

    if (found_double_colon &&

        i >= xstart && i < xstart + section_num) {

      addr->s6_addr16[i] = 0;

      continue;

    }

    while (*s == ':')

      s++;

    if (i == 6 && isdigit((int)*s)) {

      struct in_addr v4 = string_to_ip(s);

      if (memcmp(&zero_ip, &v4,

           sizeof(struct in_addr)) != 0) {

        /* Ending with :IPv4-address */

        addr->s6_addr32[3] = v4.s_addr;

        break;

      }

    }

    val = simple_strtoul(s, &end, 16);

    if (end != e && *end != '\0' && *end != ':')

      goto out_err;

    addr->s6_addr16[i] = htons(val);

    s = end;

  }

  return 0;

out_err:

  return -1;

}

#endif

void ip_to_string(struct in_addr x, char *s)

{

  x.s_addr = ntohl(x.s_addr);

  sprintf(s, "%d.%d.%d.%d",

    (int) ((x.s_addr >> 24) & 0xff),

    (int) ((x.s_addr >> 16) & 0xff),

    (int) ((x.s_addr >> 8) & 0xff),

    (int) ((x.s_addr >> 0) & 0xff)

  );

}

void string_to_enetaddr(const char *addr, uint8_t *enetaddr)

{

  char *end;

  int i;

  if (!enetaddr)

    return;

  for (i = 0; i < 6; ++i) {

    enetaddr[i] = addr ? hextoul(addr, &end) : 0;

    if (addr)

      addr = (*end) ? end + 1 : end;

  }

}

uint compute_ip_checksum(const void *vptr, uint nbytes)

{

  int sum, oddbyte;

  const unsigned short *ptr = vptr;

  sum = 0;

  while (nbytes > 1) {

    sum += *ptr++;

    nbytes -= 2;

  }

  if (nbytes == 1) {

    oddbyte = 0;

    ((u8 *)&oddbyte)[0] = *(u8 *)ptr;

    ((u8 *)&oddbyte)[1] = 0;

    sum += oddbyte;

  }

  sum = (sum >> 16) + (sum & 0xffff);

  sum += (sum >> 16);

  sum = ~sum & 0xffff;

  return sum;

}

uint add_ip_checksums(uint offset, uint sum, uint new)

{

  ulong checksum;

  sum = ~sum & 0xffff;

  new = ~new & 0xffff;

  if (offset & 1) {

    /*

     * byte-swap the sum if it came from an odd offset; since the

     * computation is endian-independent this works.

     */

    new = ((new >> 8) & 0xff) | ((new << 8) & 0xff00);

  }

  checksum = sum + new;

  if (checksum > 0xffff)

    checksum -= 0xffff;

  return (~checksum) & 0xffff;

}

int ip_checksum_ok(const void *addr, uint nbytes)

{

  return !(compute_ip_checksum(addr, nbytes) & 0xfffe);

}