FirmwareUpdateUtility.cc

Go to the documentation of this file.

 
#include <signal.h>
#include <limits.h>
#include <iostream>
#include <stdio.h>
#include <chrono>
#include <thread>
#include <atomic>
 
#include <getopt/getopt.h>
 
#include "Messages.hh"
#include "Updater.hh"
#include "Util.hh"
 
static void usage() {
    std::cout << "Usage\n";
    std::cout << "\n";
    std::cout << "FirmwareUpdateUtility\n";
    std::cout << "\n";
    std::cout << "FirmwareUpdateUtility <options>\n";
    std::cout << "-a [address]  Ip Address of camera (Default 10.66.171.21)\n";
    std::cout << "-f [filepath] Path of firmware update (Default update.img)\n";
    std::cout << "-v            Print verbose file upload status (default false)\n";
    std::cout << "-h            Print this menu and exit.\n\n";
}
 
static void signal_handler(int signal);
std::atomic<int> ExitReceived(0);
 
#ifndef PATH_MAX
#define PATH_MAX MAX_PATH
#endif
 
 
int main(int argc, char *argv[]) {
 
    bool verbose_progress = false;
    std::string ipAddress = "10.66.171.21";
    std::string filePath;
    bool UpdateComplete = false;
    int  ret = 0;
    int  opt;
 
    while ((opt = getopt(argc, argv, "a:f:vh")) != -1) {
        switch (opt) {
        case 'a':
            ipAddress = std::string(optarg);
            break;
        case 'f':
            filePath = std::string(optarg);
            break;
        case 'v':
            verbose_progress = true;
            break;
        case 'h':
        default: /* '?' */
            usage();
            exit(1);
        }
    }
 
    signal(SIGINT, signal_handler);
 
    if (ipAddress.empty()) {
        std::cerr << "Missing IP address\n";
        exit(-1);
    }
 
    if (filePath.empty())
    {
        std::cerr << "Please specify a file path\n";
        exit(-1);
    }
 
    if (!Util::FileExists(filePath.c_str())) {
        std::cerr << "Error: File " << filePath << " Does not exist\n";
        usage();
        return -1;
    }
 
    Ip i;
    if (i.Setup(ipAddress.c_str()) < 0) {
        std::cerr << "Error Failed to setup Network\n";
        return -1;
    }
 
    if (i.Bind() < 0) {
        std::cerr << "Error Failed to bind to camera server\n";
        return -1;
    }
 
    Updater u(&i);
 
    if (u.SendFile(filePath, verbose_progress) < 0) {
        std::cerr << "Error failed to send the file " << filePath << " to the camera!\n";
        return -1;
    }
 
    while (!UpdateComplete || !ExitReceived)
    {
        Messages::MessageUpdateStatus UpdateStatus;
        long int MsgLen = 0;
 
        ret = u.Receive((uint8_t *)&UpdateStatus, sizeof(UpdateStatus), &MsgLen);
        if (ret < 0)
        {
            if (ret == -CRL_EAGAIN)
            {
                usleep(100);
                continue;
            }
            std::cerr << "Error: Failed to get message from camera\n";
            return -1;
        }
        else if (ret == 0)
        {
            std::cerr << "Error: Connection closed by camera\n";
            return -1;
        }
 
        if (UpdateStatus.State & Messages::Status_Error)
        {
            std::cerr << "Error: Received an error from Camera\n";
        }
        else
        {
            Messages::PrintStatus(UpdateStatus.State);
            if (UpdateStatus.State & Messages::Status_UpdateComplete)
            {
                std::cout << "Notice: Update is complete, camera will power cycle!\n";
                UpdateStatus.Id = Messages::UpdateStatusId_ACK;
                UpdateStatus.Status = Messages::UpdateStatus_Done;
                ret = u.Send((uint8_t*)&UpdateStatus, sizeof(UpdateStatus));
                break;
            }
            else
            {
                UpdateStatus.Id = Messages::UpdateStatusId_ACK;
                UpdateStatus.Status = Messages::UpdateStatus_Ok;
                ret = u.Send((uint8_t *)&UpdateStatus, sizeof(UpdateStatus));
                if (ret < 0)
                {
                    std::cerr << "Error Failed to send ack to camera\n";
                }
 
            }
 
        }
    }
 
    return ret;
}
 
static void signal_handler(int signal)
{
    (void) signal;
    std::cout << "Exit Signal Received Cancelling Update\n";
    ExitReceived = 1;
}