SpeedTestClient.cpp

#include <arpa/inet.h>
#include <netdb.h>
#include <cerrno>
#include <fcntl.h>
#include <sys/select.h>
#include <cstdlib>
#include <string>
#include <vector>
#include "SpeedTestClient.h"

SpeedTestClient::SpeedTestClient(const ServerInfo &serverInfo): mServerInfo(serverInfo),
                                                                                  mSocketFd(0),
                                                                                  mServerVersion(-1.0){}
SpeedTestClient::~SpeedTestClient() {
    close();
}

// It returns current timestamp in ms


// It connects and initiates client/server handshaking
bool SpeedTestClient::connect() {

    if (mSocketFd){
        return true;
    }

    auto ret = mkSocket();
    if (!ret)
        return ret;

    std::string reply;

    if (!SpeedTestClient::writeLine(mSocketFd, "HI")){
        close();
        return false;
    }


    if (SpeedTestClient::readLine(mSocketFd, reply)){
        std::stringstream reply_stream(reply);
        std::string hello;
        reply_stream >> hello >> mServerVersionString;
        if (reply_stream.fail()) {
            close();
            return false;
        }
        mServerVersion = std::strtof(mServerVersionString.c_str(), nullptr);

        if (!reply.empty() && "HELLO" == hello){
            return true;
        }

    }
    close();
    return false;
}

// It closes a connection
void SpeedTestClient::close() {
    if (mSocketFd){
        SpeedTestClient::writeLine(mSocketFd, "QUIT");
        ::close(mSocketFd);
        mSocketFd = 0; // so a later connect() does not reuse a dead descriptor
    }

}

// It executes PING command
bool SpeedTestClient::ping(long &millisec) {
    long microsec = 0;
    if (!pingMicros(microsec))
        return false;
    millisec = microsec / 1000;
    return true;
}

// Same exchange, without rounding the round-trip down to whole milliseconds:
// on a fast link every sample would otherwise read as 0 ms.
bool SpeedTestClient::pingMicros(long &microsec) {
    if (!mSocketFd)
        return false;

    std::stringstream cmd;
    std::string reply;

    auto start = std::chrono::steady_clock::now();
    cmd << "PING " << std::chrono::duration_cast<std::chrono::milliseconds>(
                          start.time_since_epoch()).count();

    if (!SpeedTestClient::writeLine(mSocketFd, cmd.str())){
        close();
        return false;
    }

    if (SpeedTestClient::readLine(mSocketFd, reply)){
        if (reply.substr(0, 5) == "PONG "){
            auto stop = std::chrono::steady_clock::now();
            microsec = std::chrono::duration_cast<std::chrono::microseconds>(stop - start).count();
            return true;
        }
    }

    close();
    return false;
}

// It executes DOWNLOAD command
bool SpeedTestClient::download(const long size, const long chunk_size, long &millisec) {
    std::stringstream cmd;
    cmd << "DOWNLOAD " << size;

    if (!SpeedTestClient::writeLine(mSocketFd, cmd.str())){
        return false;
    }


    char *buff = new char[chunk_size];
    for (size_t i = 0; i < static_cast<size_t>(chunk_size); i++)
        buff[i] = '\0';

    long missing = 0;
    auto start = std::chrono::steady_clock::now();
    while (missing != size){
        auto current = read(mSocketFd, buff, static_cast<size_t>(chunk_size));

        if (current <= 0){
            delete[] buff;
            return false;
        }
        missing += current;
    }

    auto stop = std::chrono::steady_clock::now();
    millisec = std::chrono::duration_cast<std::chrono::milliseconds>(stop - start).count();
    delete[] buff;
    return true;
}

// It executes UPLOAD command
bool SpeedTestClient::upload(const long size, const long chunk_size, long &millisec) {
    std::stringstream cmd;
    cmd << "UPLOAD " << size << "\n";
    auto cmd_len = cmd.str().length();

    char *buff = new char[chunk_size];
    for(size_t i = 0; i < static_cast<size_t>(chunk_size); i++)
        buff[i] = static_cast<char>(rand() % 256);

    long missing = size;
    auto start = std::chrono::steady_clock::now();

    if (!SpeedTestClient::writeLine(mSocketFd, cmd.str())){
        delete[] buff;
        return false;
    }

    ssize_t w = cmd_len;
    missing -= w;

    while(missing > 0){
        if (missing - chunk_size > 0){
            w = write(mSocketFd, buff, static_cast<size_t>(chunk_size));
            if (w != chunk_size){
                delete[] buff;
                return false;
            }
            missing -= w;
        } else {
            buff[missing - 1] = '\n';
            w = write(mSocketFd, buff, static_cast<size_t>(missing));
            if (w != missing){
                delete[] buff;
                return false;
            }
            missing -= w;
        }

    }
    std::string reply;
    if (!SpeedTestClient::readLine(mSocketFd, reply)){
        delete[] buff;
        return false;
    }
    auto stop = std::chrono::steady_clock::now();

    std::stringstream ss;
    ss << "OK " << size << " ";
    millisec = std::chrono::duration_cast<std::chrono::milliseconds>(stop - start).count();
    delete[] buff;
    return reply.substr(0, ss.str().length()) == ss.str();

}

