rfsv16.cc

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 Matt J. Gumbley <matt@gumbley.demon.co.uk>
 *  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/>.
 *
 */
#include "config.h"
 
#include "rfsv16.h"
 
#include "bufferarray.h"
#include "bufferstore.h"
#include "drive.h"
#include "plpdirent.h"
#include "tcpsocket.h"
 
#include <algorithm>
#include <ios>
#include <iostream>
#include <fstream>
 
#include <stdlib.h>
#include <time.h>
 
#include "ignore-value.h"
 
#define RFSV16_MAXDATALEN 852 // 640
 
using namespace std;
 
RFSV16::RFSV16(std::unique_ptr<TCPSocket> socket) {
    operationId_ = 0;
    status_ = RFSV::E_PSI_FILE_DISC;
    socket_ = std::move(socket);
    reset();
}
 
Enum<RFSV::errs> RFSV16::fopen(uint32_t attr, const char *name, uint32_t &handle) {
    BufferStore a;
    string realName = convertSlash(name);
 
    // Allow random access, rather than forcing the caller to ask for it
    a.addWord((P_FRANDOM | attr) & 0xFFFF);
    a.addStringT(realName.c_str());
    if (!sendCommand(SIBO_FOPEN, a)) {
        return E_PSI_FILE_DISC;
    }
 
    Enum<RFSV::errs> res = getResponse(a);
    if (res == 0) {
        handle = static_cast<long>(a.getWord(0));
        return E_PSI_GEN_NONE;
    }
    return res;
}
 
Enum<RFSV::errs> RFSV16::mktemp(uint32_t &handle, string &tmpname) {
    BufferStore a;
 
    a.addWord(P_FUNIQUE);
    a.addStringT("TMP");
    if (!sendCommand(SIBO_OPENUNIQUE, a)) {
        return E_PSI_FILE_DISC;
    }
 
    Enum<RFSV::errs> res = getResponse(a);
    if (res == E_PSI_GEN_NONE) {
        handle = a.getWord(0);
        tmpname = a.getString(2);
        return res;
    }
    return res;
}
 
Enum<RFSV::errs> RFSV16::fcreatefile(uint32_t attr, const char *name, uint32_t &handle) {
    return fopen(attr | P_FCREATE, name, handle);
}
 
Enum<RFSV::errs> RFSV16::freplacefile(uint32_t attr, const char *name, uint32_t &handle) {
    return fopen(attr | P_FREPLACE, name, handle);
}
 
Enum<RFSV::errs> RFSV16::fopendir(const char * const name, uint32_t &handle) {
    return fopen(P_FDIR, name, handle);
}
 
Enum<RFSV::errs> RFSV16::fclose(uint32_t fileHandle) {
    BufferStore a;
    a.addWord(fileHandle & 0xFFFF);
    if (!sendCommand(SIBO_FCLOSE, a)) {
        return E_PSI_FILE_DISC;
    }
    return getResponse(a);
}
 
Enum<RFSV::errs> RFSV16::opendir(const uint32_t attr, const char *name, RFSVDirHandle &dH) {
    (void)attr;
    uint32_t handle;
    Enum<RFSV::errs> res = fopendir(name, handle);
    dH.h = handle;
    dH.b.init();
    dH.name_ = name;
    return res;
}
 
Enum<RFSV::errs> RFSV16::closedir(RFSVDirHandle &dH) {
    return fclose(dH.h);
}
 
