/*
 * Copyright 2019, The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "frame.h"

#include "hwsim.h"
#include "ieee80211.h"

#include <asm/byteorder.h>

#include <sstream>

static constexpr uint64_t kSlotTime = 9;

static const AccessCategory kPriorityToAc[8] = {
    AccessCategory::BestEffort,
    AccessCategory::Background,
    AccessCategory::Background,
    AccessCategory::BestEffort,
    AccessCategory::Video,
    AccessCategory::Video,
    AccessCategory::Voice,
    AccessCategory::Voice,
};

static uint32_t calcContentionWindowMin(AccessCategory ac) {
    switch (ac) {
        case AccessCategory::Voice:
            return 3;
        case AccessCategory::Video:
            return 7;
        case AccessCategory::BestEffort:
            return 15;
        case AccessCategory::Background:
            return 15;
    }
}

static uint32_t calcContentionWindowMax(AccessCategory ac) {
    switch (ac) {
        case AccessCategory::Voice:
            return 7;
        case AccessCategory::Video:
            return 15;
        case AccessCategory::BestEffort:
            return 1023;
        case AccessCategory::Background:
            return 1023;
    }
}

FrameType frameTypeFromByte(uint8_t byte) {
    if (byte == static_cast<uint8_t>(FrameType::Ack)) {
        return FrameType::Ack;
    } else if (byte == static_cast<uint8_t>(FrameType::Data)) {
        return FrameType::Data;
    }
    return FrameType::Unknown;
}

FrameInfo::FrameInfo(const MacAddress& transmitter,
                     uint64_t cookie,
                     uint32_t flags,
                     uint32_t channel,
                     const hwsim_tx_rate* rates,
                     size_t numRates)
    : mTransmitter(transmitter)
    , mCookie(cookie)
    , mFlags(flags)
    , mChannel(channel) {
    size_t i = 0;
    for (; i < numRates; ++i) {
        mTxRates[i].count = 0;
        mTxRates[i].idx = rates[i].idx;
    }
    for (; i < mTxRates.size(); ++i) {
        mTxRates[i].count = 0;
        mTxRates[i].idx = -1;
    }
}

bool FrameInfo::shouldAck() const {
    return !!(mFlags & HWSIM_TX_CTL_REQ_TX_STATUS);
}

Frame::Frame(const uint8_t* data, size_t size) : mData(data, data + size) {
}

Frame::Frame(const uint8_t* data, size_t size, const MacAddress& transmitter,
             uint64_t cookie, uint32_t flags, uint32_t channel,
             const hwsim_tx_rate* rates, size_t numRates)
    : mData(data, data + size)
    , mInfo(transmitter, cookie, flags, channel, rates, numRates)
    , mContentionWindow(calcContentionWindowMin(getAc()))
    , mContentionWindowMax(calcContentionWindowMax(getAc())) {
    memcpy(mInitialTxRates.data(), rates, numRates * sizeof(*rates));
}

bool Frame::incrementAttempts() {
    Rates& rates = mInfo.rates();
    for (size_t i = 0; i < rates.size(); ++i) {
        if (mInitialTxRates[i].idx == -1) {
            // We've run out of attempts
            break;
        }
        if (rates[i].count < mInitialTxRates[i].count) {
            ++rates[i].count;
            return true;
        }
    }
    return false;
}

bool Frame::hasRemainingAttempts() {
    Rates& rates = mInfo.rates();
    for (size_t i = 0; i < rates.size(); ++i) {
        if (mInitialTxRates[i].idx == -1) {
            break;
        }
        if (rates[i].count < mInitialTxRates[i].count) {
            return true;
        }
    }
    return false;
}

const MacAddress& Frame::source() const {
    auto hdr = reinterpret_cast<const struct ieee80211_hdr*>(mData.data());
    return *reinterpret_cast<const MacAddress*>(hdr->addr2);
}

const MacAddress& Frame::destination() const {
    auto hdr = reinterpret_cast<const struct ieee80211_hdr*>(mData.data());
    return *reinterpret_cast<const MacAddress*>(hdr->addr1);
}

std::string Frame::str() const {
    uint8_t type = (mData[0] >> 2) & 0x3;
    uint8_t subType = (mData[0] >> 4) & 0x0F;

    std::stringstream ss;
    ss << "[ Ck: " << cookie() << " Ch: " << channel() << " ] ";
    switch (type) {
        case 0:
            // Management
            ss << "Management (";
            switch (subType) {
                case 0:
                    ss << "Association Request";
                    break;
                case 1:
                    ss << "Association Response";
                    break;
                case 2:
                    ss << "Reassociation Request";
                    break;
                case 3:
                    ss << "Reassociation Response";
                    break;
                case 4:
                    ss << "Probe Request";
                    break;
                case 5:
                    ss << "Probe Response";
                    break;
                case 6:
                    ss << "Timing Advertisement";
                    break;
                case 8:
                    ss << "Beacon";
                    break;
                case 9:
                    ss << "ATIM";
                    break;
                case 10:
                    ss << "Disassociation";
                    break;
                case 11:
                    ss << "Authentication";
                    break;
                case 12:
                    ss << "Deauthentication";
                    break;
                case 13:
                    ss << "Action";
                    break;
                case 14:
                    ss << "Action No Ack";
                    break;
                default:
                    ss << subType;
                    break;
            }
            ss << ')';
            break;
        case 1:
            // Control
            ss << "Control (";
            switch (subType) {
                case 4:
                    ss << "Beamforming Report Poll";
                    break;
                case 5:
                    ss << "VHT NDP Announcement";
                    break;
                case 6:
                    ss << "Control Frame Extension";
                    break;
                case 7:
                    ss << "Control Wrapper";
                    break;
                case 8:
                    ss << "Block Ack Request";
                    break;
                case 9:
                    ss << "Block Ack";
                    break;
                case 10:
                    ss << "PS-Poll";
                    break;
                case 11:
                    ss << "RTS";
                    break;
                case 12:
                    ss << "CTS";
                    break;
                case 13:
                    ss << "Ack";
                    break;
                case 14:
                    ss << "CF-End";
                    break;
                case 15:
                    ss << "CF-End+CF-Ack";
                    break;
                default:
                    ss << subType;
                    break;
            }
            ss << ')';
            break;
        case 2:
            // Data
            ss << "Data (";
            switch (subType) {
                case 0:
                    ss << "Data";
                    break;
                case 1:
                    ss << "Data+CF-Ack";
                    break;
                case 2:
                    ss << "Data+CF-Poll";
                    break;
                case 3:
                    ss << "Data+CF-Ack+CF-Poll";
                    break;
                case 4:
                    ss << "Null";
                    break;
                case 5:
                    ss << "CF-Ack";
                    break;
                case 6:
                    ss << "CF-Poll";
                    break;
                case 7:
                    ss << "CF-Ack+CF-Poll";
                    break;
                case 8:
                    ss << "QoS Data";
                    break;
                case 9:
                    ss << "QoS Data+CF-Ack";
                    break;
                case 10:
                    ss << "QoS Data+CF-Poll";
                    break;
                case 11:
                    ss << "QoS Data+CF-Ack+CF-Poll";
                    break;
                case 12:
                    ss << "QoS Null";
                    break;
                case 14:
                    ss << "QoS CF-Poll";
                    break;
                case 15:
                    ss << "QoS CF-Poll+CF-Ack";
                    break;
                default:
                    ss << subType;
                    break;
            }
            ss << ')';
            break;
        case 3:
            // Extension
            ss << "Extension (";
            switch (subType) {
                case 0:
                    ss << "DMG Beacon";
                    break;
                default:
                    ss << subType;
                    break;
            }
            ss << ')';
            break;
        default:
            ss << type << " (" << subType << ')';
            break;
    }
    return ss.str();
}

bool Frame::isBeacon() const {
    uint8_t totalType = mData[0] & 0xFC;
    return totalType == 0x80;
}

bool Frame::isData() const {
    uint8_t totalType = mData[0] & 0x0C;
    return totalType == 0x08;
}

bool Frame::isDataQoS() const {
    uint8_t totalType = mData[0] & 0xFC;
    return totalType == 0x88;
}

uint16_t Frame::getQoSControl() const {
    // Some frames have 4 address fields instead of 3 which pushes QoS control
    // forward 6 bytes.
    bool uses4Addresses = !!(mData[1] & 0x03);
    const uint8_t* addr = &mData[uses4Addresses ? 30 : 24];

    return __le16_to_cpu(*reinterpret_cast<const uint16_t*>(addr));
}

uint64_t Frame::calcNextTimeout() {
    mNextTimeout = (mContentionWindow * kSlotTime) / 2;
    mContentionWindow = std::min((mContentionWindow * 2) + 1,
                                 mContentionWindowMax);
    return mNextTimeout;
}

AccessCategory Frame::getAc() const {
    if (!isData()) {
        return AccessCategory::Voice;
    }
    if (!isDataQoS()) {
        return AccessCategory::BestEffort;
    }
    uint16_t priority = getQoSControl() & 0x07;
    return kPriorityToAc[priority];
}