bool SpeedTestClient::mkSocket() {
    auto hostp = hostport();

    // AF_UNSPEC so IPv6-only servers (and IPv6-only clients) work; the old
    // gethostbyname path could only ever produce an IPv4 address.
    struct addrinfo hints;
    memset(&hints, 0, sizeof(hints));
    hints.ai_family   = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;

    char portbuf[16];
    snprintf(portbuf, sizeof(portbuf), "%d", hostp.second);

    struct addrinfo *res = nullptr;
    if (getaddrinfo(hostp.first.c_str(), portbuf, &hints, &res) != 0 || res == nullptr){
        mSocketFd = 0;
        return false;
    }

    int fd = -1;
    for (struct addrinfo *p = res; p != nullptr; p = p->ai_next){
        fd = ::socket(p->ai_family, p->ai_socktype, p->ai_protocol);
        if (fd < 0)
            continue;

        // Connect without blocking forever on a filtered host, then hand a
        // plain blocking socket to the transfer code.
        int flags = ::fcntl(fd, F_GETFL, 0);
        ::fcntl(fd, F_SETFL, flags | O_NONBLOCK);

        bool connected = ::connect(fd, p->ai_addr, p->ai_addrlen) == 0;

        if (!connected && errno == EINPROGRESS){
            fd_set writable;
            FD_ZERO(&writable);
            FD_SET(fd, &writable);

            struct timeval tv;
            tv.tv_sec  = SPEED_TEST_CONNECT_TIMEOUT_SEC;
            tv.tv_usec = 0;

            if (::select(fd + 1, nullptr, &writable, nullptr, &tv) > 0){
                int err = 0;
                socklen_t len = sizeof(err);
                connected = ::getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &len) == 0 && err == 0;
            }
        }

        ::fcntl(fd, F_SETFL, flags);

        if (connected)
            break;

        ::close(fd);
        fd = -1;
    }
    freeaddrinfo(res);

    if (fd < 0){
        mSocketFd = 0;
        return false;
    }

    mSocketFd = fd;
    return true;
}



float SpeedTestClient::version() {
    return mServerVersion;
}

const std::string& SpeedTestClient::versionString() {
    return mServerVersionString;
}

bool SpeedTestClient::versionAtLeast(const std::string &minimum) {
    return SpeedTestClient::versionAtLeast(mServerVersionString, minimum);
}

// Compares dotted versions component by component. A plain float comparison
// would rank "2.11" below "2.3" and reject every current speedtest server.
bool SpeedTestClient::versionAtLeast(const std::string &version, const std::string &minimum) {
    if (version.empty())
        return false;

    auto components = [](const std::string &in) {
        std::vector<long> out;
        std::size_t start = 0;
        while (start <= in.length()) {
            std::size_t dot = in.find('.', start);
            std::string part = in.substr(start, dot == std::string::npos ? std::string::npos : dot - start);
            char *end = nullptr;
            long value = std::strtol(part.c_str(), &end, 10);
            if (end == part.c_str())
                break; // not a number: stop here, e.g. "2.11-beta"
            out.push_back(value);
            if (dot == std::string::npos)
                break;
            start = dot + 1;
        }
        return out;
    };

    std::vector<long> have = components(version);
    std::vector<long> want = components(minimum);

    if (have.empty())
        return false;

    for (std::size_t i = 0; i < want.size(); i++) {
        long lhs = i < have.size() ? have[i] : 0;
        if (lhs != want[i])
            return lhs > want[i];
    }
    return true;
}

const std::pair<std::string, int> SpeedTestClient::hostport() {
    const std::string target = mServerInfo.host;
    const int default_port = 8080;

    std::string host = target;
    std::string port;

    if (!target.empty() && target[0] == '['){
        // Bracketed IPv6 literal: [2606:9340:1002::10]:8080
        std::size_t end = target.find(']');
        if (end == std::string::npos)
            return std::pair<std::string, int>(target, default_port);

        host = target.substr(1, end - 1);
        if (end + 2 < target.length() && target[end + 1] == ':')
            port = target.substr(end + 2);
    } else {
        std::size_t colon = target.find(':');
        // More than one colon and no brackets: a bare IPv6 literal, not host:port.
        if (colon != std::string::npos && target.find(':', colon + 1) == std::string::npos){
            host = target.substr(0, colon);
            port = target.substr(colon + 1);
        }
    }

    int portno = port.empty() ? default_port : std::atoi(port.c_str());
    if (portno <= 0 || portno > 65535)
        portno = default_port;

    return std::pair<std::string, int>(host, portno);
}

bool SpeedTestClient::readLine(int &fd, std::string &buffer) {
    buffer.clear();
    if (!fd)
        return false;
    char c;
    while(true){
        auto n = read(fd, &c, 1);
        if (n == -1)
            return false;
        if (c == '\n' || c == '\r')
            break;

        buffer += c;

    }
    return true;
}

bool SpeedTestClient::writeLine(int &fd, const std::string &buffer) {
    if (!fd)
        return false;

    auto len = static_cast<ssize_t >(buffer.length());
    if (len == 0)
        return false;

    std::string buff_copy = buffer;

    if (buff_copy.find_first_of('\n') == std::string::npos){
        buff_copy += '\n';
        len += 1;
    }
    auto n = write(fd, buff_copy.c_str(), len);
    return n == len;
}