Enum<RFSV::errs> RFSV16::readdir(RFSVDirHandle &dH, PlpDirent &e) {
    Enum<RFSV::errs> res = E_PSI_GEN_NONE;
 
    if (dH.b.getLen() < 17) {
        dH.b.init();
        dH.b.addWord(dH.h & 0xFFFF);
        if (!sendCommand(SIBO_FDIRREAD, dH.b)) {
            return E_PSI_FILE_DISC;
        }
        res = getResponse(dH.b);
        if (res == E_PSI_GEN_NONE) {
            uint16_t bufferLen = dH.b.getWord(0);
            dH.b.discardFirstBytes(2);
            if (dH.b.getLen() != bufferLen) {
                return E_PSI_GEN_FAIL;
            }
        }
    }
    if ((res == E_PSI_GEN_NONE) && (dH.b.getLen() > 16)) {
        uint16_t version = dH.b.getWord(0);
        if (version != 2) {
            return E_PSI_GEN_FAIL;
        }
        e.attr = attr2std(static_cast<uint32_t>(dH.b.getWord(2)));
        e.size = dH.b.getDWord(4);
        e.time.setSiboTime(dH.b.getDWord(8));
        e.dirname_ = dH.name_;
        e.name = dH.b.getString(16);
        e.attrstr = attr2String(e.attr);
 
        dH.b.discardFirstBytes(17 + e.name.length());
 
    }
    return res;
}
 
Enum<RFSV::errs> RFSV16::dir(const char *name, PlpDir &files) {
    RFSVDirHandle h;
    files.clear();
    Enum<RFSV::errs> res = opendir(PSI_A_HIDDEN|PSI_A_SYSTEM|PSI_A_DIR, name, h);
    while (res == E_PSI_GEN_NONE) {
        PlpDirent e;
        res = readdir(h, e);
        if (res == E_PSI_GEN_NONE) {
            files.push_back(e);
        }
    }
    closedir(h);
    if (res == E_PSI_FILE_EOF) {
        res = E_PSI_GEN_NONE;
    }
    return res;
}
 
uint32_t RFSV16::opMode(uint32_t mode) {
    uint32_t ret = 0;
 
    ret |= ((mode & 03) == PSI_O_RDONLY) ? 0 : P_FUPDATE;
    ret |= (mode & PSI_O_TRUNC) ? P_FREPLACE : 0;
    ret |= (mode & PSI_O_CREAT) ? P_FCREATE : 0;
    ret |= (mode & PSI_O_APPEND) ? P_FAPPEND : 0;
    if ((mode & 03) == PSI_O_RDONLY) {
        ret |= (mode & PSI_O_EXCL) ? 0 : P_FSHARE;
    }
    return ret;
}
 
Enum<RFSV::errs> RFSV16::fgetmtime(const char * const name, PsiTime &mtime) {
    BufferStore a;
    string realName = convertSlash(name);
    a.addStringT(realName.c_str());
    if (!sendCommand(SIBO_FINFO, a)) {
        return E_PSI_FILE_DISC;
    }
 
    Enum<RFSV::errs> res = getResponse(a);
    if (res != E_PSI_GEN_NONE) {
        return res;
    } else if (a.getLen() == 16) {
        // According to Alex's docs, Psion's file times are in
        // seconds since 13:00!!, 1.1.1970
        mtime.setSiboTime(a.getDWord(8));
        return res;
    }
    return E_PSI_GEN_FAIL;
}
 
Enum<RFSV::errs> RFSV16::fsetmtime(const char *name, PsiTime mtime) {
    // According to Alexander's protocol doc, SIBO_SFDATE sets the modification
    // time - and as far as I can see SIBO only keeps a modification
    // time. So call SIBO_SFDATE here.
    BufferStore a;
    string realName = convertSlash(name);
    // According to Alex's docs, Psion's file times are in
    // seconds since 13:00!!, 1.1.1970
    a.addDWord(mtime.getSiboTime());
    a.addStringT(realName.c_str());
    if (!sendCommand(SIBO_SFDATE, a)) {
        return E_PSI_FILE_DISC;
    }
    return getResponse(a);
}
 
Enum<RFSV::errs> RFSV16::fgetattr(const char * const name, uint32_t &attr) {
    BufferStore a;
    string realName = convertSlash(name);
    a.addStringT(realName.c_str());
    if (!sendCommand(SIBO_FINFO, a)) {
        return E_PSI_FILE_DISC;
    }
 
    Enum<RFSV::errs> res = getResponse(a);
    if (res != E_PSI_GEN_NONE) {
        return res;
    } else if (a.getLen() == 16) {
        attr = attr2std(static_cast<long>(a.getWord(2)));
        return res;
    }
    return E_PSI_GEN_FAIL;
}
 
