initial commit0.2

1 files changed, 601 insertions, 0 deletions

diff --git a/main.cpp b/main.cpp
new file mode 100644
index 0000000..46d2135
--- /dev/null
+++ b/main.cpp
@@ -0,0 +1,601 @@
+/*
+ * 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_CellularRadio.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 <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 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;
+
+MTS::AutoPtr<MTS::IO::CellularRadio> 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_SUMMARY_STATIC      = 0x01000000;
+const uint32_t OPT_SUMMARY_NETWORK     = 0x02000000;
+
+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);
+
+Json::Value getStaticData();
+Json::Value getNetworkData();
+
+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;
+        }
+    }
+
+    CellularRadio::CODE result = CellularRadio::CODE::SUCCESS;
+
+    if(g_iOptions & OPT_SUMMARY_NETWORK) {
+        printf("%s", getNetworkData().toStyledString().c_str());
+    } else if(g_iOptions & OPT_SUMMARY_STATIC) {
+        printf("%s", getStaticData().toStyledString().c_str());
+    } else if(g_iOptions & OPT_RSSI) {
+        int32_t iValue;
+        result = g_apRadio->getSignalStrength(iValue);
+        if(result == CellularRadio::SUCCESS) {
+            writeToCache(FRSSI, iValue);
+            printf("%d", iValue);
+        }
+    } else if(g_iOptions & OPT_NETREG) {
+        std::string sValue;
+        CellularRadio::REGISTRATION eReg;
+        result = g_apRadio->getRegistration(eReg);
+        if(result == CellularRadio::SUCCESS) {
+            result = g_apRadio->convertRegistrationToString(eReg, sValue);
+            if(result == CellularRadio::SUCCESS) {
+                printf("%s", sValue.c_str());
+            }
+        }
+    } else if(g_iOptions & OPT_LAC) {
+        std::string sValue;
+        result = g_apRadio->getLac(sValue);
+        if(result == CellularRadio::SUCCESS) {
+            printf("%s", sValue.c_str());
+        }
+    } else if(g_iOptions & OPT_TOWER) {
+        std::string sValue;
+        result = g_apRadio->getTower(sValue);
+        if(result == CellularRadio::SUCCESS) {
+            printf("%s", sValue.c_str());
+        }
+    } else if(g_iOptions & OPT_ICCID) {
+        std::string sValue;
+        result = g_apRadio->getIccid(sValue);
+        if(result == CellularRadio::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 == CellularRadio::SUCCESS) {
+            printf("%s", sValue.c_str());
+        }
+    } else if(g_iOptions & OPT_NETWORK) {
+        std::string sValue;
+        result = g_apRadio->getNetwork(sValue);
+        if(result == CellularRadio::SUCCESS) {
+            printf("%s", sValue.c_str());
+        }
+    } else if(g_iOptions & OPT_MDN) {
+        std::string sValue;
+        result = g_apRadio->getMdn(sValue);
+        if(result == CellularRadio::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 == CellularRadio::SUCCESS) {
+            writeToCache(FFIRMWARE, sValue);
+            printf("%s", sValue.c_str());
+        }
+    } else if(g_iOptions & OPT_IMEI) {
+        std::string sValue;
+        result = g_apRadio->getImei(sValue);
+        if(result == CellularRadio::SUCCESS) {
+            printf("%s", sValue.c_str());
+        }
+    } else if(g_iOptions & OPT_IMSI) {
+        std::string sValue;
+        result = g_apRadio->getImsi(sValue);
+        if(result == CellularRadio::SUCCESS) {
+            printf("%s", sValue.c_str());
+        }
+    } else if(g_iOptions & OPT_MODEL) {
+        std::string sValue;
+        result = g_apRadio->getModel(sValue);
+        if(result == CellularRadio::SUCCESS) {
+            printf("%s", sValue.c_str());
+        }
+    } else if(g_iOptions & OPT_TYPE) {
+        std::string sValue;
+        std::string sType;
+        result = g_apRadio->getModel(sValue);
+        if(result == CellularRadio::SUCCESS) {
+            result = g_apRadio->convertModelToType(sValue, sType);
+            if(result == CellularRadio::SUCCESS) {
+                printf("%s", sType.c_str());
+            }
+        }
+    } else if(g_iOptions & OPT_CARRIER) {
+        std::string sValue;
+        result = g_apRadio->getCarrier(sValue);
+        if(result == CellularRadio::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 == CellularRadio::SUCCESS) {
+            printf("%s %s GMT%s", sDate.c_str(), sTime.c_str(), sZone.c_str());
+        }
+    }
+
+    if (g_bIstty && result == CellularRadio::CODE::SUCCESS)
+        printf("\n");
+
+    shutdown();
+    return (result == CellularRadio::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", jData.toStyledString().c_str());
+
+    //Save to radio cache directory
+    std::ofstream ofile;
+
+    ofile.open(g_sCache + "/" + FMODEL);
+    ofile << jData[MTS::IO::CellularRadio::KEY_MODEL].asString();
+    ofile.close();
+
+    if(g_sType == MTS::IO::CellularRadio::VALUE_TYPE_CDMA) {
+        ofile.open(g_sCache + "/" + FIMEI);
+        ofile << jData[MTS::IO::CellularRadio::KEY_MEID].asString();
+        ofile.close();
+        ofile.open(g_sCache + "/" + FMEID);
+        ofile << jData[MTS::IO::CellularRadio::KEY_MEID].asString();
+        ofile.close();
+    } else {
+        ofile.open(g_sCache + "/" + FIMEI);
+        ofile << jData[MTS::IO::CellularRadio::KEY_IMEI].asString();
+        ofile.close();
+        ofile.open(g_sCache + "/" + FMEID);
+        ofile << jData[MTS::IO::CellularRadio::KEY_IMEI].asString();
+        ofile.close();
+    }
+
+    ofile.open(g_sCache + "/" + FIMSI);
+    ofile << jData[MTS::IO::CellularRadio::KEY_IMSI].asString();
+    ofile.close();
+
+    ofile.open(g_sCache + "/" + FTYPE);
+    ofile << jData[MTS::IO::CellularRadio::KEY_TYPE].asString();
+    ofile.close();
+
+    ofile.open(g_sCache + "/" + FCODE);
+    ofile << jData[MTS::IO::CellularRadio::KEY_CODE].asString();
+    ofile.close();
+
+    ofile.open(g_sCache + "/" + FFIRMWARE);
+    ofile << jData[MTS::IO::CellularRadio::KEY_FIRMWARE].asString();
+    ofile.close();
+
+    ofile.open(g_sCache + "/" + FCARRIER);
+    ofile << jData[MTS::IO::CellularRadio::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;
+    CellularRadio::CODE eCode = g_apRadio->getImei(sImei);
+    if(eCode != CellularRadio::SUCCESS) {
+        printWarning("Radio IMEI not found: %s", CellularRadio::getCodeAsString(eCode).c_str());
+    }
+
+    if(g_apRadio->getModel(g_sModel) == CellularRadio::SUCCESS) {
+        jData[CellularRadio::KEY_MODEL] = g_sModel;
+    } else {
+        printWarning("Radio model not found");
+    }
+
+    if(g_apRadio->convertModelToType(g_sModel, g_sType) == CellularRadio::SUCCESS) {
+        jData[CellularRadio::KEY_TYPE] = g_sType;
+    } else {
+        printWarning("Radio type not supported");
+    }
+
+    std::string sCode(CellularRadio::VALUE_UNKNOWN);
+    if(g_apRadio->convertModelToMtsShortCode(g_sModel, sCode) != CellularRadio::SUCCESS) {
+        printWarning("Radio MTS short code not supported");
+    }
+    jData[CellularRadio::KEY_CODE] = sCode;
+
+    if(g_sType == CellularRadio::VALUE_TYPE_CDMA) {
+        jData[CellularRadio::KEY_MEID] = sImei;
+    } else {
+        jData[CellularRadio::KEY_IMEI] = sImei;
+
+        std::string sIccid;
+        if(g_apRadio->getIccid(sIccid) == CellularRadio::SUCCESS) {
+            jData[CellularRadio::KEY_ICCID] = sIccid;
+        }
+    }
+
+    std::string sImsi(CellularRadio::VALUE_UNKNOWN);
+    if(g_apRadio->getImsi(sImsi) != CellularRadio::SUCCESS) {
+        printWarning("Radio IMSI not found");
+    }
+    jData[CellularRadio::KEY_IMSI] = sImsi;
+
+    std::string sMsid(CellularRadio::VALUE_UNKNOWN);
+    if(g_apRadio->getMsid(sMsid) != CellularRadio::SUCCESS) {
+        printWarning("Radio MSID not found");
+    }
+    jData[CellularRadio::KEY_MSID] = sMsid;
+
+    std::string sFirmware(CellularRadio::VALUE_UNKNOWN);
+    if(g_apRadio->getFirmware(sFirmware) != CellularRadio::SUCCESS) {
+        printWarning("Radio Firmware not found");
+    }
+    jData[CellularRadio::KEY_FIRMWARE] = sFirmware;
+
+    std::string sCarrier(CellularRadio::VALUE_UNKNOWN);
+    if(g_apRadio->getCarrier(sCarrier) != CellularRadio::SUCCESS) {
+        printWarning("Radio Carrier not found");
+    }
+    jData[CellularRadio::KEY_CARRIER] = sCarrier;
+
+
+    std::string sHardware(CellularRadio::VALUE_UNKNOWN);
+    if(g_apRadio->getHardware(sHardware) != CellularRadio::SUCCESS) {
+        printWarning("Radio Hardware Version not found");
+    }
+    jData[CellularRadio::KEY_HARDWARE] = sHardware;
+
+    std::string sManufacturer(CellularRadio::VALUE_UNKNOWN);
+    if(g_apRadio->getManufacturer(sManufacturer) != CellularRadio::SUCCESS) {
+        printWarning("Radio Manufacturer not found");
+    }
+    jData[CellularRadio::KEY_MANUFACTURER] = sManufacturer;
+
+    std::string sMdn(CellularRadio::VALUE_UNKNOWN);
+    if(g_apRadio->getMdn(sMdn) == CellularRadio::SUCCESS) {
+        //CDMA Provisioned Flag
+        if(g_sType == CellularRadio::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[CellularRadio::KEY_MDN] = sMdn;
+
+    Json::Value jMip;
+    if(g_apRadio->getMipProfile(jMip) == MTS::IO::CellularRadio::SUCCESS) {
+        jData[MTS::IO::CellularRadio::KEY_MIP] = jMip;
+    }
+
+    return jData;
+}
+
+Json::Value getNetworkData() {
+    Json::Value jData;
+    g_apRadio->getNetworkStatus(jData);
+    return jData;
+}
+
+void parseOptions(int argc, char** argv) {
+    int c;
+    int iOption;
+    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 },
+              { "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 },
+              { "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 },
+              { "static",       no_argument,        &iOption, OPT_SUMMARY_STATIC },
+              { "dynamic",      no_argument,        &iOption, OPT_SUMMARY_NETWORK },
+              { 0, 0, 0, 0 } };
+
+        /* getopt_long stores the option index here. */
+        int option_index = 0;
+
+        c = getopt_long(argc, argv, "d:p:ic:?v", long_options, &option_index);
+
+        /* Detect the end of the options. */
+        if (c == -1) {
+            break;
+        }
+
+        if(c == 0) {
+            g_iOptions |= iOption;
+            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;
+
+            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--imei\n");
+    printf("\t--imsi\n");
+    printf("\t--lac\n");
+    printf("\t--model\n");
+    printf("\t--netreg\n");
+    printf("\t--network\n");
+    printf("\t--phonenumber\n");
+    printf("\t--mdn\n");
+    printf("\t--rssi\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("\n");
+    printf("\tSupported Radios:\n");
+    printf("\t\tHE910, GE910, DE910, CE910\n");
+}