rfsv.h

Go to the documentation of this file.

/*
 * This file is part of plptools.
 *
 *  Copyright (C) 1999 Philip Proudman <philip.proudman@btinternet.com>
 *  Copyright (C) 1999-2002 Fritz Elfert <felfert@to.com>
 *  Copyright (c) 2026 Jason Morley <hello@jbmorley.co.uk>
 *
 *  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 <deque>
#include <memory>
#include <string>
#include <vector>
 
#include "Enum.h"
#include "connectionerror.h"
#include "plpdirent.h"
#include "bufferstore.h"
 
typedef std::deque<class PlpDirent> PlpDir;
 
class TCPSocket;
class Drive;
 
inline const int RFSV_SENDLEN = 2000;
 
typedef int (*cpCallback_t)(void *, uint32_t);
 
class RFSV16;
class RFSV32;
 
class RFSVDirHandle {
    friend class RFSV16;
    friend class RFSV32;
 
private:
    uint32_t h;
    BufferStore b;
    std::string name_;
};
 
class RFSV {
public:
    enum seek_mode {
        PSI_SEEK_SET = 1,
        PSI_SEEK_CUR = 2,
        PSI_SEEK_END = 3
    };
 
    enum open_flags {
        PSI_O_RDONLY = 0000,
        PSI_O_WRONLY = 0001,
        PSI_O_RDWR   = 0002
    };
 
    enum open_mode {
        PSI_O_CREAT  = 00100,
        PSI_O_EXCL   = 00200,
        PSI_O_TRUNC  = 01000,
        PSI_O_APPEND = 02000,
        PSI_O_SHARE  = 04000
    };
 
    enum errs {
        E_PSI_GEN_NONE = 0,
        E_PSI_GEN_FAIL = -1,
        E_PSI_GEN_ARG = -2,
        E_PSI_GEN_OS = -3,
        E_PSI_GEN_NSUP = -4,
        E_PSI_GEN_UNDER = -5,
        E_PSI_GEN_OVER = -6,
        E_PSI_GEN_RANGE = -7,
        E_PSI_GEN_DIVIDE = -8,
        E_PSI_GEN_INUSE = -9,
        E_PSI_GEN_NOMEMORY = - 10,
        E_PSI_GEN_NOSEGMENTS = -11,
        E_PSI_GEN_NOSEM = -12,
        E_PSI_GEN_NOPROC = -13,
        E_PSI_GEN_OPEN = -14,
        E_PSI_GEN_NOTOPEN = -15,
        E_PSI_GEN_IMAGE = -16,
        E_PSI_GEN_RECEIVER = -17,
        E_PSI_GEN_DEVICE = -18,
        E_PSI_GEN_FSYS = -19,
        E_PSI_GEN_START = -20,
        E_PSI_GEN_NOFONT = -21,
        E_PSI_GEN_TOOWIDE = -22,
        E_PSI_GEN_TOOMANY = -23,
        E_PSI_FILE_EXIST = -32,
        E_PSI_FILE_NXIST = -33,
        E_PSI_FILE_WRITE = -34,
        E_PSI_FILE_READ = -35,
        E_PSI_FILE_EOF = -36,
        E_PSI_FILE_FULL = -37,
        E_PSI_FILE_NAME = -38,
        E_PSI_FILE_ACCESS = -39,
        E_PSI_FILE_LOCKED = -40,
        E_PSI_FILE_DEVICE = -41,
        E_PSI_FILE_DIR = -42,
        E_PSI_FILE_RECORD = -43,
        E_PSI_FILE_RDONLY = -44,
        E_PSI_FILE_INV = -45,
        E_PSI_FILE_PENDING = -46,
        E_PSI_FILE_VOLUME = -47,
        E_PSI_FILE_CANCEL = -48,
        E_PSI_FILE_ALLOC = -49,
        E_PSI_FILE_DISC = -50,
        E_PSI_FILE_CONNECT = -51,
        E_PSI_FILE_RETRAN = -52,
        E_PSI_FILE_LINE = -53,
        E_PSI_FILE_INACT = -54,
        E_PSI_FILE_PARITY = -55,
        E_PSI_FILE_FRAME = -56,
        E_PSI_FILE_OVERRUN = -57,
        E_PSI_MDM_CONFAIL = -58,
        E_PSI_MDM_BUSY = -59,
        E_PSI_MDM_NOANS = -60,
        E_PSI_MDM_BLACKLIST = -61,
        E_PSI_FILE_NOTREADY = -62,
        E_PSI_FILE_UNKNOWN = -63,
        E_PSI_FILE_DIRFULL = -64,
        E_PSI_FILE_PROTECT = -65,
        E_PSI_FILE_CORRUPT = -66,
        E_PSI_FILE_ABORT = -67,
        E_PSI_FILE_ERASE = -68,
        E_PSI_FILE_INVALID = -69,
        E_PSI_GEN_POWER = -100,
        E_PSI_FILE_TOOBIG = -101,
        E_PSI_GEN_DESCR = -102,
        E_PSI_GEN_LIB = -103,
        E_PSI_FILE_NDISC = -104,
        E_PSI_FILE_DRIVER = -105,
        E_PSI_FILE_COMPLETION = -106,
        E_PSI_GEN_BUSY = -107,
        E_PSI_GEN_TERMINATED = -108,
        E_PSI_GEN_DIED = -109,
        E_PSI_FILE_HANDLE = -110,
 
        // Special error code for "Operation not permitted in RFSV16"
        E_PSI_NOT_SIBO = -200,
        // Special error code for "internal library error"
        E_PSI_INTERNAL = -201
    };
 
    enum file_attribs {
        PSI_A_RDONLY     = 0x0001,
        PSI_A_HIDDEN     = 0x0002,
        PSI_A_SYSTEM     = 0x0004,
        PSI_A_DIR        = 0x0008,
        PSI_A_ARCHIVE    = 0x0010,
        PSI_A_VOLUME     = 0x0020,
 
        PSI_A_NORMAL     = 0x0040,
        PSI_A_TEMP       = 0x0080,
        PSI_A_COMPRESSED = 0x0100,
 
        PSI_A_READ       = 0x0200,
        PSI_A_EXEC       = 0x0400,
        PSI_A_STREAM     = 0x0800,
        PSI_A_TEXT       = 0x1000
    };
 
    static RFSV *connect(const std::string &host, int port, Enum<ConnectionError> *error);
 
    virtual ~RFSV();
    void reset();
    void reconnect();
 
    Enum<errs> getStatus();
 
    virtual Enum<errs> fopen(const uint32_t attr, const char * const name, uint32_t &handle) = 0;
 
    virtual Enum<errs> mktemp(uint32_t &handle, std::string &name) = 0;
 
    virtual Enum<errs> fcreatefile(const uint32_t attr, const char * const name, uint32_t &handle) = 0;
 
    virtual Enum<errs> freplacefile(const uint32_t attr, const char * const name, uint32_t &handle) = 0;
 
    virtual Enum<errs> fclose(const uint32_t handle) = 0;
 
    virtual Enum<errs> dir(const char * const name, PlpDir &ret) = 0;
 
    Enum<errs> dir(const std::string &path,
                   bool recursive,
                   std::vector<PlpDirent> &files);
 
    virtual Enum<errs> fgetmtime(const char * const name, PsiTime &mtime) = 0;
 
    virtual Enum<errs> fsetmtime(const char * const name, const PsiTime mtime) = 0;
 
    virtual Enum<errs> fgetattr(const char * const name, uint32_t &attr) = 0;
 
    virtual Enum<errs> pathtest(const char * const name) = 0;
 
    virtual Enum<errs> fgeteattr(const char * const name, PlpDirent &e) =0;
 
    virtual Enum<errs> fsetattr(const char * const name, const uint32_t seta, const uint32_t unseta) = 0;
 
    virtual Enum<errs> dircount(const char * const name, uint32_t &count) = 0;
 
    virtual Enum<errs> devlist(uint32_t &devbits) = 0;
 
    virtual Enum<errs> devinfo(const char drive, Drive &dinfo) = 0;
 
    Enum<errs> drives(std::vector<Drive> &drives);
 
    virtual Enum<errs> fread(const uint32_t handle, unsigned char * const buffer, const uint32_t len, uint32_t &count) = 0;
 
    virtual Enum<errs> fwrite(const uint32_t handle, const unsigned char * const buffer, const uint32_t len, uint32_t &count) = 0;
 
    virtual Enum<errs> copyFromPsion(const char *from, const char *to, void *context, cpCallback_t func) = 0;
 
    virtual Enum<RFSV::errs> copyFromPsion(const char *from, int fd, cpCallback_t cb) = 0;
 
    virtual Enum<errs> copyToPsion(const char * const from, const char * const to, void *, cpCallback_t func) = 0;
 
    virtual Enum<errs> copyOnPsion(const char * const from, const char * const to, void *, cpCallback_t func) = 0;
 
    virtual Enum<errs> fsetsize(const uint32_t handle, const uint32_t size) = 0;
 
    virtual Enum<errs> fseek(const uint32_t handle, const int32_t offset, const uint32_t mode, uint32_t &resultpos) = 0;
 
    virtual Enum<errs> mkdir(const char * const name) = 0;
 
    virtual Enum<errs> rmdir(const char * const name) = 0;
 
    virtual Enum<errs> rename(const char * const oldname, const char * const newname) = 0;
 
    virtual Enum<errs> remove(const char * const name) = 0;
 
    virtual Enum<errs> opendir(const uint32_t attr, const char * const name, RFSVDirHandle &handle) = 0;
 
    virtual Enum<errs> readdir(RFSVDirHandle &handle, PlpDirent &entry) = 0;
 
    virtual Enum<errs> closedir(RFSVDirHandle &handle) = 0;
 
    virtual Enum<errs> setVolumeName(const char drive, const char * const name) = 0;
 
    std::string attr2String(const uint32_t attr);
 
    virtual uint32_t opMode(const uint32_t mode) = 0;
 
    static std::string convertSlash(const std::string &name);
 
    int getSpeed();
 
    virtual int getProtocolVersion() = 0;
 
    virtual char defaultInternalDriveLetter() = 0;
 
protected:
    const char *getConnectName();
 
    std::unique_ptr<TCPSocket> socket_;
    Enum<errs> status_;
    int32_t operationId_;
};