Enum<RFSV::errs> RFSV16::fgeteattr(const char *const name, PlpDirent &e) {
    BufferStore a;
    string realName = convertSlash(name);
    a.addStringT(realName.c_str());
    if (!sendCommand(SIBO_FINFO, a))
        return E_PSI_FILE_DISC;
    Enum<RFSV::errs> res = getResponse(a);
    if (res != E_PSI_GEN_NONE)
        return res;
    else if (a.getLen() == 16) {
 
        // Get the filename.
        const char *p = strrchr(realName.c_str(), '\\');
        if (p) {
            p++;
        } else {
            p = realName.c_str();
        }
 
        // Uppercase the resulting filename as, while EPOC16 is case insensitive, it returns all responses as uppercase.
        string filename = p;
        std::transform(filename.begin(), filename.end(), filename.begin(), ::toupper);
 
        e.name = filename;
        e.attr = attr2std(static_cast<long>(a.getWord(2)));
        e.size = a.getDWord(4);
        e.time.setSiboTime(a.getDWord(8));
        e.UID  = PlpUID(0,0,0);
        e.attrstr = string(attr2String(e.attr));
        return res;
    }
    return E_PSI_GEN_FAIL;
}
 
Enum<RFSV::errs> RFSV16::fsetattr(const char *name, uint32_t seta, uint32_t unseta) {
    uint32_t statusword = std2attr(seta) & (~ std2attr(unseta));
    statusword ^= 0x0000001; // r bit is inverted
    uint32_t bitmask = std2attr(seta) | std2attr(unseta);
    BufferStore a;
    a.addWord(statusword & 0xFFFF);
    a.addWord(bitmask & 0xFFFF);
    a.addStringT(name);
    if (!sendCommand(SIBO_SFSTAT, a)) {
        return E_PSI_FILE_DISC;
    }
    return getResponse(a);
}
 
Enum<RFSV::errs> RFSV16::dircount(const char * const name, uint32_t &count) {
    RFSVDirHandle h;
    Enum<RFSV::errs> res = opendir(PSI_A_HIDDEN|PSI_A_SYSTEM|PSI_A_DIR, name, h);
    while (res == E_PSI_GEN_NONE) {
        PlpDirent e;
        res = readdir(h, e);
        if (res == E_PSI_GEN_NONE) {
            count++;
        }
    }
    closedir(h);
    if (res == E_PSI_FILE_EOF) {
        res = E_PSI_GEN_NONE;
    }
    return res;
}
 
Enum<RFSV::errs> RFSV16::devlist(uint32_t &devbits) {
    Enum<RFSV::errs> res;
    uint32_t fileHandle;
    devbits = 0;
 
    // The following is taken from a trace between a Series 3c and PsiWin.
    // Hope it works! We SIBO_PARSE to find the correct node, then FOPEN
    // (P_FDEVICE) this, SIBO_FDEVICEREAD each entry, setting the appropriate
    // drive-letter-bit in devbits, then FCLOSE.
 
    BufferStore a;
    a.init();
    a.addByte(0x00); // no Name 1
    a.addByte(0x00); // no Name 2
    a.addByte(0x00); // no Name 3
    if (!sendCommand(SIBO_PARSE, a)) {
        return E_PSI_FILE_DISC;
    }
    res = getResponse(a);
    if (res != E_PSI_GEN_NONE) {
        return res;
    }
 
    // Find the drive to FOPEN
    char name[4] = { 'x', ':', '\\', '\0' } ;
    a.discardFirstBytes(6); // Result, fsys, dev, path, file, file, ending, flag
    /* This leaves R E M : : M : \ */
    name[0] = static_cast<char>(a.getByte(5)); // the M
    res = fopen(P_FDEVICE, name, fileHandle);
    if (res != E_PSI_GEN_NONE) {
        return status_;
    }
 
    while (1) {
        a.init();
        a.addWord(fileHandle & 0xFFFF);
        if (!sendCommand(SIBO_FDEVICEREAD, a))
            return E_PSI_FILE_DISC;
        res = getResponse(a);
        if (res)
            break;
        uint16_t version = a.getWord(0);
        if ((version < 1) || (version > 2)) {
            cerr << "devlist: not version 1 or 2" << endl;
            fclose(fileHandle);
            return E_PSI_GEN_FAIL;
        }
        char drive = a.getByte(64);
        if (drive >= 'A' && drive <= 'Z') {
            int shift = (drive - 'A');
            devbits |= static_cast<long>(1 << shift);
        } else {
            cerr << "devlist: non-alphabetic drive letter ("
                 << drive << ")" << endl;
        }
    }
    if (res == E_PSI_FILE_EOF) {
        res = E_PSI_GEN_NONE;
    }
    fclose(fileHandle);
    return res;
}
 
