rpcs.h

Go to the documentation of this file.

/*
 * This file is part of plptools.
 *
 *  Copyright (C) 1999-2002 Fritz Elfert <felfert@to.com>
 *
 *  This program 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.
 *
 *  This program 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
 *  along with this program; if not, see <https://www.gnu.org/licenses/>.
 *
 */
#pragma once
 
#include "connectionerror.h"
#include "psitime.h"
#include "psiprocess.h"
#include "rfsv.h"
#include "Enum.h"
 
#include <memory>
#include <vector>
 
class TCPSocket;
class BufferStore;
class BufferArray;
 
typedef std::vector<PsiProcess> processList;
 
class RPCS {
public:
    enum machs {
        PSI_MACH_UNKNOWN = 0,
        PSI_MACH_PC = 1,
        PSI_MACH_MC = 2,
        PSI_MACH_HC = 3,
        PSI_MACH_S3 = 4,
        PSI_MACH_S3A = 5,
        PSI_MACH_WORKABOUT = 6,
        PSI_MACH_SIENA = 7,
        PSI_MACH_S3C = 8,
        PSI_MACH_S5 = 32,
        PSI_MACH_WINC = 33
        // TODO: Code for 5mx
    };
 
    enum languages {
        PSI_LANG_TEST         = 0,
        PSI_LANG_en_GB        = 1,
        PSI_LANG_fr_FR        = 2,
        PSI_LANG_de_DE        = 3,
        PSI_LANG_es_ES        = 4,
        PSI_LANG_it_IT        = 5,
        PSI_LANG_sv_SE        = 6,
        PSI_LANG_da_DK        = 7,
        PSI_LANG_no_NO        = 8,
        PSI_LANG_fi_FI        = 9,
        PSI_LANG_en_US        = 10,
        PSI_LANG_fr_CH        = 11,
        PSI_LANG_de_CH        = 12,
        PSI_LANG_pt_PT        = 13,
        PSI_LANG_tr_TR        = 14,
        PSI_LANG_is_IS        = 15,
        PSI_LANG_ru_RU        = 16,
        PSI_LANG_hu_HU        = 17,
        PSI_LANG_nl_NL        = 18,
        PSI_LANG_nl_BE        = 19,
        PSI_LANG_en_AU        = 20,
        PSI_LANG_fr_BE        = 21,
        PSI_LANG_de_AT        = 22,
        PSI_LANG_en_NZ        = 23,
        PSI_LANG_fr_CA        = 24,
        PSI_LANG_cs_CZ        = 25,
        PSI_LANG_sk_SK        = 26,
        PSI_LANG_pl_PL        = 27,
        PSI_LANG_sl_SI        = 28
    };
 
    enum batterystates {
        PSI_BATT_DEAD = 0,
        PSI_BATT_VERYLOW = 1,
        PSI_BATT_LOW = 2,
        PSI_BATT_GOOD = 3
    };
 
    typedef struct machineInfo_t {
        Enum<machs> machineType;
        char machineName[17];
        unsigned long long machineUID;
        unsigned long countryCode;
        Enum<languages> uiLanguage;
 
        unsigned short romMajor;
        unsigned short romMinor;
        unsigned short romBuild;
        unsigned long romSize;
        bool romProgrammable;
 
        unsigned long ramSize;
        unsigned long ramFree;
        unsigned long ramMaxFree;
        unsigned long ramDiskSize;
 
        unsigned long registrySize;
        unsigned long displayWidth;
        unsigned long displayHeight;
 
        psi_timeval time;
        psi_timezone tz;
 
        psi_timeval mainBatteryInsertionTime;
        Enum<batterystates> mainBatteryStatus;
        psi_timeval mainBatteryUsedTime;
        unsigned long mainBatteryCurrent;
        unsigned long mainBatteryUsedPower;
        unsigned long mainBatteryVoltage;
        unsigned long mainBatteryMaxVoltage;
 
        Enum<batterystates> backupBatteryStatus;
        unsigned long backupBatteryVoltage;
        unsigned long backupBatteryMaxVoltage;
 
        psi_timeval externalPowerUsedTime;
        bool externalPower;
    } machineInfo;
 
    static RPCS *connect(const std::string &host, int port, Enum<ConnectionError> *error);
 
    virtual ~RPCS();
 
    void reset();
 
    void reconnect();
 
    Enum<RFSV::errs> getStatus();
 
    Enum<RFSV::errs> getNCPversion(int &major, int &minor);
 
    Enum<RFSV::errs> execProgram(const char *program, const char *args);
 
