hal/src/PrefixParser.cpp

/*
 * Copyright (c) 2017, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *    * Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *    * Redistributions in binary form must reproduce the above
 *      copyright notice, this list of conditions and the following
 *      disclaimer in the documentation and/or other materials provided
 *      with the distribution.
 *    * Neither the name of The Linux Foundation nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/* External Includes */
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <vector>

/* Internal Includes */
#include "IOffloadManager.h"
#include "PrefixParser.h"

/* Avoiding namespace pollution */
using IP_FAM = ::IOffloadManager::IP_FAM;
using Prefix = ::IOffloadManager::Prefix;

using ::std::string;
using ::std::vector;


/* ------------------------------ PUBLIC ------------------------------------ */
PrefixParser::PrefixParser() {
    mLastErr = "No Err";
} /* PrefixParser */

bool PrefixParser::add(vector<string> in) {
    return add(in, IP_FAM::INVALID);
} /* add */

bool PrefixParser::add(string in) {
    return add(in, IP_FAM::INVALID);
} /* add */

bool PrefixParser::addV4(string in) {
    return add(in, IP_FAM::V4);
} /* addV4 */

bool PrefixParser::addV4(vector<string> in) {
    return add(in, IP_FAM::V4);
} /* addV4 */

bool PrefixParser::addV6(string in) {
    return add(in, IP_FAM::V6);
} /* addV6 */

bool PrefixParser::addV6(vector<string> in) {
    for (size_t i = 0; i < in.size(); i++) {
        if (!addV6(in[i]))
            return false;
    }
    return true;
} /* addV6 */

int PrefixParser::size() {
    return mPrefixes.size();
} /* size */

bool PrefixParser::allAreFullyQualified() {
    for (size_t i = 0; i < mPrefixes.size(); i++) {
        if (mPrefixes[i].fam == IP_FAM::V4) {
            uint32_t masked = mPrefixes[i].v4Addr & mPrefixes[i].v4Mask;
            if (masked != mPrefixes[i].v4Addr)
                return false;
        } else {
            uint32_t masked[4];
            masked[0] = mPrefixes[i].v6Addr[0] & mPrefixes[i].v6Mask[0];
            masked[1] = mPrefixes[i].v6Addr[1] & mPrefixes[i].v6Mask[1];
            masked[2] = mPrefixes[i].v6Addr[2] & mPrefixes[i].v6Mask[2];
            masked[3] = mPrefixes[i].v6Addr[3] & mPrefixes[i].v6Mask[3];
            for (int j = 0; j < 4; j++) {
                if (masked[j] != mPrefixes[i].v6Addr[j])
                    return false;
            }
        }
    }
    return true;
} /* allAreFullyQualified */

Prefix PrefixParser::getFirstPrefix() {
    if (size() >= 1)
        return mPrefixes[0];
    return makeBlankPrefix(IP_FAM::INVALID);
} /* getFirstPrefix */

string PrefixParser::getLastErrAsStr() {
    return mLastErr;
} /* getLastErrAsStr */


/* ------------------------------ PRIVATE ----------------------------------- */
bool PrefixParser::add(vector<string> in, IP_FAM famHint) {
    if (in.size() == 0)
        return false;

    for (size_t i = 0; i < in.size(); i++) {
        if (!add(in[i], famHint))
            return false;
    }
    return true;
} /* add */

