path: root/main.cpp

/*
 * Copyright (C) 2015 by Multi-Tech Systems
 *
 * This file is part of radio-query.
 *
 * radio-query is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * radio-query is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with radio-query.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#include <mts/MTS_Text.h>
#include <mts/MTS_Logger.h>
#include <mts/MTS_AutoPtr.h>
#include <mts/MTS_IO_ICellularRadio.h>
#include <mts/MTS_IO_CellularRadioFactory.h>
#include <json/json.h>
#include <sstream>
#include <getopt.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <iostream>
#include <climits>
#include <fstream>
#include <signal.h>
#include <unistd.h>
#include "Version.h"

const std::string DEFAULT_PORT("/dev/modem_at1");
const std::string DEFAULT_CACHE("/var/run/radio");
const std::string FMODEL("model");
const std::string FIMEI("imei");
const std::string FMEID("meid");
const std::string FIMSI("imsi");
const std::string FTYPE("type");
const std::string FCODE("code");
const std::string FRSSI("rssi");
const std::string FFIRMWARE("firmware");
const std::string FFIRMWAREBUILD("firmwarebuild");
const std::string FVENDORFIRMWARE("vendorfirmware");
const std::string FCARRIER("carrier");
const std::string FMDN("mdn");
const std::string FICCID("iccid");

std::string g_sCache(DEFAULT_CACHE);
std::string g_sModel;
std::string g_sType;
std::string g_sPort(DEFAULT_PORT);
Json::Value g_jData;
std::string g_sPdpContextId;

MTS::AutoPtr<MTS::IO::ICellularRadio> g_apRadio;

int32_t g_iOptions = 0;

const uint32_t OPT_INDIVIDUAL          = 0x00FFFFFF;
const uint32_t OPT_SUMMARY             = 0x7F000000;
const uint32_t OPT_INITIALIZE          = 0x10000000;

const uint32_t OPT_FIRMWARE            = 0x00000001;
const uint32_t OPT_IMEI                = 0x00000002;
const uint32_t OPT_IMSI                = 0x00000004;
const uint32_t OPT_LAC                 = 0x00000008;
const uint32_t OPT_MODEL               = 0x00000010;
const uint32_t OPT_NETREG              = 0x00000020;
const uint32_t OPT_NETWORK             = 0x00000040;
const uint32_t OPT_MDN                 = 0x00000080;
const uint32_t OPT_PHONENUMBER         = OPT_MDN;
const uint32_t OPT_RSSI                = 0x00000100;
const uint32_t OPT_TOWER               = 0x00000200;
const uint32_t OPT_ICCID               = 0x00000400;
const uint32_t OPT_SERVICE             = 0x00000800;
const uint32_t OPT_TYPE                = 0x00001000;
const uint32_t OPT_CARRIER             = 0x00002000;
const uint32_t OPT_DATETIME            = 0x00004000;
const uint32_t OPT_ACTIVEFIRMWARE      = 0x00008000;
const uint32_t OPT_LOCATION            = 0x00010000;
const uint32_t OPT_FIRMWAREBUILD       = 0x00020000;
const uint32_t OPT_SIM_STATUS          = 0x00040000;
const uint32_t OPT_RADIO_CODE          = 0x00080000;
const uint32_t OPT_SIM_CARRIER_CODE    = 0x00100000;
const uint32_t OPT_VENDORFIRMWARE      = 0x00200000;
const uint32_t OPT_UE_MODE_OF_OPERATION= 0x00400000;
const uint32_t OPT_SIM_MCC_MNC         = 0x00800000;

const uint32_t OPT_SUMMARY_STATIC      = 0x01000000;
const uint32_t OPT_SUMMARY_NETWORK     = 0x02000000;
const uint32_t OPT_CELL_MODE           = 0x04000000;
const uint32_t OPT_SUPPORTED_CELL_MODE = 0x08000000;
const uint32_t OPT_SELECTED_BANDS_RAW  = 0x20000000;

int32_t g_iAuxOptions = 0;
const uint32_t AOPT_VOICE_SUPPORT      = 0x00000001;
const uint32_t AOPT_PDP_CONF_STATIC    = 0x00000002;
const uint32_t AOPT_DIAGNOSTICS        = 0x00000004;

void handle_sigterm(int signum);
void printHelp(const std::string& sApp);
void parseOptions(int argc, char** argv);
void initializeCache();
void shutdown();
template<class T> bool writeToCache(const std::string& sFile, const T& tValue);
std::string cellularModeStr(MTS::IO::ICellularRadio::CELLULAR_MODES networks);

Json::Value getStaticData();
Json::Value getNetworkData();

std::string toCompactStyledString(const Json::Value& jData);

bool g_bIstty = false;

int main(int argc, char** argv) {
    using namespace MTS::IO;

    signal(SIGTERM, handle_sigterm);
    signal(SIGINT, handle_sigterm);

    MTS::Logger::setPrintLevel(MTS::Logger::PrintLevel::OFF_LEVEL, true);

    if (isatty(fileno(stdin)) && isatty(fileno(stdout)))
        g_bIstty = true;

    //Assuming cache needs to be built
    bool bBuildCache = true;

    parseOptions(argc, argv);

    printTrace("istty: %d\n", g_bIstty);

    if(!(g_iOptions & OPT_INITIALIZE)) {
        std::ifstream fModel;
        fModel.open(g_sCache + "/" + FMODEL);
        if(fModel.is_open()) {
            std::string sModel;
            fModel >> sModel;
            fModel.close();
            if(sModel.size() > 0) {
                printTrace("Pulling Model from cache: [%s]", sModel.c_str());
                g_sModel = sModel;
            }
            bBuildCache = false;
        }
    }

    MTS::IO::CellularRadioFactory factory;
    g_apRadio.reset(factory.create(g_sModel, g_sPort));

    if(g_apRadio.isNull() || !g_apRadio->initialize()) {
        printf("Error creating radio interface [%s][%s]\n", g_sPort.c_str(), g_sModel.c_str());
        exit(1);
    }

    if((g_iOptions & OPT_INITIALIZE) || bBuildCache) {
        initializeCache();
        if(g_iOptions & OPT_INITIALIZE) {
            //Initialization was the only purpose
            shutdown();
            return 0;
        }
    }

    ICellularRadio::CODE result = ICellularRadio::CODE::SUCCESS;
    if(g_iOptions & OPT_SUMMARY_NETWORK) {
        printf("%s", toCompactStyledString(getNetworkData()).c_str());
    } else if(g_iOptions & OPT_SUMMARY_STATIC) {
        printf("%s", toCompactStyledString(getStaticData()).c_str());
    } else if(g_iOptions & OPT_SIM_STATUS) {
        Json::Value jValue;
        result = g_apRadio->getSimStatusSummary(jValue);
        if(result == ICellularRadio::SUCCESS) {
            printf("%s", toCompactStyledString(jValue).c_str());
        }
    } else if(g_iOptions & OPT_RSSI) {
        int32_t iValue;
        result = g_apRadio->getSignalStrength(iValue);
        if(result == ICellularRadio::SUCCESS) {
            writeToCache(FRSSI, iValue);
            printf("%d", iValue);
        }
    }else if(g_iOptions & OPT_LOCATION) {
        std::string sValue;
        result = g_apRadio->getModemLocation(sValue);
        if(result == ICellularRadio::SUCCESS) {
            printf("%s", sValue.c_str());
        } else {
            printf("Radio has not location support");
        }
    }else if(g_iOptions & OPT_NETREG) {
        std::string sValue;
        ICellularRadio::REGISTRATION eReg;
        result = g_apRadio->getRegistration(eReg);
        if (result == ICellularRadio::SUCCESS) {
            result = g_apRadio->convertRegistrationToString(eReg, sValue);
            if (result == ICellularRadio::SUCCESS) {
                printf("%s", sValue.c_str());
            }
        }
    } else if(g_iOptions & OPT_LAC) {
        std::string sValue;
        result = g_apRadio->getLac(sValue);
        if(result == ICellularRadio::SUCCESS) {
            printf("%s", sValue.c_str());
        }
    } else if(g_iOptions & OPT_TOWER) {
        std::string sValue;
        result = g_apRadio->getTower(sValue);
        if(result == ICellularRadio::SUCCESS) {
            printf("%s", sValue.c_str());
        }
    } else if(g_iOptions & OPT_ICCID) {
        std::string sValue;
        result = g_apRadio->getIccid(sValue);
        if(result == ICellularRadio::SUCCESS) {
            writeToCache(FICCID, sValue);
            printf("%s", sValue.c_str());
        }
    } else if(g_iOptions & OPT_SERVICE) {
        std::string sValue;
        result = g_apRadio->getService(sValue);
        if(result == ICellularRadio::SUCCESS) {
            printf("%s", sValue.c_str());
        }
    } else if(g_iOptions & OPT_NETWORK) {
        std::string sValue;
        result = g_apRadio->getNetwork(sValue);
        if(result == ICellularRadio::SUCCESS) {
            printf("%s", sValue.c_str());
        }
    } else if(g_iOptions & OPT_MDN) {
        std::string sValue;
        result = g_apRadio->getMdn(sValue);
        if(result == ICellularRadio::SUCCESS) {
            writeToCache(FMDN, sValue);
            printf("%s", sValue.c_str());
        }
    } else if(g_iOptions & OPT_FIRMWARE) {
        std::string sValue;
        result = g_apRadio->getFirmware(sValue);
        if(result == ICellularRadio::SUCCESS) {
            writeToCache(FFIRMWARE, sValue);
            printf("%s", sValue.c_str());
        }
    } else if(g_iOptions & OPT_FIRMWAREBUILD) {
        std::string sValue;
        result = g_apRadio->getFirmwareBuild(sValue);
        if(result == ICellularRadio::SUCCESS) {
            writeToCache(FFIRMWAREBUILD, sValue);
            printf("%s", sValue.c_str());
        }
    } else if(g_iOptions & OPT_VENDORFIRMWARE) {
        std::string sValue;
        result = g_apRadio->getVendorFirmware(sValue);
        if(result == ICellularRadio::SUCCESS) {
            writeToCache(FVENDORFIRMWARE, sValue);
            printf("%s", sValue.c_str());
        }
    } else if(g_iOptions & OPT_IMEI) {
        std::string sValue;
        result = g_apRadio->getImei(sValue);
        if(result == ICellularRadio::SUCCESS) {
            printf("%s", sValue.c_str());
        }
    } else if(g_iOptions & OPT_IMSI) {
        std::string sValue;
        result = g_apRadio->getImsi(sValue);
        if(result == ICellularRadio::SUCCESS) {
            printf("%s", sValue.c_str());
        }
    } else if(g_iOptions & OPT_MODEL) {
        std::string sValue;
        result = g_apRadio->getModel(sValue);
        if(result == ICellularRadio::SUCCESS) {
            printf("%s", sValue.c_str());
        }
    } else if(g_iOptions & OPT_RADIO_CODE) {
        std::string sValue;
        std::string sCode;
        result = g_apRadio->getModel(sValue);
        if(result == ICellularRadio::SUCCESS) {
            result = g_apRadio->convertModelToMtsShortCode(g_sModel, sCode, g_apRadio.get());
            if(result == ICellularRadio::SUCCESS) {
                printf("%s", sCode.c_str());
            }
        }
    } else if(g_iOptions & OPT_TYPE) {
        std::string sValue;
        std::string sType;
        result = g_apRadio->getModel(sValue);
        if(result == ICellularRadio::SUCCESS) {
            result = g_apRadio->convertModelToType(sValue, sType);
            if(result == ICellularRadio::SUCCESS) {
                printf("%s", sType.c_str());
            }
        }
    } else if(g_iOptions & OPT_CARRIER) {
        std::string sValue;
        result = g_apRadio->getCarrier(sValue);
        if(result == ICellularRadio::SUCCESS) {
            writeToCache(FCARRIER, sValue);
            printf("%s", sValue.c_str());
        }
    } else if(g_iOptions & OPT_DATETIME) {
        std::string sDate, sTime, sZone;
        result = g_apRadio->getTime(sDate, sTime, sZone);
        if(result == ICellularRadio::SUCCESS) {
            printf("%s %s GMT%s", sDate.c_str(), sTime.c_str(), sZone.c_str());
        }
    } else if(g_iOptions & OPT_ACTIVEFIRMWARE) {
        std::string sValue;
        result = g_apRadio->getActiveFirmware(sValue);
        if(result == ICellularRadio::SUCCESS) {
            printf("%s", sValue.c_str());
        }
    } else if(g_iOptions & OPT_SUPPORTED_CELL_MODE) {
        std::string sValue;
        ICellularRadio::CELLULAR_MODES networks;
        result = g_apRadio->getSupportedCellularModes(networks);
        if (result == ICellularRadio::SUCCESS) {
            result = g_apRadio->convertCellModesToString(networks, sValue);
            if(result == ICellularRadio::SUCCESS) {
                printf("%s", sValue.c_str());
            }
        }
    } else if(g_iOptions & OPT_CELL_MODE) {
        std::string sValue;
        ICellularRadio::CELLULAR_MODES networks;
        result = g_apRadio->getCellularMode(networks);
        if (result == ICellularRadio::SUCCESS) {
            result = g_apRadio->convertCellModesToString(networks, sValue);
            if(result == ICellularRadio::SUCCESS) {
                printf("%s", sValue.c_str());
            }
        }
    } else if (g_iOptions & OPT_SIM_CARRIER_CODE) {
        std::string sValue;
        result = g_apRadio->getSimCarrierCode(sValue);
        if (result == ICellularRadio::SUCCESS) {
            printf("%s", sValue.c_str());
        }
    } else if (g_iOptions & OPT_UE_MODE_OF_OPERATION) {
        std::string sValue;
        ICellularRadio::UE_MODES_OF_OPERATION mode;
        result = g_apRadio->getUeModeOfOperation(mode);
        if (result == ICellularRadio::SUCCESS) {
            result = g_apRadio->convertUeModeToString(mode, sValue);
            if (result == ICellularRadio::SUCCESS) {
                printf("%s", sValue.c_str());
            }
        }
    } else if (g_iOptions & OPT_SIM_MCC_MNC) {
        std::string sMcc, sMnc;
        Json::Value jValue;
        result = g_apRadio->getSimMccMnc(sMcc, sMnc);
        if (result == ICellularRadio::SUCCESS) {
            jValue[MTS::IO::ICellularRadio::KEY_SIM_MCC] = sMcc;
            jValue[MTS::IO::ICellularRadio::KEY_SIM_MNC] = sMnc;
            printf("%s", toCompactStyledString(jValue).c_str());
        }
    } else if (g_iAuxOptions & AOPT_VOICE_SUPPORT) {
        Json::Value jValue;
        result = g_apRadio->getVoiceSupport(jValue);
        if (result == ICellularRadio::SUCCESS) {
            printf("%s", toCompactStyledString(jValue).c_str());
        }
    } else if (g_iOptions & OPT_SELECTED_BANDS_RAW) {
        std::string sResult;
        result = g_apRadio->getSelectedBandsRaw(sResult);
        if (result == ICellularRadio::SUCCESS) {
            printf("%s", sResult.c_str());
        }
    } else if (g_iAuxOptions & AOPT_PDP_CONF_STATIC) {
        Json::Value jValue;
        result = g_apRadio->getPdpContexts(jValue);
        if (result == ICellularRadio::SUCCESS) {
            if (g_sPdpContextId.empty()) {
                printf("%s", toCompactStyledString(jValue).c_str());
            } else {
                if (jValue.isMember(g_sPdpContextId)) {
                    printf("%s", toCompactStyledString(jValue[g_sPdpContextId]).c_str());
                } else {
                    result = ICellularRadio::CODE::FAILURE;
                }
            }
        }
    } else if (g_iAuxOptions & AOPT_DIAGNOSTICS) {
        std::string sValue;
        result = g_apRadio->getDiagnostics(sValue);

        // Print the results even if the radio has stopped responding at some point.
        if (result == ICellularRadio::SUCCESS || result == ICellularRadio::NO_RESPONSE) {
            printf("%s", sValue.c_str());
        }
    }

    if (g_bIstty && result == ICellularRadio::CODE::SUCCESS)
        printf("\n");

    shutdown();
    return (result == ICellularRadio::CODE::SUCCESS) ? 0 : 1;
}

void handle_sigterm(int signum) {
    if (signum == SIGTERM) {
        shutdown();
    }
}

void shutdown() {
    printDebug("Shutting Down");
    if(!g_apRadio.isNull()) {
        g_apRadio->shutdown();
        g_apRadio.reset();
    }
}

void initializeCache() {
    if(mkdir(g_sCache.c_str(), 0777) != 0) {
        if(errno != EEXIST) {
            printf("Error creating cache directory [%s] [%d][%s]\n", g_sCache.c_str(), errno, strerror(errno));
            exit(1);
        }
    }

    //Gather Static Information
    const Json::Value jData = getStaticData();

    printTrace("Static Data:\n%s\n", toCompactStyledString(jData).c_str());

    //Save to radio cache directory
    std::ofstream ofile;

    ofile.open(g_sCache + "/" + FMODEL);
    ofile << jData[MTS::IO::ICellularRadio::KEY_MODEL].asString();
    ofile.close();

    if(g_sType == MTS::IO::ICellularRadio::VALUE_TYPE_CDMA) {
        ofile.open(g_sCache + "/" + FIMEI);
        ofile << jData[MTS::IO::ICellularRadio::KEY_MEID].asString();
        ofile.close();
        ofile.open(g_sCache + "/" + FMEID);
        ofile << jData[MTS::IO::ICellularRadio::KEY_MEID].asString();
        ofile.close();
    } else {
        ofile.open(g_sCache + "/" + FIMEI);
        ofile << jData[MTS::IO::ICellularRadio::KEY_IMEI].asString();
        ofile.close();
        ofile.open(g_sCache + "/" + FMEID);
        ofile << jData[MTS::IO::ICellularRadio::KEY_IMEI].asString();
        ofile.close();
    }

    ofile.open(g_sCache + "/" + FIMSI);
    ofile << jData[MTS::IO::ICellularRadio::KEY_IMSI].asString();
    ofile.close();

    ofile.open(g_sCache + "/" + FTYPE);
    ofile << jData[MTS::IO::ICellularRadio::KEY_TYPE].asString();
    ofile.close();

    ofile.open(g_sCache + "/" + FCODE);
    ofile << jData[MTS::IO::ICellularRadio::KEY_CODE].asString();
    ofile.close();

    ofile.open(g_sCache + "/" + FFIRMWARE);
    ofile << jData[MTS::IO::ICellularRadio::KEY_FIRMWARE].asString();
    ofile.close();

    ofile.open(g_sCache + "/" + FFIRMWAREBUILD);
    ofile << jData[MTS::IO::ICellularRadio::KEY_FIRMWARE_BUILD].asString();
    ofile.close();

    ofile.open(g_sCache + "/" + FVENDORFIRMWARE);
    ofile << jData[MTS::IO::ICellularRadio::KEY_VENDOR_FIRMWARE].asString();
    ofile.close();

    ofile.open(g_sCache + "/" + FCARRIER);
    ofile << jData[MTS::IO::ICellularRadio::KEY_CARRIER].asString();
    ofile.close();
}

template<class T>
bool writeToCache(const std::string& sFile, const T& tValue) {

    std::ofstream ofile;
    ofile.open(g_sCache + "/" + sFile);
    if(!ofile.is_open()){
        return false;
    }

    std::stringstream ss;
    ss << tValue;

    ofile << ss.str();
    ofile.close();
    return true;
}

Json::Value getStaticData() {
    using namespace MTS::IO;
    Json::Value jData;

    std::string sImei;
    ICellularRadio::CODE eCode = g_apRadio->getImei(sImei);
    if(eCode != ICellularRadio::SUCCESS) {
        printWarning("Radio IMEI not found: %s", ICellularRadio::getCodeAsString(eCode).c_str());
    }

    if(g_apRadio->getModel(g_sModel) == ICellularRadio::SUCCESS) {
        jData[ICellularRadio::KEY_MODEL] = g_sModel;
    } else {
        printWarning("Radio model not found");
    }

    if(g_apRadio->convertModelToType(g_sModel, g_sType) == ICellularRadio::SUCCESS) {
        jData[ICellularRadio::KEY_TYPE] = g_sType;
    } else {
        printWarning("Radio type not supported");
    }

    std::string sCode(ICellularRadio::VALUE_UNKNOWN);
    if(ICellularRadio::convertModelToMtsShortCode(g_sModel, sCode, g_apRadio.get()) != ICellularRadio::SUCCESS) {
        printWarning("Radio MTS short code not supported");
    }
    jData[ICellularRadio::KEY_CODE] = sCode;

    if(g_sType == ICellularRadio::VALUE_TYPE_CDMA) {
        jData[ICellularRadio::KEY_MEID] = sImei;
    } else {
        jData[ICellularRadio::KEY_IMEI] = sImei;

        std::string sIccid;
        if(g_apRadio->getIccid(sIccid) == ICellularRadio::SUCCESS) {
            jData[ICellularRadio::KEY_ICCID] = sIccid;
        }
    }

    std::string sImsi(ICellularRadio::VALUE_UNKNOWN);
    if(g_apRadio->getImsi(sImsi) != ICellularRadio::SUCCESS) {
        printWarning("Radio IMSI not found");
    }
    jData[ICellularRadio::KEY_IMSI] = sImsi;

    std::string sMsid(ICellularRadio::VALUE_UNKNOWN);
    if(g_apRadio->getMsid(sMsid) != ICellularRadio::SUCCESS) {
        printWarning("Radio MSID not found");
    }
    jData[ICellularRadio::KEY_MSID] = sMsid;

    std::string sFirmware(ICellularRadio::VALUE_UNKNOWN);
    if(g_apRadio->getFirmware(sFirmware) != ICellularRadio::SUCCESS) {
        printWarning("Radio Firmware not found");
    }
    jData[ICellularRadio::KEY_FIRMWARE] = sFirmware;

    std::string sFirmwareBuild(ICellularRadio::VALUE_UNKNOWN);
    if(g_apRadio->getFirmwareBuild(sFirmwareBuild) != ICellularRadio::SUCCESS) {
        printWarning("Radio Firmware Build not found");
    }
    jData[ICellularRadio::KEY_FIRMWARE_BUILD] = sFirmwareBuild;

    std::string sVendorFirmware(ICellularRadio::VALUE_UNKNOWN);
    if(g_apRadio->getVendorFirmware(sVendorFirmware) != ICellularRadio::SUCCESS) {
        printWarning("Radio Vendor Firmware not found");
    }
    jData[ICellularRadio::KEY_VENDOR_FIRMWARE] = sVendorFirmware;

    std::string sCarrier(ICellularRadio::VALUE_UNKNOWN);
    if(g_apRadio->getCarrier(sCarrier) != ICellularRadio::SUCCESS) {
        printWarning("Radio Carrier not found");
    }
    jData[ICellularRadio::KEY_CARRIER] = sCarrier;


    std::string sHardware(ICellularRadio::VALUE_UNKNOWN);
    if(g_apRadio->getHardware(sHardware) != ICellularRadio::SUCCESS) {
        printWarning("Radio Hardware Version not found");
    }
    jData[ICellularRadio::KEY_HARDWARE] = sHardware;

    std::string sManufacturer(ICellularRadio::VALUE_UNKNOWN);
    if(g_apRadio->getManufacturer(sManufacturer) != ICellularRadio::SUCCESS) {
        printWarning("Radio Manufacturer not found");
    }
    jData[ICellularRadio::KEY_MANUFACTURER] = sManufacturer;

    std::string sMdn(ICellularRadio::VALUE_UNKNOWN);
    if(g_apRadio->getMdn(sMdn) == ICellularRadio::SUCCESS) {
        //CDMA Provisioned Flag
        if(g_sType == ICellularRadio::VALUE_TYPE_CDMA) {
            if(sMdn.size() == 0 || sMdn.find("000000") != std::string::npos) {
                jData["provisioned"] = false;
            } else {
                jData["provisioned"] = true;
            }
        }
    } else {
        printWarning("Radio MDN not found");
    }
    jData[ICellularRadio::KEY_MDN] = sMdn;

    Json::Value jMip;
    if(g_apRadio->getMipProfile(jMip) == MTS::IO::ICellularRadio::SUCCESS) {
        jData[MTS::IO::ICellularRadio::KEY_MIP] = jMip;
    }

    std::string sSupportedCellModes(ICellularRadio::VALUE_UNKNOWN);
    ICellularRadio::CELLULAR_MODES supportedCellModes;

    if(g_apRadio->getSupportedCellularModes(supportedCellModes) == ICellularRadio::SUCCESS) {
        g_apRadio->convertCellModesToString(supportedCellModes, sSupportedCellModes);
    }
    jData[MTS::IO::ICellularRadio::KEY_SUPPORTED_CELL_MODES] = sSupportedCellModes;

    std::string sCarrierCode(ICellularRadio::VALUE_UNKNOWN);
    if(g_apRadio->getSimCarrierCode(sCarrierCode) != ICellularRadio::SUCCESS) {
        printWarning("SIM carrier information not found");
    }
    jData[MTS::IO::ICellularRadio::KEY_SIM_CARRIER_CODE] = sCarrierCode;

    std::string sSimMcc(ICellularRadio::VALUE_UNKNOWN);
    std::string sSimMnc(ICellularRadio::VALUE_UNKNOWN);
    if(g_apRadio->getSimMccMnc(sSimMcc, sSimMnc) != ICellularRadio::SUCCESS) {
        printWarning("SIM carrier MCC/MNC information not found");
    }
    jData[MTS::IO::ICellularRadio::KEY_SIM_MCC] = sSimMcc;
    jData[MTS::IO::ICellularRadio::KEY_SIM_MNC] = sSimMnc;

    return jData;
}

Json::Value getNetworkData() {
    Json::Value jData;
    g_apRadio->getNetworkStatus(jData);
    return jData;
}

void parseOptions(int argc, char** argv) {
    int c;
    int iOption = 0;
    int iAuxOption = 0;
    std::string sPath;

    if(argc == 1) {
        printHelp(argv[0]);
        exit(0);
    }

    while (1) {
        static struct option long_options[] =
            { { "help",         no_argument,        0, '?' },
              { "version",      no_argument,        0, 'v' },
              { "device",       required_argument,  0, 'd' },
              { "printlvl",     required_argument,  0, 'p' },
              { "init",         optional_argument,  0, 'i' },
              { "cachedir",     required_argument,  0, 'c' },
              { "firmware",     no_argument,        &iOption, OPT_FIRMWARE },
              { "firmwarebuild",no_argument,        &iOption, OPT_FIRMWAREBUILD },
              { "vendorfirmware",no_argument,       &iOption, OPT_VENDORFIRMWARE },
              { "imei",         no_argument,        &iOption, OPT_IMEI },
              { "imsi",         no_argument,        &iOption, OPT_IMSI },
              { "lac",          no_argument,        &iOption, OPT_LAC },
              { "model",        no_argument,        &iOption, OPT_MODEL },
              { "netreg",       no_argument,        &iOption, OPT_NETREG },
              { "network",      no_argument,        &iOption, OPT_NETWORK },
              { "phonenumber",  no_argument,        &iOption, OPT_PHONENUMBER },
              { "mdn",          no_argument,        &iOption, OPT_MDN },
              { "rssi",         no_argument,        &iOption, OPT_RSSI },
              { "location",     no_argument,        &iOption, OPT_LOCATION },
              { "tower",        no_argument,        &iOption, OPT_TOWER },
              { "iccid",        no_argument,        &iOption, OPT_ICCID },
              { "service",      no_argument,        &iOption, OPT_SERVICE },
              { "type",         no_argument,        &iOption, OPT_TYPE },
              { "carrier",      no_argument,        &iOption, OPT_CARRIER },
              { "datetime",     no_argument,        &iOption, OPT_DATETIME },
              { "active-firmware", no_argument,     &iOption, OPT_ACTIVEFIRMWARE },
              { "sim-status",   no_argument,        &iOption, OPT_SIM_STATUS },
              { "code",         no_argument,        &iOption, OPT_RADIO_CODE },
              { "static",       no_argument,        &iOption, OPT_SUMMARY_STATIC },
              { "dynamic",      no_argument,        &iOption, OPT_SUMMARY_NETWORK },
              { "cellular-mode",no_argument,        &iOption, OPT_CELL_MODE },
              { "supported-cellular-modes", no_argument, &iOption, OPT_SUPPORTED_CELL_MODE },
              { "sim-carrier-code", no_argument,    &iOption, OPT_SIM_CARRIER_CODE },
              { "ue-mode-of-operation", no_argument,&iOption, OPT_UE_MODE_OF_OPERATION },
              { "sim-mcc-mnc",  no_argument,        &iOption, OPT_SIM_MCC_MNC },
              { "voice-support",no_argument,        &iAuxOption, AOPT_VOICE_SUPPORT },
              { "selected-bands-raw", no_argument,  &iOption, OPT_SELECTED_BANDS_RAW },
              { "pdp-conf-static", no_argument,     &iAuxOption, AOPT_PDP_CONF_STATIC },
              { "ctx-id",       required_argument,  0, 'C' },
              { "diagnostics",  no_argument,        &iAuxOption, AOPT_DIAGNOSTICS },
              { 0, 0, 0, 0 } };

        /* getopt_long stores the option index here. */
        int option_index = 0;

        c = getopt_long(argc, argv, "d:p:ic:?vC:", long_options, &option_index);

        /* Detect the end of the options. */
        if (c == -1) {
            break;
        }

        if(c == 0) {
            g_iOptions |= iOption;
            g_iAuxOptions |= iAuxOption;
            continue;
        }

        switch (c) {

            case '?':
                printHelp(argv[0]);
                exit(0);
                break;

            case 'v':
                printf("Version: %s\n", Version::version.c_str());
                exit(0);
                break;

            case 'p':
                int iPrintLvl;
                if(MTS::Text::parse(iPrintLvl, optarg) && iPrintLvl >= 0 && iPrintLvl <= 100) {
                    MTS::Logger::setPrintLevel(iPrintLvl);
                } else {
                    printf("print level out of range [0-100]\n");
                    exit(1);
                }
                break;

            case 'i':
                if(optarg != 0) {
                    g_sModel = optarg;
                }
                g_iOptions |= OPT_INITIALIZE;
                break;

            case 'c':
                if(optarg != 0) {
                    g_sCache = optarg;
                }
                break;

            case 'd':
                if(optarg != 0) {
                    g_sPort = optarg;
                }
                break;

            case 'C':
                if(optarg != 0) {
                    g_sPdpContextId = optarg;
                }
                break;

            default:
                printf("OPTION: [%d] ABORTING!!\n", c);
                abort();
                break;
        }
    }

    printTrace("OPTS: %08X\n", g_iOptions);

    /* Print any remaining command line arguments (not options). */
    if (optind < argc) {
        fprintf(stderr, "non-option ARGV-elements: \n");
        while (optind < argc)
            fprintf(stderr, "%s ", argv[optind++]);
        fprintf(stderr, "\n");
    }
}