    Enum<RFSV::errs> stopProgram(const char *program);
 
    Enum<RFSV::errs> queryProgram(const char *);
 
    Enum<RFSV::errs> formatOpen(const char drive, int &handle, int &count);
 
    Enum<RFSV::errs> formatRead(int handle);
 
    Enum<RFSV::errs> getUniqueID(const char *, long &);
 
    virtual Enum<RFSV::errs> getOwnerInfo(BufferArray &owner) = 0;
 
    Enum<RFSV::errs> getMachineType(Enum<machs> &type);
 
    Enum<RFSV::errs> fuser(const char *name, char *buf, int maxlen);
 
    Enum<RFSV::errs> quitServer(void);
 
    Enum<RFSV::errs> queryPrograms(processList &ret);
 
    virtual Enum<RFSV::errs> getCmdLine(const char *process, std::string &ret) = 0;
 
    virtual Enum<RFSV::errs> getMachineInfo(machineInfo &machineInfo) {
        (void)machineInfo;
        return RFSV::E_PSI_NOT_SIBO;
    }
 
    virtual Enum<RFSV::errs> closeHandle(uint32_t handle) {
        (void)handle;
        return RFSV::E_PSI_NOT_SIBO;
    }
 
    virtual Enum<RFSV::errs> regOpenIter(uint32_t, char *, uint16_t &) {
        return RFSV::E_PSI_NOT_SIBO;
    }
 
    virtual Enum<RFSV::errs> regReadIter(uint16_t) {
        return RFSV::E_PSI_NOT_SIBO;
    }
 
    virtual Enum<RFSV::errs> regWrite(void) {
        return RFSV::E_PSI_NOT_SIBO;
    }
 
    virtual Enum<RFSV::errs> regRead(void) {
        return RFSV::E_PSI_NOT_SIBO;
    }
 
    virtual Enum<RFSV::errs> regDelete(void) {
        return RFSV::E_PSI_NOT_SIBO;
    }
 
    virtual Enum<RFSV::errs> setTime(time_t time) {
        (void)time;
        return RFSV::E_PSI_NOT_SIBO;
    }
 
    virtual Enum<RFSV::errs> configRead(uint32_t size, BufferStore &data) {
        (void)size;
        (void)data;
        return RFSV::E_PSI_NOT_SIBO;
    }
 
    virtual Enum<RFSV::errs> configWrite(BufferStore data) {
        (void)data;
        return RFSV::E_PSI_NOT_SIBO;
    }
 
    virtual Enum<RFSV::errs> queryOpen() {
        return RFSV::E_PSI_NOT_SIBO;
    }
 
    virtual Enum<RFSV::errs> queryRead() {
        return RFSV::E_PSI_NOT_SIBO;
    }
 
protected:
    std::unique_ptr<TCPSocket> socket_;
 
    Enum<RFSV::errs> status;
 
    enum commands {
        QUERY_NCP        = 0x00,
        EXEC_PROG        = 0x01,
        QUERY_DRIVE      = 0x02,
        STOP_PROG        = 0x03,
        QUERY_PROG       = 0x04,
        FORMAT_OPEN      = 0x05,
        FORMAT_READ      = 0x06,
        GET_UNIQUEID     = 0x07,
        GET_OWNERINFO    = 0x08,
        GET_MACHINETYPE  = 0x09,
        GET_CMDLINE      = 0x0a,
        FUSER            = 0x0b,
        GET_MACHINE_INFO = 0x64,
        CLOSE_HANDLE     = 0x65,
        REG_OPEN_ITER    = 0x66,
        REG_READ_ITER    = 0x67,
        REG_WRITE        = 0x68,
        REG_READ         = 0x69,
        REG_DELETE       = 0x6a,
        SET_TIME         = 0x6b,
        CONFIG_OPEN      = 0x6c,
        CONFIG_READ      = 0x6d,
        CONFIG_WRITE     = 0x6e,
        QUERY_OPEN       = 0x6f,
        QUERY_READ       = 0x70,
        QUIT_SERVER      = 0xff
    };
 
    int mtCacheS5mx;
 
    virtual Enum<RFSV::errs> configOpen(uint16_t &handle, uint32_t size) {
        (void)handle;
        (void)size;
        return RFSV::E_PSI_NOT_SIBO;
    }
 
    bool sendCommand(enum commands cc, BufferStore &data);
    Enum<RFSV::errs> getResponse(BufferStore &data, bool statusIsFirstByte);
    const char *getConnectName();
};