static int sibo_dattr[] = {
    1, // Unknown
    2, // Floppy
    3, // Disk
    6, // Flash
    5, // RAM
    7, // ROM
    7, // write-protected == ROM ?
};
 
Enum<RFSV::errs> RFSV16::devinfo(const char drive, Drive &dinfo) {
    BufferStore a;
    Enum<RFSV::errs> res;
 
    // Again, this is taken from an exchange between PsiWin and a 3c.
    // For each drive, we SIBO_PARSE with its drive letter to get a response
    // (which we ignore), then do a SIBO_STATUSDEVICE to get the info.
 
    a.init();
    a.addByte(toupper(drive)); // Name 1
    a.addByte(':');
    a.addByte(0x00);
 
    a.addByte(0x00); // No name 2
    a.addByte(0x00); // No name 3
    if (!sendCommand(SIBO_PARSE, a)) {
        return E_PSI_FILE_DISC;
    }
    if ((res = getResponse(a)) != E_PSI_GEN_NONE) {
        return res;
    }
 
    a.init();
    a.addByte(toupper(drive)); // Name 1
    a.addByte(':');
    a.addByte('\\');
    a.addByte(0x00);
    if (!sendCommand(SIBO_STATUSDEVICE, a)) {
        return E_PSI_FILE_DISC;
    }
    if ((res = getResponse(a)) != E_PSI_GEN_NONE) {
        return res;
    }
 
    int attr = a.getWord(2);
    attr = sibo_dattr[a.getWord(2) & 0xff];
    dinfo.setMediaType(static_cast<MediaType>(attr));
 
    attr = a.getWord(2);
    int changeable = a.getWord(4) ? 32 : 0;
    int internal = (attr & 0x2000) ? 16 : 0;
 
    dinfo.setDriveAttributes(changeable | internal);
 
    int variable = (attr & 0x4000) ? 1 : 0;
    int dualdens = (attr & 0x1000) ? 2 : 0;
    int formattable = (attr & 0x0800) ? 4 : 0;
    int protect = ((attr & 0xff) == 6) ? 8 : 0;
 
    dinfo.setMediaAttributes(variable|dualdens|formattable|protect);
 
    dinfo.setUID(0);
    dinfo.setSize(a.getDWord(6), 0);
    dinfo.setSpace(a.getDWord(10), 0);
 
    dinfo.setName(toupper(drive), a.getString(14));
 
    return res;
}
 
bool RFSV16::sendCommand(enum commands cc, BufferStore & data) {
    if (status_ == E_PSI_FILE_DISC) {
        reconnect();
        if (status_ == E_PSI_FILE_DISC) {
            return false;
        }
    }
 
    bool result;
    BufferStore a;
    a.addWord(cc);
    a.addWord(data.getLen());
    a.addBuff(data);
    result = socket_->sendBufferStore(a);
    if (!result) {
        reconnect();
        result = socket_->sendBufferStore(a);
        if (!result) {
            status_ = E_PSI_FILE_DISC;
        }
    }
    return result;
}
 
 
Enum<RFSV::errs> RFSV16::getResponse(BufferStore & data) {
    // getWord(2) is the size field
    // which is the body of the response not counting the command (002a) and
    // the size word.
    if (socket_->getBufferStore(data) != 1) {
        cerr << "RFSV16::getResponse: duff response. "
            "getBufferStore failed." << endl;
    } else if (data.getWord(0) == 0x2a &&
               data.getWord(2) == data.getLen()-4) {
        Enum<RFSV::errs> ret = static_cast<enum errs>(static_cast<int16_t>(data.getWord(4)));
        data.discardFirstBytes(6);
        return ret;
    } else {
        cerr << "RFSV16::getResponse: duff response. Size field:" <<
            data.getWord(2) << " Frame size:" <<
            data.getLen()-4 << " Result field:" <<
            data.getWord(4) << endl;
    }
    status_ = E_PSI_FILE_DISC;
    return status_;
}
 
