File indexing completed on 2024-05-05 04:59:31

 /*
     fish.h  -  a FISH KIO worker
     SPDX-FileCopyrightText: 2001 Jörg Walter <trouble@garni.ch>
     SPDX-License-Identifier: GPL-2.0-only
 */
 
 #ifndef FISH_H
 #define FISH_H
 
 #include <KIO/AuthInfo>
 #include <KIO/Global>
 #include <KIO/WorkerBase>
 
 #define FISH_EXEC_CMD 'X'
 
 using Result = KIO::WorkerResult;
 
 struct ReceivedResult {
     KIO::fileoffset_t remainingBufferSize;
     KIO::WorkerResult result;
 };
 
 struct ConnectedResult {
     qsizetype remainingBufferSize;
     KIO::WorkerResult result;
 };
 
 class fishProtocol : public KIO::WorkerBase
 {
 public:
     fishProtocol(const QByteArray &pool_socket, const QByteArray &app_socket);
     ~fishProtocol() override;
 
     /**
     Connects to a server and logs us in via SSH. Then starts FISH protocol.
     @ref isConnected is set to true if logging on was successful.
     It is set to false if the connection becomes closed.
 
     */
     KIO::WorkerResult openConnection() override;
 
     /** sets connection information for subsequent commands */
     void setHost(const QString &host, quint16 port, const QString &user, const QString &pass) override;
     /** Forced close of the connection */
     void closeConnection() override;
     /** get a file */
     KIO::WorkerResult get(const QUrl &url) override;
     /** put a file */
     KIO::WorkerResult put(const QUrl &url, int permissions, KIO::JobFlags flags) override;
     /** stat a file */
     KIO::WorkerResult stat(const QUrl &url) override;
     /** find mimetype for a file */
     KIO::WorkerResult mimetype(const QUrl &url) override;
     /** list a directory */
     KIO::WorkerResult listDir(const QUrl &url) override;
     /** create a directory */
     KIO::WorkerResult mkdir(const QUrl &url, int permissions) override;
     /** rename a file */
     KIO::WorkerResult rename(const QUrl &src, const QUrl &dest, KIO::JobFlags flags) override;
     /** create a symlink */
     KIO::WorkerResult symlink(const QString &target, const QUrl &dest, KIO::JobFlags flags) override;
     /** change file permissions */
     KIO::WorkerResult chmod(const QUrl &url, int permissions) override;
     /** copies a file */
     KIO::WorkerResult copy(const QUrl &src, const QUrl &dest, int permissions, KIO::JobFlags flags) override;
     /** report status */
     void worker_status() override;
     /** removes a file or directory */
     KIO::WorkerResult del(const QUrl &u, bool isfile) override;
     /** special like background execute */
     KIO::WorkerResult special(const QByteArray &data) override;
 
 private: // Private methods
     /** Clean up connection */
     void shutdownConnection(bool forced = false);
     /** aborts command sequence and calls error() */
     Q_REQUIRED_RESULT KIO::WorkerResult error(int type, const QString &detail);
     /** executes next command in sequence or calls finished() if all is done */
     void finished();
 
 private: // Private attributes
     /** fd for reading and writing to the process */
     int childFd;
     /** buffer for data to be written */
     QByteArray outBuf;
     /** current write position in buffer */
     KIO::fileoffset_t outBufPos;
     /** use su if true else use ssh */
     bool local;
     /**  // FIXME: just a workaround for konq deficiencies */
     bool isStat;
     /**  // FIXME: just a workaround for konq deficiencies */
     QString redirectUser, redirectPass;
 
 protected: // Protected attributes
     /** for LIST/STAT */
     KIO::UDSEntry udsEntry;
     /** for LIST/STAT */
     KIO::UDSEntry udsStatEntry;
     /** for LIST/STAT */
     long long udsType;
     /** for LIST/STAT */
     QString udsMime;
     /** for LIST/STAT */
     QString thisFn;
     /** for STAT */
     QString wantedFn;
     QString statPath;
     /** url of current request */
     QUrl url;
     /** true if connection is logged in successfully */
     bool isLoggedIn;
     /** host name of current connection */
     QString connectionHost;
     /** user name of current connection */
     QString connectionUser;
     /** port of current connection */
     int connectionPort;
     /** password of current connection */
     QString connectionPassword;
     /** AuthInfo object used for logging in */
     KIO::AuthInfo connectionAuth;
     /** number of lines received, == 0 -> everything went ok */
     int errorCount;
     /** queue for lines to be sent */
     QList<QByteArray> qlist;
     /** queue for commands to be sent */
     QStringList commandList;
     /** queue for commands to be sent */
     QList<int> commandCodes;
     /** bytes still to be read in raw mode */
     KIO::fileoffset_t rawRead;
     /** bytes still to be written in raw mode */
     KIO::fileoffset_t rawWrite;
     /** data bytes to read in next read command */
     KIO::fileoffset_t recvLen;
     /** data bytes to write in next write command */
     KIO::fileoffset_t sendLen;
     /** true if the last write operation was finished */
     bool writeReady;
     /** true if a command stack is currently executing */
     bool isRunning;
     /** reason of LIST command */
     enum { CHECK, LIST } listReason;
     /** true if FISH server understands APPEND command */
     bool hasAppend;
     /** permission of created file */
     int putPerm;
     /** true if file may be overwritten */
     bool checkOverwrite;
     /** current position of write */
     KIO::fileoffset_t putPos;
     /** true if file already existed */
     bool checkExist;
     /** true if this is the first login attempt (== use cached password) */
     bool firstLogin;
     /** write buffer */
     QByteArray rawData;
     /** buffer for storing bytes used for MimeMagic */
     QByteArray mimeBuffer;
     /** whther the mimetype has been sent already */
     bool mimeTypeSent;
     /** number of bytes read so far */
     KIO::fileoffset_t dataRead;
     /** details about each fishCommand */
     static const struct fish_info {
         const char *command;
         int params;
         const char *alt;
         int lines;
     } fishInfo[];
     /** last FISH command sent to server */
     enum fish_command_type {
         FISH_FISH,
         FISH_VER,
         FISH_PWD,
         FISH_LIST,
         FISH_STAT,
         FISH_RETR,
         FISH_STOR,
         FISH_CWD,
         FISH_CHMOD,
         FISH_DELE,
         FISH_MKD,
         FISH_RMD,
         FISH_RENAME,
         FISH_LINK,
         FISH_SYMLINK,
         FISH_CHOWN,
         FISH_CHGRP,
         FISH_READ,
         FISH_WRITE,
         FISH_COPY,
         FISH_APPEND,
         FISH_EXEC
     } fishCommand;
     int fishCodeLen;
 
 protected: // Protected methods
     /** manages initial communication setup including password queries */
 #ifndef Q_OS_WIN
     ConnectedResult establishConnection(char *buffer, KIO::fileoffset_t buflen);
 #else
     ConnectedResult establishConnection(const QByteArray &buffer);
 #endif
     ReceivedResult received(const char *buffer, KIO::fileoffset_t buflen);
     void sent();
     /** builds each FISH request and sets the error counter */
     bool sendCommand(fish_command_type cmd, ...);
     /** checks response string for result code, converting 000 and 001 appropriately */
     int handleResponse(const QString &str);
     /** parses a ls -l time spec */
     int makeTimeFromLs(const QString &dayStr, const QString &monthStr, const QString &timeyearStr);
     /** executes a chain of commands */
     KIO::WorkerResult run();
     /** creates the subprocess */
     KIO::WorkerResult connectionStart();
     /** writes one chunk of data to stdin of child process */
 #ifndef Q_OS_WIN
     void writeChild(const char *buf, KIO::fileoffset_t len);
 #else
     void writeChild(const QByteArray &buf, KIO::fileoffset_t len);
 #endif
     /** parses response from server and acts accordingly */
     KIO::WorkerResult manageConnection(const QString &line);
     /** writes to process */
     void writeStdin(const QString &line);
     /** Verify port **/
     void setHostInternal(const QUrl &u);
 };
 
 #endif