bool PrefixParser::add(string in, IP_FAM famHint) {
    if (in.length() == 0) {
        mLastErr = "Failed to parse string, length = 0...";
        return false;
    }

    if (famHint == IP_FAM::INVALID)
        famHint = guessIPFamily(in);

    string subnet;
    string addr;

    if (!splitIntoAddrAndMask(in, addr, subnet)) {
        mLastErr = "Failed to split into Address and Mask(" + in + ")";
        return false;
    }

    int mask = parseSubnetMask(subnet, famHint);
    if (!isMaskValid(mask, famHint)) {
        mLastErr = "Invalid mask";
        return false;
    }

    Prefix pre = makeBlankPrefix(famHint);

    if (famHint == IP_FAM::V4) {
        if (!parseV4Addr(addr, pre)) {
            mLastErr = "Failed to parse V4 Address(" + addr + ")";
            return false;
        }
    } else if (!parseV6Addr(addr, pre)) {
        mLastErr = "Failed to parse V6 Address(" + addr + ")";
        return false;
    }

    if (famHint == IP_FAM::V4 && !populateV4Mask(mask, pre)) {
        mLastErr = "Failed to populate IPv4 Mask(" + std::to_string(mask)
                + ", " + addr + ")";
        return false;
    } else if (!populateV6Mask(mask, pre)) {
        mLastErr = "Failed to populate IPv6 Mask(" + std::to_string(mask)
                + ", " + addr + ")";
        return false;
    }

    mPrefixes.push_back(pre);
    return true;
} /* add */

/* Assumption (based on man inet_pton)
 *
 * X represents a hex character
 * d represents a base 10 digit
 * / represents the start of the subnet mask
 *              (assume that it can be left off of all below combinations)
 *
 * IPv4 Addresses always look like the following:
 *      ddd.ddd.ddd.ddd/dd
 *
 * IPv6 Addresses can look a few different ways:
 *      x:x:x:x:x:x:x:x/ddd
 *      x::x/ddd
 *      x:x:x:x:x:x:d.d.d.d/ddd
 *
 * Therefore, if a presentation of an IP Address contains a colon, then it
 * may not be a valid IPv6, but, it is definitely not valid IPv4.  If a
 * presentation of an IP Address does not contain a colon, then it may not be
 * a valid IPv4, but, it is definitely not IPv6.
 */
IP_FAM PrefixParser::guessIPFamily(string in) {
    size_t found = in.find(":");
    if (found != string::npos)
        return IP_FAM::V6;
    return IP_FAM::V4;
} /* guessIPFamily */

bool PrefixParser::splitIntoAddrAndMask(string in, string &addr, string &mask) {
    size_t pos = in.find("/");

    if (pos != string::npos && pos >= 1) {
        /* addr is now everything up until the first / */
        addr = in.substr(0, pos);
    } else if (pos == string::npos) {
        /* There is no /, so the entire input is an address */
        addr = in;
    } else {
        /* There was nothing before the /, not recoverable */
        return false;
    }

    if (pos != string::npos && pos < in.size()) {
        /* There is a / and it is not the last character.  Everything after /
         * must be the subnet.
         */
        mask = in.substr(pos + 1);
    } else if (pos != string::npos && pos == in.size()) {
        /* There is a /, but it is the last character.  This is garbage, but,
         * we may still be able to interpret the address so we will throw it
         * out.
         */
        mask = "";
    } else if (pos == string::npos) {
        /* There is no /, therefore, there is no subnet */
        mask = "";
    } else {
        /* This really shouldn't be possible because it would imply that find
         * returned a position larger than the size of the input.  Just
         * preserving sanity that mask is always initialized.
         */
        mask = "";
    }

    return true;
} /* splitIntoAddrAndMask */

int PrefixParser::parseSubnetMask(string in, IP_FAM famHint) {
    if (in.empty())
        /* Treat no subnet mask as fully qualified */
        return (famHint == IP_FAM::V6) ? 128 : 32;
    return atoi(in.c_str());
} /* parseSubnetMask */

bool PrefixParser::parseV4Addr(string in, Prefix &out) {
    struct sockaddr_in sa;

    int ret = inet_pton(AF_INET, in.c_str(), &(sa.sin_addr));

    if (ret < 0) {
        /* errno would be valid */
        return false;
    } else if (ret == 0) {
        /* input was not a valid IP address */
        return false;
    }

    /* Address in network byte order */
    out.v4Addr = htonl(sa.sin_addr.s_addr);
    return true;
} /* parseV4Addr */