Enum<RFSV::errs> RFSV16::fread(const uint32_t handle, unsigned char * const buf, const uint32_t len, uint32_t &count) {
    Enum<RFSV::errs> res;
    unsigned char *p = buf;
    long l;
 
    count = 0;
    do {
        BufferStore a;
 
        // Read in blocks of 291 bytes; the maximum payload for
        // an RFSV frame. ( As seen in traces ) - this isn't optimal:
        // RFSV can handle fragmentation of frames, where only the
        // first SIBO_FREAD RESPONSE frame has a RESPONSE (00 2A), SIZE
        // and RESULT field. Every subsequent frame
        // just has data, 297 bytes (or less) of it.
        //
        a.addWord(handle);
        a.addWord((len - count) > RFSV16_MAXDATALEN
                  ? RFSV16_MAXDATALEN
                  : (len - count));
        if (!sendCommand(SIBO_FREAD, a)) {
            return E_PSI_FILE_DISC;
        }
        if ((res = getResponse(a)) != E_PSI_GEN_NONE) {
            if (res == E_PSI_FILE_EOF) {
                return E_PSI_GEN_NONE;
            }
            return res;
        }
        if ((l = a.getLen()) > 0) {
            memcpy(p, a.getString(), l);
            count += l;
            p += l;
        }
    } while ((count < len) && (l > 0));
    return res;
}
 
Enum<RFSV::errs> RFSV16::fwrite(const uint32_t handle,
                                const unsigned char *const buf,
                                const uint32_t len,
                                uint32_t &count) {
    Enum<RFSV::errs> res;
    const unsigned char *p = buf;
 
    count = 0;
    while (count < len) {
        BufferStore a;
        int nbytes;
 
        // Write in blocks of 291 bytes; the maximum payload for
        // an RFSV frame. ( As seen in traces ) - this isn't optimal:
        // RFSV can handle fragmentation of frames, where only the
        // first SIBO_FREAD RESPONSE frame has a RESPONSE (00 2A), SIZE
        // and RESULT field. Every subsequent frame
        // just has data, 297 bytes (or less) of it.
        nbytes = (len - count) > RFSV16_MAXDATALEN
            ? RFSV16_MAXDATALEN
            : (len - count);
        a.addWord(handle);
        a.addBytes(p, nbytes);
        if (!sendCommand(SIBO_FWRITE, a)) {
            return E_PSI_FILE_DISC;
        }
        if ((res = getResponse(a)) != E_PSI_GEN_NONE) {
            return res;
        }
 
        count += nbytes;
        p += nbytes;
    }
    return res;
}
 
Enum<RFSV::errs> RFSV16::copyFromPsion(const char *from, const char *to, void *ptr, cpCallback_t cb) {
    Enum<RFSV::errs> res;
    uint32_t handle;
    uint32_t len;
    uint32_t total = 0;
 
    if ((res = fopen(P_FSHARE | P_FSTREAM, from, handle)) != E_PSI_GEN_NONE)
        return res;
    ofstream op(to);
    if (!op) {
        fclose(handle);
        return E_PSI_GEN_FAIL;
    }
    do {
        unsigned char buf[RFSV_SENDLEN];
        if ((res = fread(handle, buf, sizeof(buf), len)) == E_PSI_GEN_NONE) {
            if (len > 0) {
                op.write(reinterpret_cast<char *>(buf), static_cast<std::streamsize>(len));
            }
            total += len;
            if (cb && !cb(ptr, total)) {
                res = E_PSI_FILE_CANCEL;
            }
        }
    } while (len > 0 && (res == E_PSI_GEN_NONE));
 
    fclose(handle);
    op.close();
    if (res == E_PSI_FILE_EOF) {
        res = E_PSI_GEN_NONE;
    }
    return res;
}
 
