1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
/***************************************************************************
fish.h - a FISH kioslave
-------------------
begin : Thu Oct 4 17:09:14 CEST 2001
copyright : (C) 2001 by Jörg Walter
email : trouble@garni.ch
***************************************************************************/
/***************************************************************************
* *
* 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, version 2 of the License *
* *
***************************************************************************/
#ifndef __fish_h__
#define __fish_h__
#include <tqstring.h>
#include <tqcstring.h>
#include <kurl.h>
#include <kio/global.h>
#include <kio/slavebase.h>
#include <kprocess.h>
#include <kio/authinfo.h>
#include <time.h>
#define FISH_EXEC_CMD 'X'
class fishProtocol : public KIO::SlaveBase
{
public:
fishProtocol(const TQCString &pool_socket, const TQCString &app_socket);
virtual ~fishProtocol();
/**
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.
*/
void openConnection();
/**
Clean up connection
*/
void shutdownConnection(bool forced=false);
/** sets connection information for subsequent commands */
void setHost(const TQString & host, int port, const TQString & user, const TQString & pass);
/** Forced close of the connection */
void closeConnection();
/** get a file */
void get(const KURL& url);
/** put a file */
void put(const KURL& url, int permissions, bool overwrite, bool resume);
/** aborts command sequence and calls error() */
void error(int type, const TQString &detail);
/** executes next command in sequence or calls finished() if all is done */
void finished();
/** stat a file */
void stat(const KURL& url);
/** find mimetype for a file */
void mimetype(const KURL& url);
/** list a directory */
void listDir(const KURL& url);
/** create a directory */
void mkdir(const KURL&url, int permissions);
/** rename a file */
void rename(const KURL& src, const KURL& dest, bool overwrite);
/** create a symlink */
void symlink(const TQString& target, const KURL& dest, bool overwrite);
/** change file permissions */
void chmod(const KURL& url, int permissions);
/** copies a file */
void copy(const KURL &src, const KURL &dest, int permissions, bool overwrite);
/** report status */
void slave_status();
/** removes a file or directory */
void del(const KURL &u, bool isfile);
/** special like background execute */
void special( const TQByteArray &data );
private: // Private attributes
/** the SSH process used to communicate with the remote end */
pid_t childPid;
/** fd for reading and writing to the process */
int childFd;
/** buffer for data to be written */
const char *outBuf;
/** current write position in buffer */
KIO::fileoffset_t outBufPos;
/** length of buffer */
KIO::fileoffset_t outBufLen;
/** 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 */
TQString redirectUser, redirectPass;
protected: // Protected attributes
/** for LIST/STAT */
KIO::UDSEntry udsEntry;
/** for LIST/STAT */
KIO::UDSEntry udsStatEntry;
/** for LIST/STAT */
KIO::UDSAtom typeAtom;
/** for LIST/STAT */
KIO::UDSAtom mimeAtom;
/** for LIST/STAT */
TQString thisFn;
/** for STAT */
TQString wantedFn;
TQString statPath;
/** url of current request */
KURL url;
/** true if connection is logged in successfully */
bool isLoggedIn;
/** host name of current connection */
TQString connectionHost;
/** user name of current connection */
TQString connectionUser;
/** port of current connection */
int connectionPort;
/** password of current connection */
TQString 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 */
TQStringList qlist;
/** queue for commands to be sent */
TQStringList commandList;
/** queue for commands to be sent */
TQValueList<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 */
TQByteArray rawData;
/** buffer for storing bytes used for MimeMagic */
TQByteArray 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 */
int establishConnection(char *buffer, KIO::fileoffset_t buflen);
int 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 TQString &str);
/** parses a ls -l time spec */
int makeTimeFromLs(const TQString &dayStr, const TQString &monthStr, const TQString &timeyearStr);
/** executes a chain of commands */
void run();
/** creates the subprocess */
bool connectionStart();
/** writes one chunk of data to stdin of child process */
void writeChild(const char *buf, KIO::fileoffset_t len);
/** parses response from server and acts accordingly */
void manageConnection(const TQString &line);
/** writes to process */
void writeStdin(const TQString &line);
};
#endif
|