bool PrefixParser::parseV6Addr(string in, Prefix &out) {
    struct sockaddr_in6 sa;

    int ret = inet_pton(AF_INET6, in.c_str(), &(sa.sin6_addr));

    if (ret < 0) {
        /* errno would be valid */
        return false;
    } else if (ret == 0) {
        /* input was not a valid IP address */
        return false;
    }

    /* Translate unsigned chars to unsigned ints to match IPA
     *
     * TODO there must be a better way to do this beyond bit fiddling
     * Maybe a Union since we've already made the assumption that the data
     * structures match?
     */
    out.v6Addr[0] = (sa.sin6_addr.s6_addr[0] << 24) |
                    (sa.sin6_addr.s6_addr[1] << 16) |
                    (sa.sin6_addr.s6_addr[2] << 8) |
                    (sa.sin6_addr.s6_addr[3]);
    out.v6Addr[1] = (sa.sin6_addr.s6_addr[4] << 24) |
                    (sa.sin6_addr.s6_addr[5] << 16) |
                    (sa.sin6_addr.s6_addr[6] << 8) |
                    (sa.sin6_addr.s6_addr[7]);
    out.v6Addr[2] = (sa.sin6_addr.s6_addr[8] << 24) |
                    (sa.sin6_addr.s6_addr[9] << 16) |
                    (sa.sin6_addr.s6_addr[10] << 8) |
                    (sa.sin6_addr.s6_addr[11]);
    out.v6Addr[3] = (sa.sin6_addr.s6_addr[12] << 24) |
                    (sa.sin6_addr.s6_addr[13] << 16) |
                    (sa.sin6_addr.s6_addr[14] << 8) |
                    (sa.sin6_addr.s6_addr[15]);
    return true;
} /* parseV6Addr */

bool PrefixParser::populateV4Mask(int mask, Prefix &out) {
    if (mask < 0 || mask > 32)
        return false;
    out.v4Mask = createMask(mask);
    return true;
} /* populateV4Mask */

bool PrefixParser::populateV6Mask(int mask, Prefix &out) {
    if (mask < 0 || mask > 128)
        return false;

    for (int i = 0; i < 4; i++) {
        out.v6Mask[i] = createMask(mask);
        mask = (mask > 32) ? mask - 32 : 0;
    }

    return true;
} /* populateV6Mask */

uint32_t PrefixParser::createMask(int mask) {
    uint32_t ret = 0;

    if (mask >= 32) {
        ret = ~ret;
        return ret;
    }

    for (int i = 0; i < 32; i++) {
        if (i < mask)
            ret = (ret << 1) | 1;
        else
            ret = (ret << 1);
    }

    return ret;
} /* createMask */

Prefix PrefixParser::makeBlankPrefix(IP_FAM famHint) {
    Prefix ret;

    ret.fam = famHint;

    ret.v4Addr = 0;
    ret.v4Mask = 0;

    ret.v6Addr[0] = 0;
    ret.v6Addr[1] = 0;
    ret.v6Addr[2] = 0;
    ret.v6Addr[3] = 0;

    ret.v6Mask[0] = 0;
    ret.v6Mask[1] = 0;
    ret.v6Mask[2] = 0;
    ret.v6Mask[3] = 0;

    return ret;
} /* makeBlankPrefix */

bool PrefixParser::isMaskValid(int mask, IP_FAM fam) {
    if (mask < 0) {
        mLastErr = "Failed parse subnet mask(" + std::to_string(mask) + ")";
        return false;
    } else if (mask == 0) {
        mLastErr = "Subnet mask cannot be 0(" + std::to_string(mask) + ")";
        return false;
    } else if (fam == IP_FAM::V4 && mask > 32) {
        mLastErr = "Interpreted address as V4 but mask was too large("
                + std::to_string(mask) + ")";
        return false;
    } else if (fam == IP_FAM::V6 && mask > 128) {
        mLastErr = "Interpreted address as V6 but mask was too large("
                + std::to_string(mask) + ")";
        return false;
    }

    return true;
} /* isMaskValid */