Must use a reference in loop variables with newer gcc

2 files changed, 632 insertions, 2 deletions

diff --git a/src/Device/Device.cpp b/src/Device/Device.cpp
index d52fa93..3f7cf27 100644
--- a/src/Device/Device.cpp
+++ b/src/Device/Device.cpp
@@ -250,7 +250,7 @@ void Device::load() {
     mapFileToCapability();
     mapFirmware();
     mapMacAddress2();
-    for (const auto capability : capabilityList) {
+    for (const auto &capability : capabilityList) {
         capabilities.AddMember(
             rapidjson::Value().SetString(capability.first.c_str(),
                                          capability.first.length(), acAlloc),
@@ -296,7 +296,7 @@ void Device::load() {
         ethSwitch.AddMember("ports", std::move(ports), ethSwitchAlloc);
     }
 
-    for (const auto device : deviceInfoList) {
+    for (const auto &device : deviceInfoList) {
         deviceInfo.AddMember(
             rapidjson::Value().SetString(device.first.c_str(),
                                          device.first.length(), alloc),
diff --git a/src/Device/Device.cpp.orig b/src/Device/Device.cpp.orig
new file mode 100644
index 0000000..d52fa93
--- /dev/null
+++ b/src/Device/Device.cpp.orig
@@ -0,0 +1,630 @@
+/**********************************************************************
+ * COPYRIGHT 2020 MULTI-TECH SYSTEMS, INC.
+ *
+ * ALL RIGHTS RESERVED BY AND FOR THE EXCLUSIVE BENEFIT OF
+ * MULTI-TECH SYSTEMS, INC.
+ *
+ * MULTI-TECH SYSTEMS, INC. - CONFIDENTIAL AND PROPRIETARY
+ * INFORMATION AND/OR TRADE SECRET.
+ *
+ * NOTICE: ALL CODE, PROGRAM, INFORMATION, SCRIPT, INSTRUCTION,
+ * DATA, AND COMMENT HEREIN IS AND SHALL REMAIN THE CONFIDENTIAL
+ * INFORMATION AND PROPERTY OF MULTI-TECH SYSTEMS, INC.
+ * USE AND DISCLOSURE THEREOF, EXCEPT AS STRICTLY AUTHORIZED IN A
+ * WRITTEN AGREEMENT SIGNED BY MULTI-TECH SYSTEMS, INC. IS PROHIBITED.
+ *
+ ***********************************************************************/
+
+#include <gpiod.h>
+#include "Device.h"
+
+const std::vector<std::string> Device::apIdentifiers = {
+    "ap1", "ap2", "lora", "lora-2", "slot1", "slot2"};
+const std::regex
+    Device::apFilters("(modalias)|(power)(.*)|(subsystem)|(uevent)");
+const std::regex Device::serialModeFilter("(.*)(serial-mode)");
+const std::regex Device::mtcdt3HwVersionFilters("(MTCDT3AC)(.*)");
+const std::regex Device::mtrFilters("(MTR-)(.*)");
+const std::regex Device::storeFilters(
+    "(.*)(mac-)(.*)|(.*)(-id)|(uuid)|(.*)(/eui)|(.*)(/"
+    "cdone)|(.*)(hw-version)|(oem-string)(.*)|(imei)|(capability)(.*)|(radio-"
+    "reset-backoff-seconds)|(modalias)|(power)|((subsystem)(.*))|(uevent)|("
+    "board-temperature)|(reset)|(led3)|(led-ls)|(usbhd-ps-oc)|(.*)(adc[0-9])|(."
+    "*)(din[0-9])|(gpi[0-9])|(gpi[0-9][0-9])");
+const std::regex Device::showFilters("(modalias)|(subsystem)|(uevent)");
+
+std::map<std::string, bool> Device::capabilityList = {
+    {"adc", false},
+    {"battery", false},
+    {"bluetooth", false},
+    {"cell", false},
+    {"cellPpp", false},
+    {"cellWwan", false},
+    {"din", false},
+    {"dout", false},
+    {"externalSerialPort", false},
+    {"gpio", false},
+    {"gps", false},
+    {"lora", false},
+    {"loraLbt", false},
+    {"loraNetworkServer", false},
+    {"nodeRed", false},
+    {"rs232", false},
+    {"rs422", false},
+    {"rs485", false},
+    {"serial", false},
+    {"supercap", false},
+    {"wifi", false},
+    {"docker", false},
+    {"tpm", false},
+    {"userDataEncryption", false}};
+
+std::map<std::string, std::string> Device::ethSwitchList;
+
+std::map<std::string, std::string> Device::deviceInfoList = {
+    {"deviceId", ""},
+    {"hardwareVersion", ""},
+    {"imei", ""},
+    {"macAddress", "00:00:00:00:00:00"},
+    {"macBluetooth", "00:00:00:00:00:00"},
+    {"macWifi", "00:00:00:00:00:00"},
+    {"productId", ""},
+    {"uuid", ""},
+    {"vendorId", ""},
+    {"oemString1", ""},
+    {"oemString2", ""}};
+
+Device::Device() {
+    isRoot = !getuid();
+    accessoryCardsList.reserve(accessoryCardsListSize);
+    accessoryCardsList.push_back(std::make_unique<Lora21Card>(*this));
+    accessoryCardsList.push_back(std::make_unique<Lora21ExtCard>(*this));
+    accessoryCardsList.push_back(std::make_unique<Lora03Card>(*this));
+    accessoryCardsList.push_back(std::make_unique<Lora10Card>(*this));
+    accessoryCardsList.push_back(std::make_unique<Lora15Card>(*this));
+    accessoryCardsList.push_back(std::make_unique<Lora2G4Card>(*this));
+    accessoryCardsList.push_back(std::make_unique<Gpiob>(*this));
+    accessoryCardsList.push_back(std::make_unique<Mfser>(*this));
+}
+
+bool Device::isAccessoryCard(const char *d_name, const char *dir_name) {
+    return std::binary_search(apIdentifiers.begin(), apIdentifiers.end(),
+                              dir_name) &&
+           !regex_match(d_name, apFilters);
+}
+
+void Device::sortAccessoryCards() {
+    rapidjson::SizeType i, j;
+    for (i = 0; i < accessoryCards.Size() - 1; i++) {
+        for (j = 0; j < accessoryCards.Size() - i - 1; j++) {
+            if (accessoryCards[j]["port"].GetString() <
+                accessoryCards[j + 1]["port"].GetString()) {
+                accessoryCards[j].Swap(accessoryCards[j + 1]);
+            }
+        }
+    }
+}
+
+bool Device::isValidDirectory(const struct dirent *entry, std::string fullPath,
+                              const char *d_name) {
+    std::string path = fullPath + "/" + std::string(d_name);
+    return (entry->d_type & DT_DIR) && strcmp(d_name, "..") != 0 &&
+           strcmp(d_name, ".") != 0 && (path.length() < PATH_MAX);
+}
+
+void Device::getSystemTreeJson(const char *dir_name) {
+    std::string fullPath = SYSFS_PLATFORM + std::string(dir_name);
+    DIR *d = opendir(fullPath.c_str());
+
+    if (!d) {
+        printError("Cannot open directory %s", fullPath);
+        exitHandler(99);
+    }
+    while (1) {
+        struct dirent *entry =
+            readdir(d); /* Gets subsequent entries from "d" */
+        if (!entry) {   /* If there are no more entries, exit */
+            break;
+        }
+        const char *d_name = entry->d_name; /* Get file name */
+        std::string fileData;
+        if (!(entry->d_type & DT_DIR) &&
+            (MTS::System::readFile(fullPath + "/" + std::string(d_name),
+                                   fileData) == 0)) {
+            fileData = MTS::Text::trim(fileData);
+            if (strlen(dir_name) > 0) {
+                if (isAccessoryCard(d_name, dir_name)) {
+                    if (accessoryCard.IsNull()) {
+                        accessoryCard.SetObject();
+                        accessoryCard.AddMember(
+                            "port",
+                            rapidjson::Value().SetString(dir_name, acAlloc),
+                            acAlloc);
+                    } else if (accessoryCard["port"] != dir_name) {
+                        accessoryCards.PushBack(accessoryCard, acAlloc);
+                        accessoryCard.SetObject();
+                        accessoryCard.AddMember(
+                            "port",
+                            rapidjson::Value().SetString(dir_name, acAlloc),
+                            acAlloc);
+                    }
+                    if (strcmp(d_name, "product-id") ==
+                        0) { /* Map card specific details based on the product
+                                id */
+                        for (unsigned int i = 0; i < accessoryCardsList.size();
+                             i++) {
+                            if (regex_match(fileData,
+                                            accessoryCardsList[i]->GetName())) {
+                                accessoryCardsList[i]->AddToDeviceInfo(
+                                    dir_name, fileData);
+                                break;
+                            }
+                        }
+                    }
+                    accessoryCard.AddMember(
+                        rapidjson::Value().SetString(
+                            toCamelCase(d_name).c_str(), acAlloc),
+                        rapidjson::Value().SetString(fileData.c_str(), acAlloc),
+                        acAlloc);
+                } else if (strcmp(dir_name, "capability") == 0 &&
+                           fileData == "1") {
+                    capabilityList[toCamelCase(d_name)] = true;
+                } else if (strcmp(dir_name, "eth-switch") == 0) {
+                    ethSwitchList[toCamelCase(d_name)] = fileData;
+                }
+            } else if ((entry->d_type != DT_LNK)) {
+                if (deviceInfoList.count(toCamelCase(d_name)) > 0) {
+                    deviceInfoList[toCamelCase(d_name)] = fileData;
+                } else if (strcmp(d_name, "hw-version") == 0) {
+                    deviceInfoList["hardwareVersion"] = fileData;
+                    if (regex_match(fileData, mtcdt3HwVersionFilters)) {
+                        capabilityList["rs232"] = true;
+                        capabilityList["rs422"] = true;
+                        capabilityList["rs485"] = true;
+                        capabilityList["serial"] = true;
+                    }
+                } else if (strcmp(d_name, "mac-eth") == 0) {
+                    deviceInfoList["macAddress"] = fileData;
+                } else if (strcmp(d_name, "has-radio") == 0 &&
+                           fileData == "1") {
+                    capabilityList["cell"] = true;
+                } else if (strcmp(d_name, "oem-string1") == 0) {
+                    deviceInfoList["oemString1"] = fileData;
+                } else if (strcmp(d_name, "oem-string2") == 0) {
+                    deviceInfoList["oemString2"] = fileData;
+                };
+                if (strcmp(d_name, "product-id") == 0) {
+                    if (regex_match(fileData, mtrFilters)) {
+                        capabilityList["rs232"] = true;
+                        capabilityList["serial"] = true;
+                    }
+                }
+            }
+        }
+        if (isValidDirectory(entry, fullPath,
+                             d_name)) { /* Check that the directory is not "d"
+                                           or d's parent */
+            getSystemTreeJson(d_name);  /* Recursively call with the new path */
+        }
+    }
+    if (closedir(
+            d)) { /* After going through all the entries, close the directory */
+        printError("Could not close %s", fullPath);
+        exitHandler(errno);
+    }
+}
+
+void Device::init() {
+    if (!isRoot) {
+        printError("Must be root to generate device_info.json");
+        exitHandler(99);
+    }
+    load();
+    writeJson();
+    exitHandler(0);
+}
+
+void Device::json() {
+    if (!isRoot) {
+        printError("Must be root to generate json");
+        exitHandler(99);
+    }
+    load();
+    printJson();
+    exitHandler(0);
+}
+
+void Device::load() {
+    deviceInfo.SetObject();
+    capabilities.SetObject();
+    ethSwitch.SetObject();
+    accessoryCards.SetArray();
+    getSystemTreeJson("");
+    if (!accessoryCard.IsNull()) {
+        accessoryCards.PushBack(accessoryCard, acAlloc);
+        if (accessoryCards.Size() > 1) {
+            sortAccessoryCards();
+        }
+    }
+
+    mapFileToCapability();
+    mapFirmware();
+    mapMacAddress2();
+    for (const auto capability : capabilityList) {
+        capabilities.AddMember(
+            rapidjson::Value().SetString(capability.first.c_str(),
+                                         capability.first.length(), acAlloc),
+            capability.second, acAlloc);
+    }
+
+    if (ethSwitchList.count("chip") && ethSwitchList.count("numPorts")) {
+        auto &ethSwitchAlloc = ethSwitch.GetAllocator();
+        const std::string &chip = ethSwitchList.at("chip");
+        ethSwitch.AddMember("chip",
+                            rapidjson::Value().SetString(
+                                chip.c_str(), chip.length(), ethSwitchAlloc),
+                            ethSwitchAlloc);
+        rapidjson::Value ports;
+        ports.SetObject();
+        for (int i = 0; i < std::stoi(ethSwitchList.at("numPorts")); ++i) {
+            const std::string num = std::to_string(i);
+            const std::string keyLabel = "port" + num + "Label";
+            const std::string keyId = "port" + num + "Id";
+            const std::string keyMac = "port" + num + "Mac";
+            ;
+            if (ethSwitchList.count(keyLabel) && ethSwitchList.count(keyId) &&
+                ethSwitchList.count(keyMac)) {
+                rapidjson::Value port;
+                port.SetObject();
+                port.AddMember("id",
+                               rapidjson::Value().SetInt(
+                                   std::stoi(ethSwitchList.at(keyId))),
+                               ethSwitchAlloc);
+                port.AddMember("mac",
+                               rapidjson::Value().SetString(
+                                   ethSwitchList.at(keyMac).c_str(),
+                                   ethSwitchList.at(keyMac).length(),
+                                   ethSwitchAlloc),
+                               ethSwitchAlloc);
+                ports.AddMember(rapidjson::Value().SetString(
+                                    ethSwitchList.at(keyLabel).c_str(),
+                                    ethSwitchList.at(keyLabel).length(),
+                                    ethSwitchAlloc),
+                                std::move(port), ethSwitchAlloc);
+            }
+        }
+        ethSwitch.AddMember("ports", std::move(ports), ethSwitchAlloc);
+    }
+
+    for (const auto device : deviceInfoList) {
+        deviceInfo.AddMember(
+            rapidjson::Value().SetString(device.first.c_str(),
+                                         device.first.length(), alloc),
+            rapidjson::Value().SetString(device.second.c_str(),
+                                         device.second.length(), alloc),
+            alloc);
+    }
+
+    deviceInfo.AddMember("capabilities", capabilities, alloc);
+    deviceInfo.AddMember("ethSwitch", ethSwitch, alloc);
+    deviceInfo.AddMember("accessoryCards", accessoryCards, alloc);
+}
+
+void Device::mapFileToCapability() {
+    if (fileType("/opt/node-red") == S_IFDIR) { /* node-red is a directory */
+        capabilityList["nodeRed"] = true;
+    }
+    if (fileType("/opt/lora/lora-network-server") ==
+        S_IFREG) { /* lora-network-server is a regular file */
+        capabilityList["loraNetworkServer"] = true;
+    }
+    if (capabilityList["cell"]) { /* only on devices with Cellular */
+        if (fileType("/dev/cdc-wdm0") == S_IFCHR) {
+            /* Cellular modem is wwan/qmi/mbim character device */
+            capabilityList["cellWwan"] = true;
+        }
+        if (!fileExists("/dev/modem_at0") && fileType("/dev/modem_at1") == S_IFCHR) {
+            /* Cellular modem without PPP support, probably uses ECM WWAN */
+            capabilityList["cellWwan"] = true;
+        } else {
+            /* all other radios - assume PPP is supported */
+            capabilityList["cellPpp"] = true;
+        }
+    }
+    if (fileType("/dev/ext_serial") ==
+        S_IFCHR) { /* ext_serial is a character device */
+        capabilityList["externalSerialPort"] = true;
+    }
+    if (fileType("/usr/bin/dockerd") ==
+        S_IFREG) { /* Docker is a regular file */
+        capabilityList["docker"] = true;
+    }
+    if (findFileGlob("/dev/tpm*") == S_IFCHR) { /* tpm* is a character device */
+        capabilityList["tpm"] = true;
+    }
+}
+
+void Device::mapMacAddress2() {
+    std::ifstream file("/sys/devices/platform/mts-io/base/mac-eth");
+    if (file.is_open()) {
+        std::string line = "";
+        std::getline(file, line);
+        deviceInfoList["macAddress1"] = line;
+    }
+}
+
+void Device::mapFirmware() {
+    std::ifstream file(FIRMWARE_FILE);
+    if (!file.is_open()) {
+        return;
+    }
+    std::string line;
+    while (std::getline(file, line)) {
+        if (line.find(FIRMWARE_VERSION) != std::string::npos) {
+            deviceInfoList["firmware"] = line.substr(line.find(" ") + 1);
+        } else if (line.find(FIRMWARE_DATE) != std::string::npos) {
+            deviceInfoList["firmwareDate"] = line.substr(line.find(" ") + 1);
+        } else if (line.find(FIRMWARE_RELEASE) != std::string::npos) {
+            deviceInfoList["firmwareRelease"] = line.substr(line.find(" ") + 1);
+        }
+    }
+}
+
+void Device::printDir(const std::string dir_name,
+                      std::vector<std::string> &results) {
+    std::string fullPath = SYSFS_PLATFORM + std::string(dir_name);
+    DIR *d = opendir(fullPath.c_str());
+    if (!d) {
+        printError("Cannot open directory %s", fullPath);
+        exitHandler(99);
+    }
+    while (1) {
+        struct dirent *entry = readdir(d);
+        if (!entry) {
+            break;
+        }
+        const char *d_name = entry->d_name;
+        if (!(entry->d_type & DT_DIR)) {
+            std::string result;
+            if (dir_name.size() > 0) {
+                result = (dir_name + "/");
+            }
+            result.append(d_name);
+            results.push_back(result);
+        }
+        if (isValidDirectory(entry, fullPath,
+                             d_name)) { /* Check that the directory is not "d"
+                                           or d's parent. */
+            printDir(d_name, results);
+        }
+    }
+    if (closedir(d)) { /* After going through all the entries, close the
+                          directory. */
+        printError("Could not close %s", fullPath);
+        exitHandler(errno);
+    }
+}
+
+void Device::printJson() {
+    rapidjson::StringBuffer buffer;
+    rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
+    deviceInfo.Accept(writer);
+    std::cout << buffer.GetString();
+}
+
+void Device::printVersion(std::string name) {
+    printInfo(
+        "%s %s\nCopyright (C) 2022 by Multi-Tech Systems\nThis program is free "
+        "software; you may redistribute it under the terms of\nthe GNU General "
+        "Public License version 2 or (at your option) any later version.\nThis "
+        "program has absolutely no warranty.",
+        name.c_str(), Version::version.c_str());
+    exitHandler(0);
+}
+
+void Device::printUsage(std::string program) {
+    std::vector<std::string> showResults;
+    printf("Usage: %s [ OPTIONS ] OBJECT [--] [ ARGUMENTS ]\n", program.c_str());
+    printf("Legacy OBJECT options:\n");
+    printf("   init                : init & make device info json\n");
+    printf("   json                : init & make device info json\n");
+    printf("   show                : show data for file\n");
+    printf("   show-trigger        : show trigger data for file\n");
+    printf("   store               : store data for file\n");
+    printf("   store-trigger       : store trigger data for file\n");
+    printf("   load-fpga           : load fpga version\n");
+    printf("Updated OBJECT options:\n");
+    printf("   -I, --init          : init & make device info json\n");
+    printf("   -j, --json          : output device info json\n");
+    printf("   -s, --show          : show data for file\n");
+    printf("   -S, --show-trigger  : show trigger data for file\n");
+    printf("   -t, --store         : store data for file\n");
+    printf("   -T, --store-trigger : store trigger data for file\n");
+    printf("   -l, --load-fpga     : update fpga version\n");
+    printf("   -c, --check         : check fpga version\n");
+    printf("   -v, --version       : show version\n");
+    printf("   -h, --help          : show help\n");
+    printf("\n");
+    printf("Options\n");
+    printf("   -V, --verbose       : show additional debug output\n");
+    printf("FPGA\n");
+    printf("Arguments:\n");
+    printf("   -p, --path          : path for card\n");
+    printf("                       : options: 1 for ap1, 2 for ap2 everything else\n");
+    printf("                       : is an expected full path. i.e. /dev/spidevX.X\n");
+    printf("   -i, --input         : input file for upgrade\n");
+    printf("                       : files are stored in /usr/lib/mts-flash-binaries\n");
+    printf("Usage:\n");
+    printf("   Load                : mts-io-sysfs -l -p <path> -i <file>\n");
+    printf("   Check               : mts-io-sysfs -c -p <path>\n");
+    printf("\n");
+    printf("show-name:\n");
+    printf("Usage:\n");
+    printf("--show-name <name>\n");
+    printDir("", showResults);
+    sort(showResults.begin(),
+         showResults.end()); // Unix file tree is not sorted
+
+    for (std::string showResult : showResults) {
+        if (!regex_match(showResult, showFilters))
+            printf("          %s\n", showResult.c_str());
+    }
+    printf("\n");
+    printf("store-name:\n");
+    printf("Usage:\n");
+    printf("--store-name <name> <value>\n");
+    for (std::string showResult : showResults) {
+        if (showResult == "radio-reset") {
+            printf("          %s { 0 }\n", showResult.c_str());
+        } else if (showResult == "reset-monitor") {
+            printf("          %s { pid short-signal long-signal "
+                   "[extra-long-signal] }\n",
+                   showResult.c_str());
+        } else if (showResult == "reset-monitor-intervals") {
+            printf("          %s { short-interval long-interval }\n",
+                   showResult.c_str());
+        } else if (regex_match(showResult, serialModeFilter)) {
+            printf("          %s { loopback | rs232 | rs485-half | "
+                   "rs422-485-full }\n",
+                   showResult.c_str());
+        } else if (!regex_match(showResult, storeFilters)) {
+            printf("          %s BOOLEAN\n", showResult.c_str());
+        }
+    }
+    printf("\n");
+    exitHandler(0);
+}
+
+/* If the name starts in upper case, assume
+ * the name is a GPIO line name from gpio-hog
+ * in device tree.  If it starts in lower case
+ * assume the name is an attribute of the mts-io
+ * driver. GPIOs can only be zero
+ * or one, never a text string.
+ */
+void Device::show(std::string name) {
+    std::string fileData;
+    char chipname[64];
+    unsigned int offset;
+    int retval;
+
+    if(isupper(name[0])) {
+        retval = gpiod_ctxless_find_line(name.c_str(), chipname,
+                                    sizeof chipname,&offset);
+        if(retval != -1)
+            retval = gpiod_ctxless_get_value(chipname, offset,
+                                            false, CMDNAME);
+        if(retval != -1) {
+            if(retval == 0)
+                printf("0\n");
+            else
+                printf("1\n");
+            exitHandler(0);
+        }
+    }
+
+    int32_t code = MTS::System::readFile(SYSFS_PLATFORM + name, fileData);
+    if (code == 0) {
+        printf("%s", fileData.c_str());
+        exitHandler(0);
+    }
+    printError("cat: can't open %s%s: %s",
+        SYSFS_PLATFORM, name.c_str(),strerror(errno));
+    exitHandler(99);
+}
+
+void Device::showTrigger(std::string name) {
+    std::string fileData;
+    int32_t code =
+        MTS::System::readFile(LEDS_GPIO_DIR + name + "/trigger", fileData);
+    if (code == 0) {
+        printf("%s", fileData.c_str());
+        exitHandler(0);
+    }
+    printError("Can't open %s%s/trigger: %s",
+                   LEDS_GPIO_DIR, name.c_str(),strerror(errno));
+    exitHandler(99);
+}
+
+// Prefer gpiod if name starts with upper case and is value 0 or 1
+void Device::store(std::string name, std::string value) {
+    int intvalue = -1;
+    int prefergpiod = 0;
+    char chipname[64];
+    unsigned int offset;
+    int retval;
+
+    if (!isRoot) {
+        printError("Must be root to store to %s", name.c_str());
+        exitHandler(99);
+    }
+    printDebug("Setting %s to %s", name.c_str(), value.c_str());
+    if(isupper(name[0])) {
+        if (value.compare("0") == 0)
+            intvalue = 0;
+        if (value.compare("1") == 0)
+            intvalue = 1;
+        if ((intvalue != -1))
+            prefergpiod = 1;
+    }
+
+    if(prefergpiod) {
+        retval = gpiod_ctxless_find_line(name.c_str(), chipname,
+                                        sizeof chipname,&offset);
+        if(retval != -1)
+            retval = gpiod_ctxless_set_value(chipname, offset, intvalue,
+                                    false, CMDNAME, NULL, NULL);
+        if(retval != -1)
+            exitHandler(0);
+    }
+
+    std::ofstream fileToWrite(SYSFS_PLATFORM + name);
+    if (fileToWrite.is_open()) {
+        fileToWrite << value;
+        if (fileToWrite.bad()) {
+            printError("Can't write %s%s: %s", SYSFS_PLATFORM,
+                   name.c_str(),strerror(errno));
+            exitHandler(98);
+        }
+        fileToWrite.close();
+        exitHandler(0);
+    }
+    printError("Can't open %s%s: %s", SYSFS_PLATFORM,
+                   name.c_str(),strerror(errno));
+    exitHandler(99);
+}
+
+void Device::storeTrigger(std::string name, std::string value) {
+    if (!isRoot) {
+        printError("Must be root to storeTrigger to %s/trigger", name.c_str());
+        exitHandler(99);
+    }
+    printDebug("Setting %s to %s", name.c_str(), value.c_str());
+    std::ofstream fileToWrite(LEDS_GPIO_DIR + name + "/trigger");
+    if (fileToWrite.is_open()) {
+        fileToWrite << value;
+        if(fileToWrite.bad()) {
+            printError("Can't write %s%s/trigger: %s",
+                   LEDS_GPIO_DIR, name.c_str(), strerror(errno));
+            exitHandler(98);
+        }
+        fileToWrite.close();
+        exitHandler(0);
+    }
+    printError("Can't open %s%s/trigger: %s",
+                   LEDS_GPIO_DIR, name.c_str(), strerror(errno));
+    exitHandler(99);
+}
+
+void Device::writeJson() {
+    rapidjson::StringBuffer buffer;
+    rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
+    deviceInfo.Accept(writer);
+    std::ofstream os(DEVICE_INFO_FILE);
+    if (!os) {
+        printError("Can't write to %s: %s", DEVICE_INFO_FILE,strerror(errno));
+        exitHandler(99);
+    } else {
+        os << buffer.GetString();
+    }
+}