/*

 * Copyright (c) 2020 Fastly, Inc.

 *

 * 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 <assert.h>

#include <string.h>

#include "quicly/constants.h"

#include "quicly/remote_cid.h"

void quicly_remote_cid_init_set(quicly_remote_cid_set_t *set, ptls_iovec_t *initial_cid, void (*random_bytes)(void *, size_t))

{

    set->cids[0] = (quicly_remote_cid_t){

        .state = QUICLY_REMOTE_CID_IN_USE,

        .sequence = 0,

    };

    if (initial_cid != NULL) {

        quicly_set_cid(&set->cids[0].cid, *initial_cid);

    } else {

        random_bytes(set->cids[0].cid.cid, QUICLY_MIN_INITIAL_DCID_LEN);

        set->cids[0].cid.len = QUICLY_MIN_INITIAL_DCID_LEN;

    }

    random_bytes(set->cids[0].stateless_reset_token, sizeof(set->cids[0].stateless_reset_token));

    for (size_t i = 1; i < PTLS_ELEMENTSOF(set->cids); i++)

        set->cids[i] = (quicly_remote_cid_t){

            .state = QUICLY_REMOTE_CID_UNAVAILABLE,

            .sequence = i,

        };

    set->_largest_sequence_expected = PTLS_ELEMENTSOF(set->cids) - 1;

    memset(&set->retired, 0, sizeof(set->retired));

}

static quicly_error_t do_register(quicly_remote_cid_set_t *set, uint64_t sequence, const uint8_t *cid, size_t cid_len,

                                  const uint8_t srt[QUICLY_STATELESS_RESET_TOKEN_LEN])

{

    int was_stored = 0;

    if (set->_largest_sequence_expected < sequence)

        return QUICLY_TRANSPORT_ERROR_CONNECTION_ID_LIMIT;

    for (size_t i = 0; i < PTLS_ELEMENTSOF(set->cids); i++) {

        if (set->cids[i].state != QUICLY_REMOTE_CID_UNAVAILABLE) {

            /* compare newly received CID against what we already have, to see if there is duplication/conflicts */

            /* If an endpoint receives a NEW_CONNECTION_ID frame that repeats a previously issued connection ID with

             * a different Stateless Reset Token or a different sequence number, or if a sequence number is used for

             * different connection IDs, the endpoint MAY treat that receipt as a connection error of type PROTOCOL_VIOLATION.

             * (19.15)

             */

            if (quicly_cid_is_equal(&set->cids[i].cid, ptls_iovec_init(cid, cid_len))) {

                if (set->cids[i].sequence == sequence &&

                    memcmp(set->cids[i].stateless_reset_token, srt, QUICLY_STATELESS_RESET_TOKEN_LEN) == 0) {

                    /* likely a duplicate due to retransmission */

                    return 0;

                } else {

                    /* received a frame that carries conflicting information */

                    return QUICLY_TRANSPORT_ERROR_PROTOCOL_VIOLATION;

                }

            }

            /* here we know CID is not equal */

            if (set->cids[i].sequence == sequence)

                return QUICLY_TRANSPORT_ERROR_PROTOCOL_VIOLATION;

        } else if (set->cids[i].sequence == sequence) {

            assert(!was_stored);

            set->cids[i].sequence = sequence;

            quicly_set_cid(&set->cids[i].cid, ptls_iovec_init(cid, cid_len));

            memcpy(set->cids[i].stateless_reset_token, srt, QUICLY_STATELESS_RESET_TOKEN_LEN);

            set->cids[i].state = QUICLY_REMOTE_CID_AVAILABLE;

            was_stored = 1;

        }

    }

    /* execution reaches here in two cases, 1) normal path, i.e. new CID was successfully registered, and 2) new CID was already

     * retired (was_stored == 0). */

    return 0;

}

static int do_unregister(quicly_remote_cid_set_t *set, size_t idx_to_unreg)

{

    uint64_t seq_to_unreg = set->cids[idx_to_unreg].sequence;

    set->cids[idx_to_unreg].state = QUICLY_REMOTE_CID_UNAVAILABLE;

    set->cids[idx_to_unreg].sequence = ++set->_largest_sequence_expected;

    return quicly_remote_cid_push_retired(set, seq_to_unreg);

}

int quicly_remote_cid_unregister(quicly_remote_cid_set_t *set, uint64_t sequence)

{

    for (size_t i = 0; i < PTLS_ELEMENTSOF(set->cids); i++) {

        if (sequence == set->cids[i].sequence)

            return do_unregister(set, i);

    }

    assert(!"invalid CID sequence number");

}

static int unregister_prior_to(quicly_remote_cid_set_t *set, uint64_t seq_unreg_prior_to)

{

    int ret;

    for (size_t i = 0; i < PTLS_ELEMENTSOF(set->cids); i++) {

        while (set->cids[i].sequence < seq_unreg_prior_to) {

            if ((ret = do_unregister(set, i)) != 0)

                return ret;

        }

    }

    return 0;

}

quicly_error_t quicly_remote_cid_register(quicly_remote_cid_set_t *set, uint64_t sequence, const uint8_t *cid, size_t cid_len,

                                          const uint8_t srt[QUICLY_STATELESS_RESET_TOKEN_LEN], uint64_t retire_prior_to)

{

    quicly_remote_cid_set_t backup = *set; /* preserve current state so that it can be restored to notify protocol violation */

    quicly_error_t ret;

    assert(sequence >= retire_prior_to);

    /* First, handle retire_prior_to. This order is important as it is possible to receive a NEW_CONNECTION_ID frame such that it

     * retires active_connection_id_limit CIDs and then installs one new CID. Next, the new CID is registered. If either of the two

     * fails, the state is restored to the original so that we can send an error to the peer. */

    if ((ret = unregister_prior_to(set, retire_prior_to)) != 0 || (ret = do_register(set, sequence, cid, cid_len, srt)) != 0)

        *set = backup;

    return ret;

}

int quicly_remote_cid_push_retired(quicly_remote_cid_set_t *set, uint64_t sequence)

{

    /* do nothing if given sequence is already registered */

    for (size_t i = 0; i < set->retired.count; ++i) {

        if (set->retired.cids[i] == sequence)

            return 0;

    }

    if (set->retired.count >= PTLS_ELEMENTSOF(set->retired.cids))

        return QUICLY_ERROR_STATE_EXHAUSTION;

    set->retired.cids[set->retired.count++] = sequence;

    return 0;

}

void quicly_remote_cid_shift_retired(quicly_remote_cid_set_t *set, size_t count)

{

    assert(count <= set->retired.count);

    set->retired.count -= count;

    for (size_t i = 0; i < count; ++i)

        set->retired.cids[i] = set->retired.cids[i + count];

}