Enum<RFSV::errs> RFSV16::copyFromPsion(const char *from, int fd, cpCallback_t cb) {
    Enum<RFSV::errs> res;
    uint32_t handle;
    uint32_t len;
    uint32_t total = 0;
 
    if ((res = fopen(P_FSHARE | P_FSTREAM, from, handle)) != E_PSI_GEN_NONE) {
        return res;
    }
    do {
        unsigned char buf[RFSV_SENDLEN];
        if ((res = fread(handle, buf, sizeof(buf), len)) == E_PSI_GEN_NONE) {
            if (len > 0)
                // FIXME: return UNIX errors from this method.
                ignore_value(write(fd, buf, len));
            total += len;
            if (cb && !cb(NULL, total)) {
                res = E_PSI_FILE_CANCEL;
            }
        }
    } while (len > 0 && (res == E_PSI_GEN_NONE));
 
    fclose(handle);
    if (res == E_PSI_FILE_EOF) {
        res = E_PSI_GEN_NONE;
    }
    return res;
}
 
Enum<RFSV::errs> RFSV16::copyToPsion(const char *from, const char *to, void *ptr, cpCallback_t cb) {
    uint32_t handle;
    uint32_t len = 0;
    uint32_t total = 0;
    Enum<RFSV::errs> res;
 
    ifstream ip(from);
    if (!ip) {
        return E_PSI_FILE_NXIST;
    }
    res = fcreatefile(P_FSTREAM | P_FUPDATE, to, handle);
    if (res != E_PSI_GEN_NONE) {
        res = freplacefile(P_FSTREAM | P_FUPDATE, to, handle);
        if (res != E_PSI_GEN_NONE) {
            return res;
        }
    }
    unsigned char *buff = new unsigned char[RFSV_SENDLEN];
    while (res == E_PSI_GEN_NONE && ip && !ip.eof()) {
        ip.read(reinterpret_cast<char *>(buff), RFSV_SENDLEN);
        if ((res = fwrite(handle, buff, ip.gcount(), len)) == E_PSI_GEN_NONE) {
            total += len;
            if (cb && !cb(ptr, total)) {
                res = E_PSI_FILE_CANCEL;
            }
        }
    }
    delete[]buff;
    fclose(handle);
    ip.close();
    return res;
}
 
Enum<RFSV::errs> RFSV16::copyOnPsion(const char *from, const char *to, void *ptr, cpCallback_t cb) {
    uint32_t handle_from;
    uint32_t handle_to;
    uint32_t len;
    uint32_t wlen;
    uint32_t total = 0;
    Enum<RFSV::errs> res;
 
    if ((res = fopen(P_FSHARE | P_FSTREAM, from, handle_from)) != E_PSI_GEN_NONE) {
        return res;
    }
    res = fcreatefile(P_FSTREAM | P_FUPDATE, to, handle_to);
    if (res != E_PSI_GEN_NONE) {
        res = freplacefile(P_FSTREAM | P_FUPDATE, to, handle_to);
        if (res != E_PSI_GEN_NONE) {
            return res;
        }
    }
    do {
        unsigned char buf[RFSV_SENDLEN];
        if ((res = fread(handle_from, buf, sizeof(buf), len)) == E_PSI_GEN_NONE) {
            if (len > 0) {
                if ((res = fwrite(handle_to, buf, len, wlen)) == E_PSI_GEN_NONE) {
                    total += wlen;
                    if (cb && !cb(ptr, total)) {
                        res = E_PSI_FILE_CANCEL;
                    }
                }
            }
        }
    } while (len > 0 && wlen > 0 && (res == E_PSI_GEN_NONE));
    fclose(handle_from);
    fclose(handle_to);
    if (res == E_PSI_FILE_EOF) {
        res = E_PSI_GEN_NONE;
    }
    return res;
}
 
Enum<RFSV::errs> RFSV16::pathtest(const char * const path) {
    string realName = convertSlash(path);
    BufferStore a;
    a.addStringT(realName.c_str());
    sendCommand(SIBO_PATHTEST, a);
    return getResponse(a);
}
 