void printHelp(const std::string& sApp) {
    printf("Usage: %s <opt1> <opt2> ...\n", sApp.c_str());
    printf("\tSimple utility to pull info from supported radios in a consistent manner\n");
    printf("\t--init (i)              : initializes the utility for all future calls\n");
    printf("\t--device (d) <device>   : specify modem device to query, default: /dev/modem_at1\n");
    printf("\t--printlvl (p) <level>  : sets the printlvl [0-100]\n");
    printf("\t--help (?)              : returns this message\n");
    printf("\t--version (v)           : returns version\n");
    printf("\n");
    printf("\tQueries:\n");
    printf("\t--firmware\n");
    printf("\t--firmwarebuild\n");
    printf("\t--vendorfirmware\n");
    printf("\t--imei\n");
    printf("\t--imsi\n");
    printf("\t--lac\n");
    printf("\t--model\n");
    printf("\t--code\n");
    printf("\t--netreg\n");
    printf("\t--network\n");
    printf("\t--phonenumber\n");
    printf("\t--mdn\n");
    printf("\t--rssi\n");
    printf("\t--location\n");
    printf("\t--tower\n");
    printf("\t--iccid\n");
    printf("\t--service\n");
    printf("\t--type\n");
    printf("\t--carrier\n");
    printf("\t--datetime\n");
    printf("\t--sim-status\n");
    printf("\t--cellular-mode\n");
    printf("\t--supported-cellular-modes\n");
    printf("\t--sim-carrier-code\n");
    printf("\t--ue-mode-of-operation\n");
    printf("\t--sim-mcc-mnc\n");
    printf("\t--voice-support\n");
    printf("\t--selected-bands-raw\n");
    printf("\t--pdp-conf-static --ctx-id <context-id>\n");
    printf("\t--diagnostics\n");
    // Applicable for LTE910-NA1 dual FW images only
    // printf("\t--active-firmware\n");
    printf("\n");
    printf("\tSupported Radios:\n");
    printf("\t\tHE910, GE910, DE910, CE910, LE910, ME910, EG95, EG25\n");
}

std::string toCompactStyledString(const Json::Value& jData) {
    Json::StreamWriterBuilder builder;
    builder["indentation"] = "\t";
    builder["commentStyle"] = "None";

    std::string sOut = Json::writeString(builder, jData);
    sOut += '\n';

    return sOut;
}