/*

 * ngtcp2

 *

 * Copyright (c) 2017 ngtcp2 contributors

 *

 * Permission is hereby granted, free of charge, to any person obtaining

 * a copy of this software and associated documentation files (the

 * "Software"), to deal in the Software without restriction, including

 * without limitation the rights to use, copy, modify, merge, publish,

 * distribute, sublicense, and/or sell copies of the Software, and to

 * permit persons to whom the Software is furnished to do so, subject to

 * the following conditions:

 *

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 */

#include "ngtcp2_conv.h"

#include <string.h>

#include <assert.h>

#include "ngtcp2_str.h"

#include "ngtcp2_pkt.h"

#include "ngtcp2_net.h"

#include "ngtcp2_unreachable.h"

const uint8_t *ngtcp2_get_uint64be(uint64_t *dest, const uint8_t *p) {

  memcpy(dest, p, sizeof(*dest));

  *dest = ngtcp2_ntohl64(*dest);

  return p + sizeof(*dest);

}

const uint8_t *ngtcp2_get_uint32be(uint32_t *dest, const uint8_t *p) {

  memcpy(dest, p, sizeof(*dest));

  *dest = ngtcp2_ntohl(*dest);

  return p + sizeof(*dest);

}

const uint8_t *ngtcp2_get_uint24be(uint32_t *dest, const uint8_t *p) {

  *dest = 0;

  memcpy(((uint8_t *)dest) + 1, p, 3);

  *dest = ngtcp2_ntohl(*dest);

  return p + 3;

}

const uint8_t *ngtcp2_get_uint16be(uint16_t *dest, const uint8_t *p) {

  memcpy(dest, p, sizeof(*dest));

  *dest = ngtcp2_ntohs(*dest);

  return p + sizeof(*dest);

}

const uint8_t *ngtcp2_get_uint16(uint16_t *dest, const uint8_t *p) {

  memcpy(dest, p, sizeof(*dest));

  return p + sizeof(*dest);

}

static const uint8_t *get_uvarint(uint64_t *dest, const uint8_t *p) {

  uint16_t n16;

  uint32_t n32;

  uint64_t n64;

  switch (*p >> 6) {

  case 0:

    *dest = *p++;

    return p;

  case 1:

    memcpy(&n16, p, 2);

    n16 = ngtcp2_ntohs(n16);

    n16 &= 0x3FFF;

    *dest = n16;

    return p + 2;

  case 2:

    memcpy(&n32, p, 4);

    n32 = ngtcp2_ntohl(n32);

    n32 &= 0x3FFFFFFF;

    *dest = n32;

    return p + 4;

  case 3:

    memcpy(&n64, p, 8);

    n64 = ngtcp2_ntohl64(n64);

    n64 &= 0x3FFFFFFFFFFFFFFF;

    *dest = n64;

    return p + 8;

  default:

    ngtcp2_unreachable();

  }

}

const uint8_t *ngtcp2_get_uvarint(uint64_t *dest, const uint8_t *p) {

  return get_uvarint(dest, p);

}

const uint8_t *ngtcp2_get_varint(int64_t *dest, const uint8_t *p) {

  return get_uvarint((uint64_t *)dest, p);

}

int64_t ngtcp2_get_pkt_num(const uint8_t *p, size_t pkt_numlen) {

  uint32_t l;

  uint16_t s;

  switch (pkt_numlen) {

  case 1:

    return *p;

  case 2:

    ngtcp2_get_uint16be(&s, p);

    return (int64_t)s;

  case 3:

    ngtcp2_get_uint24be(&l, p);

    return (int64_t)l;

  case 4:

    ngtcp2_get_uint32be(&l, p);

    return (int64_t)l;

  default:

    ngtcp2_unreachable();

  }

}

uint8_t *ngtcp2_put_uint64be(uint8_t *p, uint64_t n) {

  n = ngtcp2_htonl64(n);

  return ngtcp2_cpymem(p, (const uint8_t *)&n, sizeof(n));

}

uint8_t *ngtcp2_put_uint32be(uint8_t *p, uint32_t n) {

  n = ngtcp2_htonl(n);

  return ngtcp2_cpymem(p, (const uint8_t *)&n, sizeof(n));

}

uint8_t *ngtcp2_put_uint24be(uint8_t *p, uint32_t n) {

  n = ngtcp2_htonl(n);

  return ngtcp2_cpymem(p, ((const uint8_t *)&n) + 1, 3);

}

uint8_t *ngtcp2_put_uint16be(uint8_t *p, uint16_t n) {

  n = ngtcp2_htons(n);

  return ngtcp2_cpymem(p, (const uint8_t *)&n, sizeof(n));

}

uint8_t *ngtcp2_put_uint16(uint8_t *p, uint16_t n) {

  return ngtcp2_cpymem(p, (const uint8_t *)&n, sizeof(n));

}

uint8_t *ngtcp2_put_uvarint(uint8_t *p, uint64_t n) {

  uint8_t *rv;

  if (n < 64) {

    *p++ = (uint8_t)n;

    return p;

  }

  if (n < 16384) {

    rv = ngtcp2_put_uint16be(p, (uint16_t)n);

    *p |= 0x40;

    return rv;

  }

  if (n < 1073741824) {

    rv = ngtcp2_put_uint32be(p, (uint32_t)n);

    *p |= 0x80;

    return rv;

  }

  assert(n < 4611686018427387904ULL);

  rv = ngtcp2_put_uint64be(p, n);

  *p |= 0xC0;

  return rv;

}

uint8_t *ngtcp2_put_uvarint30(uint8_t *p, uint32_t n) {

  uint8_t *rv;

  assert(n < 1073741824);

  rv = ngtcp2_put_uint32be(p, n);

  *p |= 0x80;

  return rv;

}

uint8_t *ngtcp2_put_pkt_num(uint8_t *p, int64_t pkt_num, size_t len) {

  switch (len) {

  case 1:

    *p++ = (uint8_t)pkt_num;

    return p;

  case 2:

    return ngtcp2_put_uint16be(p, (uint16_t)pkt_num);

  case 3:

    return ngtcp2_put_uint24be(p, (uint32_t)pkt_num);

  case 4:

    return ngtcp2_put_uint32be(p, (uint32_t)pkt_num);

  default:

    ngtcp2_unreachable();

  }

}

size_t ngtcp2_get_uvarintlen(const uint8_t *p) {

  return (size_t)(1U << (*p >> 6));

}

size_t ngtcp2_put_uvarintlen(uint64_t n) {

  if (n < 64) {

    return 1;

  }

  if (n < 16384) {

    return 2;

  }

  if (n < 1073741824) {

    return 4;

  }

  assert(n < 4611686018427387904ULL);

  return 8;

}

uint64_t ngtcp2_ord_stream_id(int64_t stream_id) {

  return (uint64_t)(stream_id >> 2) + 1;

}