Enum<RFSV::errs> RFSV16::fsetsize(uint32_t handle, uint32_t size) {
    BufferStore a;
    a.addWord(handle & 0xffff);
    a.addDWord(size);
    if (!sendCommand(SIBO_FSETEOF, a)) {
        return E_PSI_FILE_DISC;
    }
    return getResponse(a);
}
 
/*
 * Unix-like implementation off fseek with one
 * exception: If seeking beyond eof, the gap
 * contains garbage instead of zeroes.
 */
Enum<RFSV::errs> RFSV16::fseek(const uint32_t handle, const int32_t pos, const uint32_t mode, uint32_t &resultpos) {
    BufferStore a;
    Enum<RFSV::errs> res;
    uint32_t savpos = 0;
    uint32_t realpos;
    uint32_t calcpos = 0;
 
/*
  seek-parameter for psion:
   dword position
   dword handle
   dword mode
   1 = from start
   2 = from current pos
   3 = from end
   ??no more?? 4 = sense recpos
   ??no more?? 5 = set recpos
   ??no more?? 6 = text-rewind
*/
 
    if ((mode < PSI_SEEK_SET) || (mode > PSI_SEEK_END)) {
        return E_PSI_GEN_ARG;
    }
 
    if ((mode == PSI_SEEK_CUR) && (pos >= 0)) {
        /* get and save current position */
        a.init();
        a.addWord(handle);
        a.addDWord(0);
        a.addWord(PSI_SEEK_CUR);
        if (!sendCommand(SIBO_FSEEK, a)) {
            return E_PSI_FILE_DISC;
        }
        if ((res = getResponse(a)) != E_PSI_GEN_NONE) {
            return res;
        }
        savpos = a.getDWord(0);
        if (pos == 0) {
            resultpos = savpos;
            return res;
        }
    }
    if ((mode == PSI_SEEK_END) && (pos >= 0)) {
        /* get and save end position */
        a.init();
        a.addWord(handle);
        a.addDWord(0);
        a.addWord(PSI_SEEK_END);
        if (!sendCommand(SIBO_FSEEK, a)) {
            return E_PSI_FILE_DISC;
        }
        if ((res = getResponse(a)) != E_PSI_GEN_NONE) {
            return res;
        }
        savpos = a.getDWord(0);
        if (pos == 0) {
            resultpos = savpos;
            return res;
        }
    }
    /* Now the real seek */
    a.addWord(handle);
    a.addDWord(pos);
    a.addWord(mode);
    if (!sendCommand(SIBO_FSEEK, a)) {
        return E_PSI_FILE_DISC;
    }
    if ((res = getResponse(a)) != 0) {
        return res;
    }
    realpos = a.getDWord(0);
    switch (mode) {
        case PSI_SEEK_SET:
            calcpos = pos;
            break;
        case PSI_SEEK_CUR:
            calcpos = savpos + pos;
            break;
        case PSI_SEEK_END:
            resultpos = realpos;
            return res;
            break;
    }
    if (calcpos > realpos) {
        /* Beyond end of file */
        res = fsetsize(handle, calcpos);
        if (res != E_PSI_GEN_NONE) {
            return res;
        }
        a.init();
        a.addWord(handle);
        a.addDWord(calcpos);
        a.addWord(PSI_SEEK_SET);
        if (!sendCommand(SIBO_FSEEK, a)) {
            return E_PSI_FILE_DISC;
        }
        if ((res = getResponse(a)) != 0) {
            return res;
        }
        realpos = a.getDWord(0);
    }
    resultpos = realpos;
    return res;
}
 
Enum<RFSV::errs> RFSV16::mkdir(const char* dirName) {
    string realName = convertSlash(dirName);
    BufferStore a;
    a.addStringT(realName.c_str());
    sendCommand(SIBO_MKDIR, a);
    return getResponse(a);
}
 
