• Skip to content
  • Skip to link menu
  • KDE API Reference
  • kdelibs-4.14.38 API Reference
  • KDE Home
  • Contact Us
 

KIO

  • kio
  • kio
slaveinterface.cpp
Go to the documentation of this file.
1/* This file is part of the KDE libraries
2 Copyright (C) 2000 David Faure <faure@kde.org>
3
4 This library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Library General Public
6 License version 2 as published by the Free Software Foundation.
7
8 This library is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 Library General Public License for more details.
12
13 You should have received a copy of the GNU Library General Public License
14 along with this library; see the file COPYING.LIB. If not, write to
15 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
16 Boston, MA 02110-1301, USA.
17*/
18
19#include "slaveinterface.h"
20#include "slaveinterface_p.h"
21#include "usernotificationhandler_p.h"
22
23#include "slavebase.h"
24#include "connection.h"
25#include "hostinfo_p.h"
26
27#include <errno.h>
28#include <stdlib.h>
29#include <sys/time.h>
30#include <unistd.h>
31#include <signal.h>
32#include <time.h>
33
34#include <kdebug.h>
35#include <klocale.h>
36
37#include <QtDBus/QtDBus>
38#include <QtCore/QPointer>
39#include <QtNetwork/QSslCertificate>
40#include <QtNetwork/QSslError>
41
42using namespace KIO;
43
44
45Q_GLOBAL_STATIC(UserNotificationHandler, globalUserNotificationHandler)
46
47
48SlaveInterface::SlaveInterface(SlaveInterfacePrivate &dd, QObject *parent)
49 : QObject(parent), d_ptr(&dd)
50{
51 connect(&d_ptr->speed_timer, SIGNAL(timeout()), SLOT(calcSpeed()));
52}
53
54SlaveInterface::~SlaveInterface()
55{
56 // Note: no kDebug() here (scheduler is deleted very late)
57
58 delete d_ptr;
59}
60
61void SlaveInterface::setConnection( Connection* connection )
62{
63 Q_D(SlaveInterface);
64 d->connection = connection;
65}
66
67Connection *SlaveInterface::connection() const
68{
69 const Q_D(SlaveInterface);
70 return d->connection;
71}
72
73static KIO::filesize_t readFilesize_t(QDataStream &stream)
74{
75 KIO::filesize_t result;
76 stream >> result;
77 return result;
78}
79
80bool SlaveInterface::dispatch()
81{
82 Q_D(SlaveInterface);
83 Q_ASSERT( d->connection );
84
85 int cmd;
86 QByteArray data;
87
88 int ret = d->connection->read( &cmd, data );
89 if (ret == -1)
90 return false;
91
92 return dispatch( cmd, data );
93}
94
95void SlaveInterface::calcSpeed()
96{
97 Q_D(SlaveInterface);
98 if (d->slave_calcs_speed) {
99 d->speed_timer.stop();
100 return;
101 }
102
103 struct timeval tv;
104 gettimeofday(&tv, 0);
105
106 long diff = ((tv.tv_sec - d->start_time.tv_sec) * 1000000 +
107 tv.tv_usec - d->start_time.tv_usec) / 1000;
108 if (diff - d->last_time >= 900) {
109 d->last_time = diff;
110 if (d->nums == max_nums) {
111 // let's hope gcc can optimize that well enough
112 // otherwise I'd try memcpy :)
113 for (unsigned int i = 1; i < max_nums; ++i) {
114 d->times[i-1] = d->times[i];
115 d->sizes[i-1] = d->sizes[i];
116 }
117 d->nums--;
118 }
119 d->times[d->nums] = diff;
120 d->sizes[d->nums++] = d->filesize - d->offset;
121
122 KIO::filesize_t lspeed = 1000 * (d->sizes[d->nums-1] - d->sizes[0]) / (d->times[d->nums-1] - d->times[0]);
123
124// kDebug() << (long)d->filesize << diff
125// << long(d->sizes[d->nums-1] - d->sizes[0])
126// << d->times[d->nums-1] - d->times[0]
127// << long(lspeed) << double(d->filesize) / diff
128// << convertSize(lspeed)
129// << convertSize(long(double(d->filesize) / diff) * 1000);
130
131 if (!lspeed) {
132 d->nums = 1;
133 d->times[0] = diff;
134 d->sizes[0] = d->filesize - d->offset;
135 }
136 emit speed(lspeed);
137 }
138}
139
140#ifndef KDE_USE_FINAL // already defined in slavebase.cpp
141/*
142 * Map pid_t to a signed integer type that makes sense for QByteArray;
143 * only the most common sizes 16 bit and 32 bit are special-cased.
144 */
145template<int T> struct PIDType { typedef pid_t PID_t; } ;
146template<> struct PIDType<2> { typedef qint16 PID_t; } ;
147template<> struct PIDType<4> { typedef qint32 PID_t; } ;
148#endif
149
150bool SlaveInterface::dispatch(int _cmd, const QByteArray &rawdata)
151{
152 Q_D(SlaveInterface);
153 //kDebug(7007) << "dispatch " << _cmd;
154
155 QDataStream stream(rawdata);
156
157 QString str1;
158 qint32 i;
159 qint8 b;
160 quint32 ul;
161
162 switch(_cmd) {
163 case MSG_DATA:
164 emit data(rawdata);
165 break;
166 case MSG_DATA_REQ:
167 emit dataReq();
168 break;
169 case MSG_OPENED:
170 emit open();
171 break;
172 case MSG_FINISHED:
173 //kDebug(7007) << "Finished [this = " << this << "]";
174 d->offset = 0;
175 d->speed_timer.stop();
176 emit finished();
177 break;
178 case MSG_STAT_ENTRY: {
179 UDSEntry entry;
180 stream >> entry;
181 emit statEntry(entry);
182 break;
183 }
184 case MSG_LIST_ENTRIES: {
185 quint32 count;
186 stream >> count;
187
188 UDSEntryList list;
189 UDSEntry entry;
190 for (uint i = 0; i < count; i++) {
191 stream >> entry;
192 list.append(entry);
193 }
194 emit listEntries(list);
195 break;
196 }
197 case MSG_RESUME: { // From the put job
198 d->offset = readFilesize_t(stream);
199 emit canResume(d->offset);
200 break;
201 }
202 case MSG_CANRESUME: // From the get job
203 d->filesize = d->offset;
204 emit canResume(0); // the arg doesn't matter
205 break;
206 case MSG_ERROR:
207 stream >> i >> str1;
208 kDebug(7007) << "error " << i << " " << str1;
209 emit error(i, str1);
210 break;
211 case MSG_SLAVE_STATUS: {
212 PIDType<sizeof(pid_t)>::PID_t stream_pid;
213 pid_t pid;
214 QByteArray protocol;
215 stream >> stream_pid >> protocol >> str1 >> b;
216 pid = stream_pid;
217 emit slaveStatus(pid, protocol, str1, (b != 0));
218 break;
219 }
220 case MSG_CONNECTED:
221 emit connected();
222 break;
223 case MSG_WRITTEN: {
224 KIO::filesize_t size = readFilesize_t(stream);
225 emit written(size);
226 break;
227 }
228 case INF_TOTAL_SIZE: {
229 KIO::filesize_t size = readFilesize_t(stream);
230 gettimeofday(&d->start_time, 0);
231 d->last_time = 0;
232 d->filesize = d->offset;
233 d->sizes[0] = d->filesize - d->offset;
234 d->times[0] = 0;
235 d->nums = 1;
236 d->speed_timer.start(1000);
237 d->slave_calcs_speed = false;
238 emit totalSize(size);
239 break;
240 }
241 case INF_PROCESSED_SIZE: {
242 KIO::filesize_t size = readFilesize_t(stream);
243 emit processedSize( size );
244 d->filesize = size;
245 break;
246 }
247 case INF_POSITION: {
248 KIO::filesize_t pos = readFilesize_t(stream);
249 emit position(pos);
250 break;
251 }
252 case INF_SPEED:
253 stream >> ul;
254 d->slave_calcs_speed = true;
255 d->speed_timer.stop();
256 emit speed( ul );
257 break;
258 case INF_GETTING_FILE:
259 break;
260 case INF_ERROR_PAGE:
261 emit errorPage();
262 break;
263 case INF_REDIRECTION: {
264 KUrl url;
265 stream >> url;
266 emit redirection( url );
267 break;
268 }
269 case INF_MIME_TYPE:
270 stream >> str1;
271 emit mimeType(str1);
272 if (!d->connection->suspended())
273 d->connection->sendnow(CMD_NONE, QByteArray());
274 break;
275 case INF_WARNING:
276 stream >> str1;
277 emit warning(str1);
278 break;
279 case INF_MESSAGEBOX: {
280 kDebug(7007) << "needs a msg box";
281 QString text, caption, buttonYes, buttonNo, dontAskAgainName;
282 int type;
283 stream >> type >> text >> caption >> buttonYes >> buttonNo;
284 if (stream.atEnd()) {
285 messageBox(type, text, caption, buttonYes, buttonNo);
286 } else {
287 stream >> dontAskAgainName;
288 messageBox(type, text, caption, buttonYes, buttonNo, dontAskAgainName);
289 }
290 break;
291 }
292 case INF_INFOMESSAGE: {
293 QString msg;
294 stream >> msg;
295 emit infoMessage(msg);
296 break;
297 }
298 case INF_META_DATA: {
299 MetaData m;
300 stream >> m;
301 if (m.contains(QLatin1String("ssl_in_use"))) {
302 const QLatin1String ssl_("ssl_");
303 const MetaData constM = m;
304 for (MetaData::ConstIterator it = constM.lowerBound(ssl_); it != constM.constEnd(); ++it) {
305 if (it.key().startsWith(ssl_)) {
306 d->sslMetaData.insert(it.key(), it.value());
307 } else {
308 // we're past the ssl_* entries; remember that QMap is ordered.
309 break;
310 }
311 }
312 }
313 emit metaData(m);
314 break;
315 }
316 case MSG_NET_REQUEST: {
317 QString host;
318 QString slaveid;
319 stream >> host >> slaveid;
320 requestNetwork(host, slaveid);
321 break;
322 }
323 case MSG_NET_DROP: {
324 QString host;
325 QString slaveid;
326 stream >> host >> slaveid;
327 dropNetwork(host, slaveid);
328 break;
329 }
330 case MSG_NEED_SUBURL_DATA: {
331 emit needSubUrlData();
332 break;
333 }
334 case MSG_HOST_INFO_REQ: {
335 QString hostName;
336 stream >> hostName;
337 HostInfo::lookupHost(hostName, this, SLOT(slotHostInfo(QHostInfo)));
338 break;
339 }
340 default:
341 kWarning(7007) << "Slave sends unknown command (" << _cmd << "), dropping slave";
342 return false;
343 }
344 return true;
345}
346
347void SlaveInterface::setOffset( KIO::filesize_t o)
348{
349 Q_D(SlaveInterface);
350 d->offset = o;
351}
352
353KIO::filesize_t SlaveInterface::offset() const
354{
355 const Q_D(SlaveInterface);
356 return d->offset;
357}
358
359void SlaveInterface::requestNetwork(const QString &host, const QString &slaveid)
360{
361 Q_D(SlaveInterface);
362 kDebug(7007) << "requestNetwork " << host << slaveid;
363 QByteArray packedArgs;
364 QDataStream stream( &packedArgs, QIODevice::WriteOnly );
365 stream << true;
366 d->connection->sendnow( INF_NETWORK_STATUS, packedArgs );
367}
368
369void SlaveInterface::dropNetwork(const QString &host, const QString &slaveid)
370{
371 kDebug(7007) << "dropNetwork " << host << slaveid;
372}
373
374void SlaveInterface::sendResumeAnswer( bool resume )
375{
376 Q_D(SlaveInterface);
377 kDebug(7007) << "ok for resuming:" << resume;
378 d->connection->sendnow( resume ? CMD_RESUMEANSWER : CMD_NONE, QByteArray() );
379}
380
381void SlaveInterface::sendMessageBoxAnswer(int result)
382{
383 Q_D(SlaveInterface);
384 if (!d->connection) {
385 return;
386 }
387
388 if (d->connection->suspended()) {
389 d->connection->resume();
390 }
391 QByteArray packedArgs;
392 QDataStream stream( &packedArgs, QIODevice::WriteOnly );
393 stream << result;
394 d->connection->sendnow(CMD_MESSAGEBOXANSWER, packedArgs);
395 kDebug(7007) << "message box answer" << result;
396}
397
398void SlaveInterface::messageBox( int type, const QString &text, const QString &_caption,
399 const QString &buttonYes, const QString &buttonNo )
400{
401 messageBox( type, text, _caption, buttonYes, buttonNo, QString() );
402}
403
404void SlaveInterface::messageBox( int type, const QString &text, const QString &caption,
405 const QString &buttonYes, const QString &buttonNo, const QString &dontAskAgainName )
406{
407 Q_D(SlaveInterface);
408
409 if (d->connection) {
410 d->connection->suspend();
411 }
412
413 QHash<UserNotificationHandler::MessageBoxDataType, QVariant> data;
414 data.insert(UserNotificationHandler::MSG_TEXT, text);
415 data.insert(UserNotificationHandler::MSG_CAPTION, caption);
416 data.insert(UserNotificationHandler::MSG_YES_BUTTON_TEXT, buttonYes);
417 data.insert(UserNotificationHandler::MSG_NO_BUTTON_TEXT, buttonNo);
418 data.insert(UserNotificationHandler::MSG_DONT_ASK_AGAIN, dontAskAgainName);
419
420 // SMELL: the braindead way to support button icons
421 // TODO: Fix this in KIO::SlaveBase.
422 if (buttonYes == i18n("&Details")) {
423 data.insert(UserNotificationHandler::MSG_YES_BUTTON_ICON, QLatin1String("help-about"));
424 } else if (buttonYes == i18n("&Forever")) {
425 data.insert(UserNotificationHandler::MSG_YES_BUTTON_ICON, QLatin1String("flag-green"));
426 }
427
428 if (buttonNo == i18n("Co&ntinue")) {
429 data.insert(UserNotificationHandler::MSG_NO_BUTTON_ICON, QLatin1String("arrow-right"));
430 } else if (buttonNo == i18n("&Current Session only")) {
431 data.insert(UserNotificationHandler::MSG_NO_BUTTON_ICON, QLatin1String("chronometer"));
432 }
433
434 if (type == KIO::SlaveBase::SSLMessageBox) {
435 data.insert(UserNotificationHandler::MSG_META_DATA, d->sslMetaData.toVariant());
436 }
437
438 globalUserNotificationHandler()->requestMessageBox(this, type, data);
439}
440
441void SlaveInterface::setWindow (QWidget* window)
442{
443 Q_D(SlaveInterface);
444 d->parentWindow = window;
445}
446
447QWidget* SlaveInterface::window() const
448{
449 const Q_D(SlaveInterface);
450 return d->parentWindow;
451}
452
453void SlaveInterfacePrivate::slotHostInfo(const QHostInfo& info)
454{
455 QByteArray data;
456 QDataStream stream(&data, QIODevice::WriteOnly);
457 stream << info.hostName() << info.addresses() << info.error() << info.errorString();
458 connection->send(CMD_HOST_INFO, data);
459}
460
461#include "slaveinterface.moc"
KIO::MetaData
MetaData is a simple map of key/value strings.
Definition: global.h:397
KIO::SlaveBase::SSLMessageBox
@ SSLMessageBox
Definition: slavebase.h:248
KIO::SlaveInterfacePrivate
Definition: slaveinterface_p.h:33
KIO::SlaveInterfacePrivate::connection
Connection * connection
Definition: slaveinterface_p.h:47
KIO::SlaveInterfacePrivate::slotHostInfo
void slotHostInfo(const QHostInfo &info)
Definition: slaveinterface.cpp:453
KIO::SlaveInterface
There are two classes that specifies the protocol between application ( KIO::Job) and kioslave.
Definition: slaveinterface.h:99
KIO::SlaveInterface::calcSpeed
void calcSpeed()
Definition: slaveinterface.cpp:95
KIO::SlaveInterface::sendResumeAnswer
void sendResumeAnswer(bool resume)
Definition: slaveinterface.cpp:374
KIO::SlaveInterface::written
void written(KIO::filesize_t)
KIO::SlaveInterface::redirection
void redirection(const KUrl &)
KIO::SlaveInterface::infoMessage
void infoMessage(const QString &)
KIO::SlaveInterface::setOffset
void setOffset(KIO::filesize_t offset)
Definition: slaveinterface.cpp:347
KIO::SlaveInterface::dropNetwork
void dropNetwork(const QString &, const QString &)
Definition: slaveinterface.cpp:369
KIO::SlaveInterface::messageBox
void messageBox(int type, const QString &text, const QString &caption, const QString &buttonYes, const QString &buttonNo)
Definition: slaveinterface.cpp:398
KIO::SlaveInterface::totalSize
void totalSize(KIO::filesize_t)
KIO::SlaveInterface::d_ptr
SlaveInterfacePrivate *const d_ptr
Definition: slaveinterface.h:202
KIO::SlaveInterface::position
void position(KIO::filesize_t)
KIO::SlaveInterface::~SlaveInterface
virtual ~SlaveInterface()
Definition: slaveinterface.cpp:54
KIO::SlaveInterface::connected
void connected()
KIO::SlaveInterface::slaveStatus
void slaveStatus(pid_t, const QByteArray &, const QString &, bool)
KIO::SlaveInterface::listEntries
void listEntries(const KIO::UDSEntryList &)
KIO::SlaveInterface::sendMessageBoxAnswer
void sendMessageBoxAnswer(int result)
Sends our answer for the INF_MESSAGEBOX request.
Definition: slaveinterface.cpp:381
KIO::SlaveInterface::warning
void warning(const QString &)
KIO::SlaveInterface::connection
Connection * connection() const
Definition: slaveinterface.cpp:67
KIO::SlaveInterface::finished
void finished()
KIO::SlaveInterface::requestNetwork
void requestNetwork(const QString &, const QString &)
Definition: slaveinterface.cpp:359
KIO::SlaveInterface::statEntry
void statEntry(const KIO::UDSEntry &)
KIO::SlaveInterface::setWindow
void setWindow(QWidget *window)
Sets the top level window used as a parent when displaying dialogs.
Definition: slaveinterface.cpp:441
KIO::SlaveInterface::dispatch
virtual bool dispatch()
Definition: slaveinterface.cpp:80
KIO::SlaveInterface::offset
KIO::filesize_t offset() const
Definition: slaveinterface.cpp:353
KIO::SlaveInterface::speed
void speed(unsigned long)
KIO::SlaveInterface::dataReq
void dataReq()
KIO::SlaveInterface::needSubUrlData
void needSubUrlData()
KIO::SlaveInterface::metaData
void metaData(const KIO::MetaData &)
KIO::SlaveInterface::setConnection
void setConnection(Connection *connection)
Definition: slaveinterface.cpp:61
KIO::SlaveInterface::canResume
void canResume(KIO::filesize_t)
KIO::SlaveInterface::window
QWidget * window() const
Returns the top level window used as parent when displaying dialogs.
Definition: slaveinterface.cpp:447
KIO::SlaveInterface::open
void open()
KIO::SlaveInterface::data
void data(const QByteArray &)
KIO::SlaveInterface::processedSize
void processedSize(KIO::filesize_t)
KIO::SlaveInterface::mimeType
void mimeType(const QString &)
KIO::SlaveInterface::error
void error(int, const QString &)
KIO::SlaveInterface::errorPage
void errorPage()
KIO::UDSEntry
Universal Directory Service.
Definition: udsentry.h:59
KIO::UserNotificationHandler
Definition: usernotificationhandler_p.h:34
KIO::UserNotificationHandler::MSG_TEXT
@ MSG_TEXT
Definition: usernotificationhandler_p.h:38
KIO::UserNotificationHandler::MSG_NO_BUTTON_ICON
@ MSG_NO_BUTTON_ICON
Definition: usernotificationhandler_p.h:43
KIO::UserNotificationHandler::MSG_CAPTION
@ MSG_CAPTION
Definition: usernotificationhandler_p.h:39
KIO::UserNotificationHandler::MSG_NO_BUTTON_TEXT
@ MSG_NO_BUTTON_TEXT
Definition: usernotificationhandler_p.h:41
KIO::UserNotificationHandler::MSG_YES_BUTTON_ICON
@ MSG_YES_BUTTON_ICON
Definition: usernotificationhandler_p.h:42
KIO::UserNotificationHandler::MSG_DONT_ASK_AGAIN
@ MSG_DONT_ASK_AGAIN
Definition: usernotificationhandler_p.h:44
KIO::UserNotificationHandler::MSG_META_DATA
@ MSG_META_DATA
Definition: usernotificationhandler_p.h:45
KIO::UserNotificationHandler::MSG_YES_BUTTON_TEXT
@ MSG_YES_BUTTON_TEXT
Definition: usernotificationhandler_p.h:40
KUrl
QHash
QList< UDSEntry >
QObject
QWidget
connection.h
kDebug
#define kDebug
kWarning
#define kWarning
hostinfo_p.h
kdebug.h
timeout
int timeout
klocale.h
i18n
QString i18n(const char *text)
caption
QString caption()
KIO::HostInfo::lookupHost
void lookupHost(const QString &hostName, QObject *receiver, const char *member)
Definition: hostinfo.cpp:240
KIO
A namespace for KIO globals.
Definition: kbookmarkmenu.h:55
KIO::INF_META_DATA
@ INF_META_DATA
Definition: slaveinterface.h:57
KIO::INF_NETWORK_STATUS
@ INF_NETWORK_STATUS
Definition: slaveinterface.h:58
KIO::INF_MESSAGEBOX
@ INF_MESSAGEBOX
Definition: slaveinterface.h:59
KIO::INF_TOTAL_SIZE
@ INF_TOTAL_SIZE
Definition: slaveinterface.h:47
KIO::INF_REDIRECTION
@ INF_REDIRECTION
Definition: slaveinterface.h:50
KIO::INF_MIME_TYPE
@ INF_MIME_TYPE
Definition: slaveinterface.h:51
KIO::INF_SPEED
@ INF_SPEED
Definition: slaveinterface.h:49
KIO::INF_ERROR_PAGE
@ INF_ERROR_PAGE
Definition: slaveinterface.h:52
KIO::INF_WARNING
@ INF_WARNING
Definition: slaveinterface.h:53
KIO::INF_PROCESSED_SIZE
@ INF_PROCESSED_SIZE
Definition: slaveinterface.h:48
KIO::INF_INFOMESSAGE
@ INF_INFOMESSAGE
Definition: slaveinterface.h:56
KIO::INF_POSITION
@ INF_POSITION
Definition: slaveinterface.h:60
KIO::INF_GETTING_FILE
@ INF_GETTING_FILE
Definition: slaveinterface.h:54
KIO::CMD_MESSAGEBOXANSWER
@ CMD_MESSAGEBOXANSWER
Definition: global.h:175
KIO::CMD_NONE
@ CMD_NONE
Definition: global.h:157
KIO::CMD_RESUMEANSWER
@ CMD_RESUMEANSWER
Definition: global.h:176
KIO::CMD_HOST_INFO
@ CMD_HOST_INFO
Definition: global.h:186
KIO::MSG_RESUME
@ MSG_RESUME
Definition: slaveinterface.h:76
KIO::MSG_CANRESUME
@ MSG_CANRESUME
Definition: slaveinterface.h:82
KIO::MSG_STAT_ENTRY
@ MSG_STAT_ENTRY
Definition: slaveinterface.h:73
KIO::MSG_SLAVE_STATUS
@ MSG_SLAVE_STATUS
Definition: slaveinterface.h:77
KIO::MSG_FINISHED
@ MSG_FINISHED
Definition: slaveinterface.h:72
KIO::MSG_HOST_INFO_REQ
@ MSG_HOST_INFO_REQ
Definition: slaveinterface.h:87
KIO::MSG_ERROR
@ MSG_ERROR
Definition: slaveinterface.h:70
KIO::MSG_LIST_ENTRIES
@ MSG_LIST_ENTRIES
Definition: slaveinterface.h:74
KIO::MSG_DATA
@ MSG_DATA
Definition: slaveinterface.h:68
KIO::MSG_NET_REQUEST
@ MSG_NET_REQUEST
Definition: slaveinterface.h:79
KIO::MSG_CONNECTED
@ MSG_CONNECTED
Definition: slaveinterface.h:71
KIO::MSG_NEED_SUBURL_DATA
@ MSG_NEED_SUBURL_DATA
Definition: slaveinterface.h:81
KIO::MSG_DATA_REQ
@ MSG_DATA_REQ
Definition: slaveinterface.h:69
KIO::MSG_NET_DROP
@ MSG_NET_DROP
Definition: slaveinterface.h:80
KIO::MSG_WRITTEN
@ MSG_WRITTEN
Definition: slaveinterface.h:86
KIO::MSG_OPENED
@ MSG_OPENED
Definition: slaveinterface.h:85
KIO::filesize_t
qulonglong filesize_t
64-bit file size
Definition: global.h:57
slavebase.h
readFilesize_t
static KIO::filesize_t readFilesize_t(QDataStream &stream)
Definition: slaveinterface.cpp:73
slaveinterface.h
slaveinterface_p.h
max_nums
static const unsigned int max_nums
Definition: slaveinterface_p.h:29
usernotificationhandler_p.h
This file is part of the KDE documentation.
Documentation copyright © 1996-2023 The KDE developers.
Generated on Mon Feb 20 2023 00:00:00 by doxygen 1.9.6 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

KIO

Skip menu "KIO"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Related Pages

kdelibs-4.14.38 API Reference

Skip menu "kdelibs-4.14.38 API Reference"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDEWebKit
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • kio
  • KIOSlave
  • KJS
  •   KJS-API
  •   WTF
  • kjsembed
  • KNewStuff
  • KParts
  • KPty
  • Kross
  • KUnitConversion
  • KUtils
  • Nepomuk
  • Plasma
  • Solid
  • Sonnet
  • ThreadWeaver
Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal