VxworksTerminal.h

#ifndef ROSE_BinaryAnalysis_VxworksTerminal_H
#define ROSE_BinaryAnalysis_VxworksTerminal_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/AddressInterval.h>
#include <Rose/BinaryAnalysis/MemoryMap.h>
#include <Rose/Diagnostics.h>
 
#include <Sawyer/PartialResult.h>
#include <Sawyer/Result.h>
 
#include <string>
 
namespace Rose {
namespace BinaryAnalysis {
 
class VxworksTerminal {
public:
    using Ptr = VxworksTerminalPtr;
 
    class Settings {
    public:
        AddressInterval where;                                
        unsigned permissions = MemoryMap::READ_WRITE_EXECUTE; 
        std::string prompt = "/[_a-zA-Z0-9]+->|-> /";         
        double delaySeconds = 0.01;                           
        double timeoutSeconds = 2.0;                          
        size_t bytesPerRequest = 1024;                        
        std::string host = "localhost";                       
        uint16_t port = 23;                                   
    public:
        void print(std::ostream&) const;
    };
    class Settings {…};
 
    class DataTransfer {
    public:
        enum class State {
            NORMAL,                                     
            DRAIN,                                      
            TERMINATE                                   
        };
        enum class State {…};
 
    public:
        State state = State::NORMAL;                    
    public:
        virtual ~DataTransfer() = default;
 
        virtual std::string handleInput(const std::string &line) = 0;
 
        virtual std::string handlePrompt(const std::string &prompt) = 0;
    };
    class DataTransfer {…};
 
private:
    Settings settings_;
    int server_ = -1;                                   // filedescriptor connected to the server if open, else -1
 
public:
    static Diagnostics::Facility mlog;
 
public:
    ~VxworksTerminal();
protected:
    VxworksTerminal();
    explicit VxworksTerminal(const Settings&);
    VxworksTerminal(const VxworksTerminal&) = delete;
    VxworksTerminal& operator=(const VxworksTerminal&) = delete;
 
public:
    static Ptr instance();
    static Ptr instance(const Settings&);
public:
    static void initDiagnostics();
 
    const Settings& settings() const;
    Settings& settings();
    static std::string locatorStringDocumentation(const Settings&);
 
    static Sawyer::Result<Settings, MemoryMap::LocatorError> parseLocatorString(const std::string&, const Settings &dflt);
 
    Sawyer::Optional<std::string> open();
 
    bool isOpen() const;
 
    Sawyer::PartialResult<std::vector<uint8_t>, std::string> download();
    Sawyer::PartialResult<std::vector<uint8_t>, std::string> download(const AddressInterval&);
    Sawyer::PartialResult<AddressInterval, std::string> download(const MemoryMapPtr &destination, const std::string &name);
    Sawyer::PartialResult<AddressInterval, std::string> download(const MemoryMapPtr &destination, const AddressInterval&,
                                                                 const std::string &name);
private:
 
    bool matchPrompt(const std::string&);
    Sawyer::Result<bool, std::string> transferData(DataTransfer&);
};
class VxworksTerminal {…};
 
std::ostream& operator<<(std::ostream&, const VxworksTerminal::Settings&);
 
} // namespace
} // namespace
 
#endif
#endif