Enum<RFSV::errs> RFSV16::rmdir(const char *dirName) {
    // EPOC16 doesn't provide an RMDIR command, so we fake it using DELETE (and a few little tweaks).
 
    // Rudimentary argument checking.
    string path(dirName);
    if (path.empty()) {
        return E_PSI_FILE_NAME;
    }
 
    // The EPOC32 implementation of RMDIR allows for deletion of paths with or without a trailing forward slash.
    // However, EPOC16's DELETE (which we use here) doesn't like these, so we strip them to ensure parity between the
    // two implementations.
    if (path.back() == '\\') {
        path.pop_back();
    }
 
    // Get the path's attributes and ensure it's a directory.
    uint32_t attr;
    Enum<RFSV::errs> res = fgetattr(path.c_str(), attr);
    if (res != E_PSI_GEN_NONE) {
        return res;
    }
    if ((attr & PSI_A_DIR) == 0) {
        return E_PSI_FILE_DIR;
    }
 
    return remove(path.c_str());
}
 
Enum<RFSV::errs> RFSV16::rename(const char *oldName, const char *newName) {
    string realOldName = convertSlash(oldName);
    string realNewName = convertSlash(newName);
    BufferStore a;
    a.addStringT(realOldName.c_str());
    a.addStringT(realNewName.c_str());
    sendCommand(SIBO_RENAME, a);
    return getResponse(a);
}
 
Enum<RFSV::errs> RFSV16::remove(const char* psionName) {
    string realName = convertSlash(psionName);
    BufferStore a;
    a.addStringT(realName.c_str());
    // and this needs sending in the length word.
    sendCommand(SIBO_DELETE, a);
    return getResponse(a);
}
 
Enum<RFSV::errs> RFSV16::setVolumeName(const char drive , const char * const name) {
    (void)drive;
    (void)name;
    // Not yet ...
    return E_PSI_GEN_FAIL;
}
 
/*
 * Translate SIBO attributes to standard attributes.
 */
uint32_t RFSV16::attr2std(uint32_t attr) {
    uint32_t res = 0;
 
    // Common attributes
    if (!(attr & P_FAWRITE)) {
        res |= PSI_A_RDONLY;
    }
    if (attr & P_FAHIDDEN) {
        res |= PSI_A_HIDDEN;
    }
    if (attr & P_FASYSTEM) {
        res |= PSI_A_SYSTEM;
    }
    if (attr & P_FADIR) {
        res |= PSI_A_DIR;
    }
    if (attr & P_FAMOD) {
        res |= PSI_A_ARCHIVE;
    }
    if (attr & P_FAVOLUME) {
        res |= PSI_A_VOLUME;
    }
 
    // SIBO-specific
    if (attr & P_FAREAD) {
        res |= PSI_A_READ;
    }
    if (attr & P_FAEXEC) {
        res |= PSI_A_EXEC;
    }
    if (attr & P_FASTREAM) {
        res |= PSI_A_STREAM;
    }
    if (attr & P_FATEXT) {
        res |= PSI_A_TEXT;
    }
 
    // Do what we can for EPOC
    res |= PSI_A_NORMAL;
 
    return res;
}
 
/*
 * Translate standard attributes to SIBO attributes.
 */
uint32_t RFSV16::std2attr(const uint32_t attr) {
    uint32_t res = 0;
 
    // Common attributes
    if (!(attr & PSI_A_RDONLY)) {
        res |= P_FAWRITE;
    }
    if (attr & PSI_A_HIDDEN) {
        res |= P_FAHIDDEN;
    }
    if (attr & PSI_A_SYSTEM) {
        res |= P_FASYSTEM;
    }
    if (attr & PSI_A_DIR) {
        res |= P_FADIR;
    }
    if (attr & PSI_A_ARCHIVE) {
        res |= P_FAMOD;
    }
    if (attr & PSI_A_VOLUME) {
        res |= P_FAVOLUME;
    }
 
    // SIBO-specific
    if (attr & PSI_A_READ) {
        res |= P_FAREAD;
    }
    if (attr & PSI_A_EXEC) {
        res |= P_FAEXEC;
    }
    if (attr & PSI_A_STREAM) {
        res |= P_FASTREAM;
    }
    if (attr & PSI_A_TEXT) {
        res |= P_FATEXT;
    }
 
    return res;
}