00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
#include <config.h>
00020
00021
#include <sys/types.h>
00022
#include <sys/wait.h>
00023
#include <sys/uio.h>
00024
00025
#include <assert.h>
00026
#include <signal.h>
00027
#include <stdlib.h>
00028
#include <string.h>
00029
#include <unistd.h>
00030
#include <stdio.h>
00031
00032
#include "kio/global.h"
00033
#include "kio/job.h"
00034
00035
#include <kdebug.h>
00036
#include <klocale.h>
00037
#include <kglobal.h>
00038
#include <kprotocolmanager.h>
00039
#include <kde_file.h>
00040
00041
#ifdef HAVE_VOLMGT
00042
#include <volmgt.h>
00043
#endif
00044
00045 KIO_EXPORT
QString KIO::convertSize( KIO::filesize_t size )
00046 {
00047
double fsize = size;
00048
QString s;
00049
00050
if ( size >= 1073741824 )
00051 {
00052 fsize /= 1073741824.0;
00053
if ( fsize > 1024 )
00054 s = i18n(
"%1 TB" ).arg( KGlobal::locale()->formatNumber(fsize / 1024.0, 1));
00055
else
00056 s = i18n(
"%1 GB" ).arg( KGlobal::locale()->formatNumber(fsize, 1));
00057 }
00058
00059
else if ( size >= 1048576 )
00060 {
00061 fsize /= 1048576.0;
00062 s = i18n(
"%1 MB" ).arg( KGlobal::locale()->formatNumber(fsize, 1));
00063 }
00064
00065
else if ( size >= 1024 )
00066 {
00067 fsize /= 1024.0;
00068 s = i18n(
"%1 KB" ).arg( KGlobal::locale()->formatNumber(fsize, 1));
00069 }
00070
00071
else
00072 {
00073 s = i18n(
"%1 B" ).arg( KGlobal::locale()->formatNumber(fsize, 0));
00074 }
00075
return s;
00076 }
00077
00078 KIO_EXPORT
QString KIO::convertSizeFromKB( KIO::filesize_t kbSize )
00079 {
00080
return convertSize(kbSize * 1024);
00081 }
00082
00083 KIO_EXPORT
QString KIO::number( KIO::filesize_t size )
00084 {
00085
char charbuf[256];
00086 sprintf(charbuf,
"%lld", size);
00087
return QString::fromLatin1(charbuf);
00088 }
00089
00090 KIO_EXPORT
unsigned int KIO::calculateRemainingSeconds( KIO::filesize_t totalSize,
00091 KIO::filesize_t processedSize, KIO::filesize_t speed )
00092 {
00093
if ( (speed != 0) && (totalSize != 0) )
00094
return ( totalSize - processedSize ) / speed;
00095
else
00096
return 0;
00097 }
00098
00099 KIO_EXPORT
QString KIO::convertSeconds(
unsigned int seconds )
00100 {
00101
unsigned int days = seconds / 86400;
00102
unsigned int hours = (seconds - (days * 86400)) / 3600;
00103
unsigned int mins = (seconds - (days * 86400) - (hours * 3600)) / 60;
00104 seconds = (seconds - (days * 86400) - (hours * 3600) - (mins * 60));
00105
00106
const QTime time(hours, mins, seconds);
00107
const QString timeStr( KGlobal::locale()->formatTime(time,
true ,
true ) );
00108
if ( days > 0 )
00109
return i18n(
"1 day %1",
"%n days %1", days).arg(timeStr);
00110
else
00111
return timeStr;
00112 }
00113
00114 KIO_EXPORT
QTime KIO::calculateRemaining( KIO::filesize_t totalSize, KIO::filesize_t processedSize, KIO::filesize_t speed )
00115 {
00116
QTime remainingTime;
00117
00118
if ( speed != 0 ) {
00119 KIO::filesize_t secs;
00120
if ( totalSize == 0 ) {
00121 secs = 0;
00122 }
else {
00123 secs = ( totalSize - processedSize ) / speed;
00124 }
00125
if (secs >= (24*60*60))
00126 secs = (24*60*60)-1;
00127
int hr = secs / ( 60 * 60 );
00128
int mn = ( secs - hr * 60 * 60 ) / 60;
00129
int sc = ( secs - hr * 60 * 60 - mn * 60 );
00130
00131 remainingTime.setHMS( hr, mn, sc );
00132 }
00133
00134
return remainingTime;
00135 }
00136
00137 KIO_EXPORT
QString KIO::itemsSummaryString(uint items, uint files, uint dirs, KIO::filesize_t size,
bool showSize)
00138 {
00139
QString text = items == 0 ? i18n(
"No Items" ) : i18n(
"One Item",
"%n Items", items );
00140 text +=
" - ";
00141 text += files == 0 ? i18n(
"No Files" ) : i18n(
"One File",
"%n Files", files );
00142
if ( showSize && files > 0 )
00143 {
00144 text +=
" ";
00145 text += i18n(
"(%1 Total)").arg(KIO::convertSize( size ) );
00146 }
00147 text +=
" - ";
00148 text += dirs == 0 ? i18n(
"No Folders" ) : i18n(
"One Folder",
"%n Folders", dirs);
00149
return text;
00150 }
00151
00152 KIO_EXPORT
QString KIO::encodeFileName(
const QString & _str )
00153 {
00154
QString str( _str );
00155
00156
int i = 0;
00157
while ( ( i = str.find(
"%", i ) ) != -1 )
00158 {
00159 str.replace( i, 1,
"%%");
00160 i += 2;
00161 }
00162
while ( ( i = str.find(
"/" ) ) != -1 )
00163 str.replace( i, 1,
"%2f");
00164
return str;
00165 }
00166
00167 KIO_EXPORT
QString KIO::decodeFileName(
const QString & _str )
00168 {
00169
QString str;
00170
00171
unsigned int i = 0;
00172
for ( ; i < _str.length() ; ++i )
00173 {
00174
if ( _str[i]==
'%' )
00175 {
00176
if ( _str[i+1]==
'%' )
00177 {
00178 str.append(
'%');
00179 ++i;
00180 }
00181
else if ( _str[i+1]==
'2' && (i+2<_str.length()) && _str[i+2].lower()==
'f' )
00182 {
00183 str.append(
'/');
00184 i += 2;
00185 }
00186
else
00187 str.append(
'%');
00188 }
else
00189 str.append(_str[i]);
00190 }
00191
00192
return str;
00193 }
00194
00195 KIO_EXPORT
QString KIO::Job::errorString()
const
00196
{
00197
return KIO::buildErrorString(m_error, m_errorText);
00198 }
00199
00200 KIO_EXPORT
QString KIO::buildErrorString(
int errorCode,
const QString &errorText)
00201 {
00202
QString result;
00203
00204
switch( errorCode )
00205 {
00206
case KIO::ERR_CANNOT_OPEN_FOR_READING:
00207 result = i18n(
"Could not read %1." ).arg( errorText );
00208
break;
00209
case KIO::ERR_CANNOT_OPEN_FOR_WRITING:
00210 result = i18n(
"Could not write to %1." ).arg( errorText );
00211
break;
00212
case KIO::ERR_CANNOT_LAUNCH_PROCESS:
00213 result = i18n(
"Could not start process %1." ).arg( errorText );
00214
break;
00215
case KIO::ERR_INTERNAL:
00216 result = i18n(
"Internal Error\nPlease send a full bug report at http://bugs.kde.org\n%1" ).arg( errorText );
00217
break;
00218
case KIO::ERR_MALFORMED_URL:
00219 result = i18n(
"Malformed URL %1." ).arg( errorText );
00220
break;
00221
case KIO::ERR_UNSUPPORTED_PROTOCOL:
00222 result = i18n(
"The protocol %1 is not supported." ).arg( errorText );
00223
break;
00224
case KIO::ERR_NO_SOURCE_PROTOCOL:
00225 result = i18n(
"The protocol %1 is only a filter protocol.").arg( errorText );
00226
break;
00227
case KIO::ERR_UNSUPPORTED_ACTION:
00228 result = errorText;
00229
00230
break;
00231
case KIO::ERR_IS_DIRECTORY:
00232 result = i18n(
"%1 is a folder, but a file was expected." ).arg( errorText );
00233
break;
00234
case KIO::ERR_IS_FILE:
00235 result = i18n(
"%1 is a file, but a folder was expected." ).arg( errorText );
00236
break;
00237
case KIO::ERR_DOES_NOT_EXIST:
00238 result = i18n(
"The file or folder %1 does not exist." ).arg( errorText );
00239
break;
00240
case KIO::ERR_FILE_ALREADY_EXIST:
00241 result = i18n(
"A file named %1 already exists." ).arg( errorText );
00242
break;
00243
case KIO::ERR_DIR_ALREADY_EXIST:
00244 result = i18n(
"A folder named %1 already exists." ).arg( errorText );
00245
break;
00246
case KIO::ERR_UNKNOWN_HOST:
00247 result = errorText.isEmpty() ? i18n(
"No hostname specified." ) : i18n(
"Unknown host %1" ).arg( errorText );
00248
break;
00249
case KIO::ERR_ACCESS_DENIED:
00250 result = i18n(
"Access denied to %1." ).arg( errorText );
00251
break;
00252
case KIO::ERR_WRITE_ACCESS_DENIED:
00253 result = i18n(
"Access denied.\nCould not write to %1." ).arg( errorText );
00254
break;
00255
case KIO::ERR_CANNOT_ENTER_DIRECTORY:
00256 result = i18n(
"Could not enter folder %1." ).arg( errorText );
00257
break;
00258
case KIO::ERR_PROTOCOL_IS_NOT_A_FILESYSTEM:
00259 result = i18n(
"The protocol %1 does not implement a folder service." ).arg( errorText );
00260
break;
00261
case KIO::ERR_CYCLIC_LINK:
00262 result = i18n(
"Found a cyclic link in %1." ).arg( errorText );
00263
break;
00264
case KIO::ERR_USER_CANCELED:
00265
00266
break;
00267
case KIO::ERR_CYCLIC_COPY:
00268 result = i18n(
"Found a cyclic link while copying %1." ).arg( errorText );
00269
break;
00270
case KIO::ERR_COULD_NOT_CREATE_SOCKET:
00271 result = i18n(
"Could not create socket for accessing %1." ).arg( errorText );
00272
break;
00273
case KIO::ERR_COULD_NOT_CONNECT:
00274 result = i18n(
"Could not connect to host %1." ).arg( errorText.isEmpty() ? QString::fromLatin1(
"localhost") : errorText );
00275
break;
00276
case KIO::ERR_CONNECTION_BROKEN:
00277 result = i18n(
"Connection to host %1 is broken." ).arg( errorText );
00278
break;
00279
case KIO::ERR_NOT_FILTER_PROTOCOL:
00280 result = i18n(
"The protocol %1 is not a filter protocol." ).arg( errorText );
00281
break;
00282
case KIO::ERR_COULD_NOT_MOUNT:
00283 result = i18n(
"Could not mount device.\nThe reported error was:\n%1" ).arg( errorText );
00284
break;
00285
case KIO::ERR_COULD_NOT_UNMOUNT:
00286 result = i18n(
"Could not unmount device.\nThe reported error was:\n%1" ).arg( errorText );
00287
break;
00288
case KIO::ERR_COULD_NOT_READ:
00289 result = i18n(
"Could not read file %1." ).arg( errorText );
00290
break;
00291
case KIO::ERR_COULD_NOT_WRITE:
00292 result = i18n(
"Could not write to file %1." ).arg( errorText );
00293
break;
00294
case KIO::ERR_COULD_NOT_BIND:
00295 result = i18n(
"Could not bind %1." ).arg( errorText );
00296
break;
00297
case KIO::ERR_COULD_NOT_LISTEN:
00298 result = i18n(
"Could not listen %1." ).arg( errorText );
00299
break;
00300
case KIO::ERR_COULD_NOT_ACCEPT:
00301 result = i18n(
"Could not accept %1." ).arg( errorText );
00302
break;
00303
case KIO::ERR_COULD_NOT_LOGIN:
00304 result = errorText;
00305
break;
00306
case KIO::ERR_COULD_NOT_STAT:
00307 result = i18n(
"Could not access %1." ).arg( errorText );
00308
break;
00309
case KIO::ERR_COULD_NOT_CLOSEDIR:
00310 result = i18n(
"Could not terminate listing %1." ).arg( errorText );
00311
break;
00312
case KIO::ERR_COULD_NOT_MKDIR:
00313 result = i18n(
"Could not make folder %1." ).arg( errorText );
00314
break;
00315
case KIO::ERR_COULD_NOT_RMDIR:
00316 result = i18n(
"Could not remove folder %1." ).arg( errorText );
00317
break;
00318
case KIO::ERR_CANNOT_RESUME:
00319 result = i18n(
"Could not resume file %1." ).arg( errorText );
00320
break;
00321
case KIO::ERR_CANNOT_RENAME:
00322 result = i18n(
"Could not rename file %1." ).arg( errorText );
00323
break;
00324
case KIO::ERR_CANNOT_CHMOD:
00325 result = i18n(
"Could not change permissions for %1." ).arg( errorText );
00326
break;
00327
case KIO::ERR_CANNOT_DELETE:
00328 result = i18n(
"Could not delete file %1." ).arg( errorText );
00329
break;
00330
case KIO::ERR_SLAVE_DIED:
00331 result = i18n(
"The process for the %1 protocol died unexpectedly." ).arg( errorText );
00332
break;
00333
case KIO::ERR_OUT_OF_MEMORY:
00334 result = i18n(
"Error. Out of memory.\n%1" ).arg( errorText );
00335
break;
00336
case KIO::ERR_UNKNOWN_PROXY_HOST:
00337 result = i18n(
"Unknown proxy host\n%1" ).arg( errorText );
00338
break;
00339
case KIO::ERR_COULD_NOT_AUTHENTICATE:
00340 result = i18n(
"Authorization failed, %1 authentication not supported" ).arg( errorText );
00341
break;
00342
case KIO::ERR_ABORTED:
00343 result = i18n(
"User canceled action\n%1" ).arg( errorText );
00344
break;
00345
case KIO::ERR_INTERNAL_SERVER:
00346 result = i18n(
"Internal error in server\n%1" ).arg( errorText );
00347
break;
00348
case KIO::ERR_SERVER_TIMEOUT:
00349 result = i18n(
"Timeout on server\n%1" ).arg( errorText );
00350
break;
00351
case KIO::ERR_UNKNOWN:
00352 result = i18n(
"Unknown error\n%1" ).arg( errorText );
00353
break;
00354
case KIO::ERR_UNKNOWN_INTERRUPT:
00355 result = i18n(
"Unknown interrupt\n%1" ).arg( errorText );
00356
break;
00357
00358
00359
00360
00361
00362
00363
00364
00365
case KIO::ERR_CANNOT_DELETE_ORIGINAL:
00366 result = i18n(
"Could not delete original file %1.\nPlease check permissions." ).arg( errorText );
00367
break;
00368
case KIO::ERR_CANNOT_DELETE_PARTIAL:
00369 result = i18n(
"Could not delete partial file %1.\nPlease check permissions." ).arg( errorText );
00370
break;
00371
case KIO::ERR_CANNOT_RENAME_ORIGINAL:
00372 result = i18n(
"Could not rename original file %1.\nPlease check permissions." ).arg( errorText );
00373
break;
00374
case KIO::ERR_CANNOT_RENAME_PARTIAL:
00375 result = i18n(
"Could not rename partial file %1.\nPlease check permissions." ).arg( errorText );
00376
break;
00377
case KIO::ERR_CANNOT_SYMLINK:
00378 result = i18n(
"Could not create symlink %1.\nPlease check permissions." ).arg( errorText );
00379
break;
00380
case KIO::ERR_NO_CONTENT:
00381 result = errorText;
00382
break;
00383
case KIO::ERR_DISK_FULL:
00384 result = i18n(
"Could not write file %1.\nDisk full." ).arg( errorText );
00385
break;
00386
case KIO::ERR_IDENTICAL_FILES:
00387 result = i18n(
"The source and destination are the same file.\n%1" ).arg( errorText );
00388
break;
00389
case KIO::ERR_SLAVE_DEFINED:
00390 result = errorText;
00391
break;
00392
case KIO::ERR_UPGRADE_REQUIRED:
00393 result = i18n(
"%1 is required by the server, but is not available." ).arg(errorText);
00394
case KIO::ERR_POST_DENIED:
00395 result = i18n(
"Access to restricted port in POST denied.");
00396
break;
00397
default:
00398 result = i18n(
"Unknown error code %1\n%2\nPlease send a full bug report at http://bugs.kde.org." ).arg( errorCode ).arg( errorText );
00399
break;
00400 }
00401
00402
return result;
00403 }
00404
00405 KIO_EXPORT
QString KIO::unsupportedActionErrorString(
const QString &protocol,
int cmd) {
00406
switch (cmd) {
00407
case CMD_CONNECT:
00408
return i18n(
"Opening connections is not supported with the protocol %1." ).arg(protocol);
00409
case CMD_DISCONNECT:
00410
return i18n(
"Closing connections is not supported with the protocol %1." ).arg(protocol);
00411
case CMD_STAT:
00412
return i18n(
"Accessing files is not supported with the protocol %1.").arg(protocol);
00413
case CMD_PUT:
00414
return i18n(
"Writing to %1 is not supported.").arg(protocol);
00415
case CMD_SPECIAL:
00416
return i18n(
"There are no special actions available for protocol %1.").arg(protocol);
00417
case CMD_LISTDIR:
00418
return i18n(
"Listing folders is not supported for protocol %1.").arg(protocol);
00419
case CMD_GET:
00420
return i18n(
"Retrieving data from %1 is not supported.").arg(protocol);
00421
case CMD_MIMETYPE:
00422
return i18n(
"Retrieving mime type information from %1 is not supported.").arg(protocol);
00423
case CMD_RENAME:
00424
return i18n(
"Renaming or moving files within %1 is not supported.").arg(protocol);
00425
case CMD_SYMLINK:
00426
return i18n(
"Creating symlinks is not supported with protocol %1.").arg(protocol);
00427
case CMD_COPY:
00428
return i18n(
"Copying files within %1 is not supported.").arg(protocol);
00429
case CMD_DEL:
00430
return i18n(
"Deleting files from %1 is not supported.").arg(protocol);
00431
case CMD_MKDIR:
00432
return i18n(
"Creating folders is not supported with protocol %1.").arg(protocol);
00433
case CMD_CHMOD:
00434
return i18n(
"Changing the attributes of files is not supported with protocol %1.").arg(protocol);
00435
case CMD_SUBURL:
00436
return i18n(
"Using sub-URLs with %1 is not supported.").arg(protocol);
00437
case CMD_MULTI_GET:
00438
return i18n(
"Multiple get is not supported with protocol %1.").arg(protocol);
00439
default:
00440
return i18n(
"Protocol %1 does not support action %2.").arg(protocol).arg(cmd);
00441 }
00442 }
00443
00444 KIO_EXPORT
QStringList KIO::Job::detailedErrorStrings(
const KURL *reqUrl ,
00445
int method )
const
00446
{
00447
QString errorName, techName, description, ret2;
00448
QStringList causes, solutions, ret;
00449
00450
QByteArray raw =
rawErrorDetail( m_error, m_errorText, reqUrl, method );
00451
QDataStream stream(raw, IO_ReadOnly);
00452
00453 stream >> errorName >> techName >> description >> causes >> solutions;
00454
00455
QString url, protocol, datetime;
00456
if ( reqUrl ) {
00457 url = reqUrl->
htmlURL();
00458 protocol = reqUrl->
protocol();
00459 }
else {
00460 url = i18n(
"(unknown)" );
00461 }
00462
00463 datetime =
KGlobal::locale()->
formatDateTime( QDateTime::currentDateTime(),
00464
false );
00465
00466 ret << errorName;
00467 ret << QString::fromLatin1(
"<qt><p><b>" ) + errorName +
00468 QString::fromLatin1(
"</b></p><p>" ) + description +
00469 QString::fromLatin1(
"</p>" );
00470 ret2 = QString::fromLatin1(
"<qt><p>" );
00471
if ( !techName.isNull() )
00472 ret2 += i18n(
"<b>Technical reason</b>: " ) + techName + QString::fromLatin1(
"</p>" );
00473 ret2 += i18n(
"</p><p><b>Details of the request</b>:" );
00474 ret2 += i18n(
"</p><ul><li>URL: %1</li>" ).arg( url );
00475
if ( !protocol.isNull() ) {
00476 ret2 += i18n(
"<li>Protocol: %1</li>" ).arg( protocol );
00477 }
00478 ret2 += i18n(
"<li>Date and time: %1</li>" ).arg( datetime );
00479 ret2 += i18n(
"<li>Additional information: %1</li></ul>" ).arg( m_errorText );
00480
if ( causes.count() ) {
00481 ret2 += i18n(
"<p><b>Possible causes</b>:</p><ul><li>" );
00482 ret2 += causes.join(
"</li><li>" );
00483 ret2 += QString::fromLatin1(
"</li></ul>" );
00484 }
00485
if ( solutions.count() ) {
00486 ret2 += i18n(
"<p><b>Possible solutions</b>:</p><ul><li>" );
00487 ret2 += solutions.join(
"</li><li>" );
00488 ret2 += QString::fromLatin1(
"</li></ul>" );
00489 }
00490 ret << ret2;
00491
return ret;
00492 }
00493
00494 KIO_EXPORT
QByteArray KIO::rawErrorDetail(
int errorCode,
const QString &errorText,
00495
const KURL *reqUrl ,
int )
00496 {
00497
QString url, host, protocol, datetime, domain, path, dir, filename;
00498
bool isSlaveNetwork =
false;
00499
if ( reqUrl ) {
00500 url = reqUrl->
prettyURL();
00501 host = reqUrl->
host();
00502 protocol = reqUrl->
protocol();
00503
00504
if ( host.left(4) ==
"www." )
00505 domain = host.mid(4);
00506
else
00507 domain = host;
00508
00509 path = reqUrl->
path(1);
00510 filename = reqUrl->
fileName();
00511 dir = path + filename;
00512
00513
00514
00515
if ( protocol ==
"http" ||
00516 protocol ==
"https" ||
00517 protocol ==
"ftp" ||
00518 protocol ==
"sftp" ||
00519 protocol ==
"webdav" ||
00520 protocol ==
"webdavs" ||
00521 protocol ==
"finger" ||
00522 protocol ==
"fish" ||
00523 protocol ==
"gopher" ||
00524 protocol ==
"imap" ||
00525 protocol ==
"imaps" ||
00526 protocol ==
"lan" ||
00527 protocol ==
"ldap" ||
00528 protocol ==
"mailto" ||
00529 protocol ==
"news" ||
00530 protocol ==
"nntp" ||
00531 protocol ==
"pop3" ||
00532 protocol ==
"pop3s" ||
00533 protocol ==
"smtp" ||
00534 protocol ==
"smtps" ||
00535 protocol ==
"telnet"
00536 ) {
00537 isSlaveNetwork =
false;
00538 }
00539 }
else {
00540
00541 url = host = domain = path = filename = dir = errorText;
00542 protocol = i18n(
"(unknown)" );
00543 }
00544
00545 datetime =
KGlobal::locale()->
formatDateTime( QDateTime::currentDateTime(),
00546
false );
00547
00548
QString errorName, techName, description;
00549
QStringList causes, solutions;
00550
00551
00552
QString sSysadmin = i18n(
"Contact your appropriate computer support system, "
00553
"whether the system administrator, or technical support group for further "
00554
"assistance." );
00555
QString sServeradmin = i18n(
"Contact the administrator of the server "
00556
"for further assistance." );
00557
00558
QString sAccess = i18n(
"Check your access permissions on this resource." );
00559
QString cAccess = i18n(
"Your access permissions may be inadequate to "
00560
"perform the requested operation on this resource." );
00561
QString cLocked = i18n(
"The file may be in use (and thus locked) by "
00562
"another user or application." );
00563
QString sQuerylock = i18n(
"Check to make sure that no other "
00564
"application or user is using the file or has locked the file." );
00565
QString cHardware = i18n(
"Although unlikely, a hardware error may have "
00566
"occurred." );
00567
QString cBug = i18n(
"You may have encountered a bug in the program." );
00568
QString cBuglikely = i18n(
"This is most likely to be caused by a bug in the "
00569
"program. Please consider submitting a full bug report as detailed below." );
00570
QString sUpdate = i18n(
"Update your software to the latest version. "
00571
"Your distribution should provide tools to update your software." );
00572
QString sBugreport = i18n(
"When all else fails, please consider helping the "
00573
"KDE team or the third party maintainer of this software by submitting a "
00574
"high quality bug report. If the software is provided by a third party, "
00575
"please contact them directly. Otherwise, first look to see if "
00576
"the same bug has been submitted by someone else by searching at the "
00577
"<a href=\"http://bugs.kde.org/\">KDE bug reporting website</a>. If not, take "
00578
"note of the details given above, and include them in your bug report, along "
00579
"with as many other details as you think might help." );
00580
QString cNetwork = i18n(
"There may have been a problem with your network "
00581
"connection." );
00582
00583
QString cNetconf = i18n(
"There may have been a problem with your network "
00584
"configuration. If you have been accessing the Internet with no problems "
00585
"recently, this is unlikely." );
00586
QString cNetpath = i18n(
"There may have been a problem at some point along "
00587
"the network path between the server and this computer." );
00588
QString sTryagain = i18n(
"Try again, either now or at a later time." );
00589
QString cProtocol = i18n(
"A protocol error or incompatibility may have occurred." );
00590
QString sExists = i18n(
"Ensure that the resource exists, and try again." );
00591
QString cExists = i18n(
"The specified resource may not exist." );
00592
QString cTypo = i18n(
"You may have incorrectly typed the location." );
00593
QString sTypo = i18n(
"Double-check that you have entered the correct location "
00594
"and try again." );
00595
QString sNetwork = i18n(
"Check your network connection status." );
00596
00597
switch( errorCode ) {
00598
case KIO::ERR_CANNOT_OPEN_FOR_READING:
00599 errorName = i18n(
"Cannot Open Resource For Reading" );
00600 description = i18n(
"This means that the contents of the requested file "
00601
"or folder <strong>%1</strong> could not be retrieved, as read "
00602
"access could not be obtained." ).arg( dir );
00603 causes << i18n(
"You may not have permissions to read the file or open "
00604
"the folder.") << cLocked << cHardware;
00605 solutions << sAccess << sQuerylock << sSysadmin;
00606
break;
00607
00608
case KIO::ERR_CANNOT_OPEN_FOR_WRITING:
00609 errorName = i18n(
"Cannot Open Resource For Writing" );
00610 description = i18n(
"This means that the file, <strong>%1</strong>, could "
00611
"not be written to as requested, because access with permission to "
00612
"write could not be obtained." ).arg( filename );
00613 causes << cAccess << cLocked << cHardware;
00614 solutions << sAccess << sQuerylock << sSysadmin;
00615
break;
00616
00617
case KIO::ERR_CANNOT_LAUNCH_PROCESS:
00618 errorName = i18n(
"Cannot Initiate the %1 Protocol" ).arg( protocol );
00619 techName = i18n(
"Unable to Launch Process" );
00620 description = i18n(
"The program on your computer which provides access "
00621
"to the <strong>%1</strong> protocol could not be started. This is "
00622
"usually due to technical reasons." ).arg( protocol );
00623 causes << i18n(
"The program which provides compatibility with this "
00624
"protocol may not have been updated with your last update of KDE. "
00625
"This can cause the program to be incompatible with the current version "
00626
"and thus not start." ) << cBug;
00627 solutions << sUpdate << sSysadmin;
00628
break;
00629
00630
case KIO::ERR_INTERNAL:
00631 errorName = i18n(
"Internal Error" );
00632 description = i18n(
"The program on your computer which provides access "
00633
"to the <strong>%1</strong> protocol has reported an internal error." )
00634 .arg( protocol );
00635 causes << cBuglikely;
00636 solutions << sUpdate << sBugreport;
00637
break;
00638
00639
case KIO::ERR_MALFORMED_URL:
00640 errorName = i18n(
"Improperly Formatted URL" );
00641 description = i18n(
"The <strong>U</strong>niform <strong>R</strong>esource "
00642
"<strong>L</strong>ocator (URL) that you entered was not properly "
00643
"formatted. The format of a URL is generally as follows:"
00644
"<blockquote><strong>protocol://user:password@www.example.org:port/folder/"
00645
"filename.extension?query=value</strong></blockquote>" );
00646 solutions << sTypo;
00647
break;
00648
00649
case KIO::ERR_UNSUPPORTED_PROTOCOL:
00650 errorName = i18n(
"Unsupported Protocol %1" ).arg( protocol );
00651 description = i18n(
"The protocol <strong>%1</strong> is not supported "
00652
"by the KDE programs currently installed on this computer." )
00653 .arg( protocol );
00654 causes << i18n(
"The requested protocol may not be supported." )
00655 << i18n(
"The versions of the %1 protocol supported by this computer and "
00656
"the server may be incompatible." ).arg( protocol );
00657 solutions << i18n(
"You may perform a search on the Internet for a KDE "
00658
"program (called a kioslave or ioslave) which supports this protocol. "
00659
"Places to search include <a href=\"http://kde-apps.org/\">"
00660
"http://kde-apps.org/</a> and <a href=\"http://freshmeat.net/\">"
00661
"http://freshmeat.net/</a>." )
00662 << sUpdate << sSysadmin;
00663
break;
00664
00665
case KIO::ERR_NO_SOURCE_PROTOCOL:
00666 errorName = i18n(
"URL Does Not Refer to a Resource." );
00667 techName = i18n(
"Protocol is a Filter Protocol" );
00668 description = i18n(
"The <strong>U</strong>niform <strong>R</strong>esource "
00669
"<strong>L</strong>ocator (URL) that you entered did not refer to a "
00670
"specific resource." );
00671 causes << i18n(
"KDE is able to communicate through a protocol within a "
00672
"protocol; the protocol specified is only for use in such situations, "
00673
"however this is not one of these situations. This is a rare event, and "
00674
"is likely to indicate a programming error." );
00675 solutions << sTypo;
00676
break;
00677
00678
case KIO::ERR_UNSUPPORTED_ACTION:
00679 errorName = i18n(
"Unsupported Action: %1" ).arg( errorText );
00680 description = i18n(
"The requested action is not supported by the KDE "
00681
"program which is implementing the <strong>%1</strong> protocol." )
00682 .arg( protocol );
00683 causes << i18n(
"This error is very much dependent on the KDE program. The "
00684
"additional information should give you more information than is available "
00685
"to the KDE input/output architecture." );
00686 solutions << i18n(
"Attempt to find another way to accomplish the same "
00687
"outcome." );
00688
break;
00689
00690
case KIO::ERR_IS_DIRECTORY:
00691 errorName = i18n(
"File Expected" );
00692 description = i18n(
"The request expected a file, however the "
00693
"folder <strong>%1</strong> was found instead." ).arg( dir );
00694 causes << i18n(
"This may be an error on the server side." ) << cBug;
00695 solutions << sUpdate << sSysadmin;
00696
break;
00697
00698
case KIO::ERR_IS_FILE:
00699 errorName = i18n(
"Folder Expected" );
00700 description = i18n(
"The request expected a folder, however "
00701
"the file <strong>%1</strong> was found instead." ).arg( filename );
00702 causes << cBug;
00703 solutions << sUpdate << sSysadmin;
00704
break;
00705
00706
case KIO::ERR_DOES_NOT_EXIST:
00707 errorName = i18n(
"File or Folder Does Not Exist" );
00708 description = i18n(
"The specified file or folder <strong>%1</strong> "
00709
"does not exist." ).arg( dir );
00710 causes << cBug;
00711 solutions << sUpdate << sSysadmin;
00712
break;
00713
00714
case KIO::ERR_FILE_ALREADY_EXIST:
00715 errorName = i18n(
"File Already Exists" );
00716 description = i18n(
"The requested file could not be created because a "
00717
"file with the same name already exists." );
00718 solutions << i18n (
"Try moving the current file out of the way first, "
00719
"and then try again." )
00720 << i18n (
"Delete the current file and try again." )
00721 << i18n(
"Choose an alternate filename for the new file." );
00722
break;
00723
00724
case KIO::ERR_DIR_ALREADY_EXIST:
00725 errorName = i18n(
"Folder Already Exists" );
00726 description = i18n(
"The requested folder could not be created because "
00727
"a folder with the same name already exists." );
00728 solutions << i18n(
"Try moving the current folder out of the way first, "
00729
"and then try again." )
00730 << i18n(
"Delete the current folder and try again." )
00731 << i18n(
"Choose an alternate name for the new folder." );
00732
break;
00733
00734
case KIO::ERR_UNKNOWN_HOST:
00735 errorName = i18n(
"Unknown Host" );
00736 description = i18n(
"An unknown host error indicates that the server with "
00737
"the requested name, <strong>%1</strong>, could not be "
00738
"located on the Internet." ).arg( host );
00739 causes << i18n(
"The name that you typed, %1, may not exist: it may be "
00740
"incorrectly typed." ).arg( host )
00741 << cNetwork << cNetconf;
00742 solutions << sNetwork << sSysadmin;
00743
break;
00744
00745
case KIO::ERR_ACCESS_DENIED:
00746 errorName = i18n(
"Access Denied" );
00747 description = i18n(
"Access was denied to the specified resource, "
00748
"<strong>%1</strong>." ).arg( url );
00749 causes << i18n(
"You may have supplied incorrect authentication details or "
00750
"none at all." )
00751 << i18n(
"Your account may not have permission to access the "
00752
"specified resource." );
00753 solutions << i18n(
"Retry the request and ensure your authentication details "
00754
"are entered correctly." ) << sSysadmin;
00755
if ( !isSlaveNetwork ) solutions << sServeradmin;
00756
break;
00757
00758
case KIO::ERR_WRITE_ACCESS_DENIED:
00759 errorName = i18n(
"Write Access Denied" );
00760 description = i18n(
"This means that an attempt to write to the file "
00761
"<strong>%1</strong> was rejected." ).arg( filename );
00762 causes << cAccess << cLocked << cHardware;
00763 solutions << sAccess << sQuerylock << sSysadmin;
00764
break;
00765
00766
case KIO::ERR_CANNOT_ENTER_DIRECTORY:
00767 errorName = i18n(
"Unable to Enter Folder" );
00768 description = i18n(
"This means that an attempt to enter (in other words, "
00769
"to open) the requested folder <strong>%1</strong> was rejected." )
00770 .arg( dir );
00771 causes << cAccess << cLocked;
00772 solutions << sAccess << sQuerylock << sSysadmin;
00773
break;
00774
00775
case KIO::ERR_PROTOCOL_IS_NOT_A_FILESYSTEM:
00776 errorName = i18n(
"Folder Listing Unavailable" );
00777 techName = i18n(
"Protocol %1 is not a Filesystem" ).arg( protocol );
00778 description = i18n(
"This means that a request was made which requires "
00779
"determining the contents of the folder, and the KDE program supporting "
00780
"this protocol is unable to do so." );
00781 causes << cBug;
00782 solutions << sUpdate << sBugreport;
00783
break;
00784
00785
case KIO::ERR_CYCLIC_LINK:
00786 errorName = i18n(
"Cyclic Link Detected" );
00787 description = i18n(
"UNIX environments are commonly able to link a file or "
00788
"folder to a separate name and/or location. KDE detected a link or "
00789
"series of links that results in an infinite loop - i.e. the file was "
00790
"(perhaps in a roundabout way) linked to itself." );
00791 solutions << i18n(
"Delete one part of the loop in order that it does not "
00792
"cause an infinite loop, and try again." ) << sSysadmin;
00793
break;
00794
00795
case KIO::ERR_USER_CANCELED:
00796
00797
00798
00799
00800 errorName = i18n(
"Request Aborted By User" );
00801 description = i18n(
"The request was not completed because it was "
00802
"aborted." );
00803 solutions << i18n(
"Retry the request." );
00804
break;
00805
00806
case KIO::ERR_CYCLIC_COPY:
00807 errorName = i18n(
"Cyclic Link Detected During Copy" );
00808 description = i18n(
"UNIX environments are commonly able to link a file or "
00809
"folder to a separate name and/or location. During the requested copy "
00810
"operation, KDE detected a link or series of links that results in an "
00811
"infinite loop - i.e. the file was (perhaps in a roundabout way) linked "
00812
"to itself." );
00813 solutions << i18n(
"Delete one part of the loop in order that it does not "
00814
"cause an infinite loop, and try again." ) << sSysadmin;
00815
break;
00816
00817
case KIO::ERR_COULD_NOT_CREATE_SOCKET:
00818 errorName = i18n(
"Could Not Create Network Connection" );
00819 techName = i18n(
"Could Not Create Socket" );
00820 description = i18n(
"This is a fairly technical error in which a required "
00821
"device for network communications (a socket) could not be created." );
00822 causes << i18n(
"The network connection may be incorrectly configured, or "
00823
"the network interface may not be enabled." );
00824 solutions << sNetwork << sSysadmin;
00825
break;
00826
00827
case KIO::ERR_COULD_NOT_CONNECT:
00828 errorName = i18n(
"Connection to Server Refused" );
00829 description = i18n(
"The server <strong>%1</strong> refused to allow this "
00830
"computer to make a connection." ).arg( host );
00831 causes << i18n(
"The server, while currently connected to the Internet, "
00832
"may not be configured to allow requests." )
00833 << i18n(
"The server, while currently connected to the Internet, "
00834
"may not be running the requested service (%1)." ).arg( protocol )
00835 << i18n(
"A network firewall (a device which restricts Internet "
00836
"requests), either protecting your network or the network of the server, "
00837
"may have intervened, preventing this request." );
00838 solutions << sTryagain << sServeradmin << sSysadmin;
00839
break;
00840
00841
case KIO::ERR_CONNECTION_BROKEN:
00842 errorName = i18n(
"Connection to Server Closed Unexpectedly" );
00843 description = i18n(
"Although a connection was established to "
00844
"<strong>%1</strong>, the connection was closed at an unexpected point "
00845
"in the communication." ).arg( host );
00846 causes << cNetwork << cNetpath << i18n(
"A protocol error may have occurred, "
00847
"causing the server to close the connection as a response to the error." );
00848 solutions << sTryagain << sServeradmin << sSysadmin;
00849
break;
00850
00851
case KIO::ERR_NOT_FILTER_PROTOCOL:
00852 errorName = i18n(
"URL Resource Invalid" );
00853 techName = i18n(
"Protocol %1 is not a Filter Protocol" ).arg( protocol );
00854 description = i18n(
"The <strong>U</strong>niform <strong>R</strong>esource "
00855
"<strong>L</strong>ocator (URL) that you entered did not refer to "
00856
"a valid mechanism of accessing the specific resource, "
00857
"<strong>%1%2</strong>." )
00858 .arg( !host.isNull() ? host +
'/' : QString::null ).arg( dir );
00859 causes << i18n(
"KDE is able to communicate through a protocol within a "
00860
"protocol. This request specified a protocol be used as such, however "
00861
"this protocol is not capable of such an action. This is a rare event, "
00862
"and is likely to indicate a programming error." );
00863 solutions << sTypo << sSysadmin;
00864
break;
00865
00866
case KIO::ERR_COULD_NOT_MOUNT:
00867 errorName = i18n(
"Unable to Initialize Input/Output Device" );
00868 techName = i18n(
"Could Not Mount Device" );
00869 description = i18n(
"The requested device could not be initialized "
00870
"(\"mounted\"). The reported error was: <strong>%1</strong>" )
00871 .arg( errorText );
00872 causes << i18n(
"The device may not be ready, for example there may be "
00873
"no media in a removable media device (i.e. no CD-ROM in a CD drive), "
00874
"or in the case of a peripheral/portable device, the device may not "
00875
"be correctly connected." )
00876 << i18n(
"You may not have permissions to initialize (\"mount\") the "
00877
"device. On UNIX systems, often system administrator privileges are "
00878
"required to initialize a device." )
00879 << cHardware;
00880 solutions << i18n(
"Check that the device is ready; removable drives "
00881
"must contain media, and portable devices must be connected and powered "
00882
"on.; and try again." ) << sAccess << sSysadmin;
00883
break;
00884
00885
case KIO::ERR_COULD_NOT_UNMOUNT:
00886 errorName = i18n(
"Unable to Uninitialize Input/Output Device" );
00887 techName = i18n(
"Could Not Unmount Device" );
00888 description = i18n(
"The requested device could not be uninitialized "
00889
"(\"unmounted\"). The reported error was: <strong>%1</strong>" )
00890 .arg( errorText );
00891 causes << i18n(
"The device may be busy, that is, still in use by "
00892
"another application or user. Even such things as having an open "
00893
"browser window on a location on this device may cause the device to "
00894
"remain in use." )
00895 << i18n(
"You may not have permissions to uninitialize (\"unmount\") "
00896
"the device. On UNIX systems, system administrator privileges are "
00897
"often required to uninitialize a device." )
00898 << cHardware;
00899 solutions << i18n(
"Check that no applications are accessing the device, "
00900
"and try again." ) << sAccess << sSysadmin;
00901
break;
00902
00903
case KIO::ERR_COULD_NOT_READ:
00904 errorName = i18n(
"Cannot Read From Resource" );
00905 description = i18n(
"This means that although the resource, "
00906
"<strong>%1</strong>, was able to be opened, an error occurred while "
00907
"reading the contents of the resource." ).arg( url );
00908 causes << i18n(
"You may not have permissions to read from the resource." );
00909
if ( !isSlaveNetwork ) causes << cNetwork;
00910 causes << cHardware;
00911 solutions << sAccess;
00912
if ( !isSlaveNetwork ) solutions << sNetwork;
00913 solutions << sSysadmin;
00914
break;
00915
00916
case KIO::ERR_COULD_NOT_WRITE:
00917 errorName = i18n(
"Cannot Write to Resource" );
00918 description = i18n(
"This means that although the resource, <strong>%1</strong>"
00919
", was able to be opened, an error occurred while writing to the resource." )
00920 .arg( url );
00921 causes << i18n(
"You may not have permissions to write to the resource." );
00922
if ( !isSlaveNetwork ) causes << cNetwork;
00923 causes << cHardware;
00924 solutions << sAccess;
00925
if ( !isSlaveNetwork ) solutions << sNetwork;
00926 solutions << sSysadmin;
00927
break;
00928
00929
case KIO::ERR_COULD_NOT_BIND:
00930 errorName = i18n(
"Could Not Listen for Network Connections" );
00931 techName = i18n(
"Could Not Bind" );
00932 description = i18n(
"This is a fairly technical error in which a required "
00933
"device for network communications (a socket) could not be established "
00934
"to listen for incoming network connections." );
00935 causes << i18n(
"The network connection may be incorrectly configured, or "
00936
"the network interface may not be enabled." );
00937 solutions << sNetwork << sSysadmin;
00938
break;
00939
00940
case KIO::ERR_COULD_NOT_LISTEN:
00941 errorName = i18n(
"Could Not Listen for Network Connections" );
00942 techName = i18n(
"Could Not Listen" );
00943 description = i18n(
"This is a fairly technical error in which a required "
00944
"device for network communications (a socket) could not be established "
00945
"to listen for incoming network connections." );
00946 causes << i18n(
"The network connection may be incorrectly configured, or "
00947
"the network interface may not be enabled." );
00948 solutions << sNetwork << sSysadmin;
00949
break;
00950
00951
case KIO::ERR_COULD_NOT_ACCEPT:
00952 errorName = i18n(
"Could Not Accept Network Connection" );
00953 description = i18n(
"This is a fairly technical error in which an error "
00954
"occurred while attempting to accept an incoming network connection." );
00955 causes << i18n(
"The network connection may be incorrectly configured, or "
00956
"the network interface may not be enabled." )
00957 << i18n(
"You may not have permissions to accept the connection." );
00958 solutions << sNetwork << sSysadmin;
00959
break;
00960
00961
case KIO::ERR_COULD_NOT_LOGIN:
00962 errorName = i18n(
"Could Not Login: %1" ).arg( errorText );
00963 description = i18n(
"An attempt to login to perform the requested "
00964
"operation was unsuccessful." );
00965 causes << i18n(
"You may have supplied incorrect authentication details or "
00966
"none at all." )
00967 << i18n(
"Your account may not have permission to access the "
00968
"specified resource." ) << cProtocol;
00969 solutions << i18n(
"Retry the request and ensure your authentication details "
00970
"are entered correctly." ) << sServeradmin << sSysadmin;
00971
break;
00972
00973
case KIO::ERR_COULD_NOT_STAT:
00974 errorName = i18n(
"Could Not Determine Resource Status" );
00975 techName = i18n(
"Could Not Stat Resource" );
00976 description = i18n(
"An attempt to determine information about the status "
00977
"of the resource <strong>%1</strong>, such as the resource name, type, "
00978
"size, etc., was unsuccessful." ).arg( url );
00979 causes << i18n(
"The specified resource may not have existed or may "
00980
"not be accessible." ) << cProtocol << cHardware;
00981 solutions << i18n(
"Retry the request and ensure your authentication details "
00982
"are entered correctly." ) << sSysadmin;
00983
break;
00984
00985
case KIO::ERR_COULD_NOT_CLOSEDIR:
00986
00987 errorName = i18n(
"Could Not Cancel Listing" );
00988 techName = i18n(
"FIXME: Document this" );
00989
break;
00990
00991
case KIO::ERR_COULD_NOT_MKDIR:
00992 errorName = i18n(
"Could Not Create Folder" );
00993 description = i18n(
"An attempt to create the requested folder failed." );
00994 causes << cAccess << i18n(
"The location where the folder was to be created "
00995
"may not exist." );
00996
if ( !isSlaveNetwork ) causes << cProtocol;
00997 solutions << i18n(
"Retry the request." ) << sAccess;
00998
break;
00999
01000
case KIO::ERR_COULD_NOT_RMDIR:
01001 errorName = i18n(
"Could Not Remove Folder" );
01002 description = i18n(
"An attempt to remove the specified folder, "
01003
"<strong>%1</strong>, failed." ).arg( dir );
01004 causes << i18n(
"The specified folder may not exist." )
01005 << i18n(
"The specified folder may not be empty." )
01006 << cAccess;
01007
if ( !isSlaveNetwork ) causes << cProtocol;
01008 solutions << i18n(
"Ensure that the folder exists and is empty, and try "
01009
"again." ) << sAccess;
01010
break;
01011
01012
case KIO::ERR_CANNOT_RESUME:
01013 errorName = i18n(
"Could Not Resume File Transfer" );
01014 description = i18n(
"The specified request asked that the transfer of "
01015
"file <strong>%1</strong> be resumed at a certain point of the "
01016
"transfer. This was not possible." ).arg( filename );
01017 causes << i18n(
"The protocol, or the server, may not support file "
01018
"resuming." );
01019 solutions << i18n(
"Retry the request without attempting to resume "
01020
"transfer." );
01021
break;
01022
01023
case KIO::ERR_CANNOT_RENAME:
01024 errorName = i18n(
"Could Not Rename Resource" );
01025 description = i18n(
"An attempt to rename the specified resource "
01026
"<strong>%1</strong> failed." ).arg( url );
01027 causes << cAccess << cExists;
01028
if ( !isSlaveNetwork ) causes << cProtocol;
01029 solutions << sAccess << sExists;
01030
break;
01031
01032
case KIO::ERR_CANNOT_CHMOD:
01033 errorName = i18n(
"Could Not Alter Permissions of Resource" );
01034 description = i18n(
"An attempt to alter the permissions on the specified "
01035
"resource <strong>%1</strong> failed." ).arg( url );
01036 causes << cAccess << cExists;
01037 solutions << sAccess << sExists;
01038
break;
01039
01040
case KIO::ERR_CANNOT_DELETE:
01041 errorName = i18n(
"Could Not Delete Resource" );
01042 description = i18n(
"An attempt to delete the specified resource "
01043
"<strong>%1</strong> failed." ).arg( url );
01044 causes << cAccess << cExists;
01045 solutions << sAccess << sExists;
01046
break;
01047
01048
case KIO::ERR_SLAVE_DIED:
01049 errorName = i18n(
"Unexpected Program Termination" );
01050 description = i18n(
"The program on your computer which provides access "
01051
"to the <strong>%1</strong> protocol has unexpectedly terminated." )
01052 .arg( url );
01053 causes << cBuglikely;
01054 solutions << sUpdate << sBugreport;
01055
break;
01056
01057
case KIO::ERR_OUT_OF_MEMORY:
01058 errorName = i18n(
"Out of Memory" );
01059 description = i18n(
"The program on your computer which provides access "
01060
"to the <strong>%1</strong> protocol could not obtain the memory "
01061
"required to continue." ).arg( protocol );
01062 causes << cBuglikely;
01063 solutions << sUpdate << sBugreport;
01064
break;
01065
01066
case KIO::ERR_UNKNOWN_PROXY_HOST:
01067 errorName = i18n(
"Unknown Proxy Host" );
01068 description = i18n(
"While retrieving information about the specified "
01069
"proxy host, <strong>%1</strong>, an Unknown Host error was encountered. "
01070
"An unknown host error indicates that the requested name could not be "
01071
"located on the Internet." ).arg( errorText );
01072 causes << i18n(
"There may have been a problem with your network "
01073
"configuration, specifically your proxy's hostname. If you have been "
01074
"accessing the Internet with no problems recently, this is unlikely." )
01075 << cNetwork;
01076 solutions << i18n(
"Double-check your proxy settings and try again." )
01077 << sSysadmin;
01078
break;
01079
01080
case KIO::ERR_COULD_NOT_AUTHENTICATE:
01081 errorName = i18n(
"Authentication Failed: Method %1 Not Supported" )
01082 .arg( errorText );
01083 description = i18n(
"Although you may have supplied the correct "
01084
"authentication details, the authentication failed because the "
01085
"method that the server is using is not supported by the KDE "
01086
"program implementing the protocol %1." ).arg( protocol );
01087 solutions << i18n(
"Please file a bug at <a href=\"http://bugs.kde.org/\">"
01088
"http://bugs.kde.org/</a> to inform the KDE team of the unsupported "
01089
"authentication method." ) << sSysadmin;
01090
break;
01091
01092
case KIO::ERR_ABORTED:
01093 errorName = i18n(
"Request Aborted" );
01094 description = i18n(
"The request was not completed because it was "
01095
"aborted." );
01096 solutions << i18n(
"Retry the request." );
01097
break;
01098
01099
case KIO::ERR_INTERNAL_SERVER:
01100 errorName = i18n(
"Internal Error in Server" );
01101 description = i18n(
"The program on the server which provides access "
01102
"to the <strong>%1</strong> protocol has reported an internal error: "
01103
"%0." ).arg( protocol );
01104 causes << i18n(
"This is most likely to be caused by a bug in the "
01105
"server program. Please consider submitting a full bug report as "
01106
"detailed below." );
01107 solutions << i18n(
"Contact the administrator of the server "
01108
"to advise them of the problem." )
01109 << i18n(
"If you know who the authors of the server software are, "
01110
"submit the bug report directly to them." );
01111
break;
01112
01113
case KIO::ERR_SERVER_TIMEOUT:
01114 errorName = i18n(
"Timeout Error" );
01115 description = i18n(
"Although contact was made with the server, a "
01116
"response was not received within the amount of time allocated for "
01117
"the request as follows:<ul>"
01118
"<li>Timeout for establishing a connection: %1 seconds</li>"
01119
"<li>Timeout for receiving a response: %2 seconds</li>"
01120
"<li>Timeout for accessing proxy servers: %3 seconds</li></ul>"
01121
"Please note that you can alter these timeout settings in the KDE "
01122
"Control Center, by selecting Network -> Preferences." )
01123 .arg( KProtocolManager::connectTimeout() )
01124 .arg( KProtocolManager::responseTimeout() )
01125 .arg( KProtocolManager::proxyConnectTimeout() );
01126 causes << cNetpath << i18n(
"The server was too busy responding to other "
01127
"requests to respond." );
01128 solutions << sTryagain << sServeradmin;
01129
break;
01130
01131
case KIO::ERR_UNKNOWN:
01132 errorName = i18n(
"Unknown Error" );
01133 description = i18n(
"The program on your computer which provides access "
01134
"to the <strong>%1</strong> protocol has reported an unknown error: "
01135
"%2." ).arg( protocol ).arg( errorText );
01136 causes << cBug;
01137 solutions << sUpdate << sBugreport;
01138
break;
01139
01140
case KIO::ERR_UNKNOWN_INTERRUPT:
01141 errorName = i18n(
"Unknown Interruption" );
01142 description = i18n(
"The program on your computer which provides access "
01143
"to the <strong>%1</strong> protocol has reported an interruption of "
01144
"an unknown type: %2." ).arg( protocol ).arg( errorText );
01145 causes << cBug;
01146 solutions << sUpdate << sBugreport;
01147
break;
01148
01149
case KIO::ERR_CANNOT_DELETE_ORIGINAL:
01150 errorName = i18n(
"Could Not Delete Original File" );
01151 description = i18n(
"The requested operation required the deleting of "
01152
"the original file, most likely at the end of a file move operation. "
01153
"The original file <strong>%1</strong> could not be deleted." )
01154 .arg( errorText );
01155 causes << cAccess;
01156 solutions << sAccess;
01157
break;
01158
01159
case KIO::ERR_CANNOT_DELETE_PARTIAL:
01160 errorName = i18n(
"Could Not Delete Temporary File" );
01161 description = i18n(
"The requested operation required the creation of "
01162
"a temporary file in which to save the new file while being "
01163
"downloaded. This temporary file <strong>%1</strong> could not be "
01164
"deleted." ).arg( errorText );
01165 causes << cAccess;
01166 solutions << sAccess;
01167
break;
01168
01169
case KIO::ERR_CANNOT_RENAME_ORIGINAL:
01170 errorName = i18n(
"Could Not Rename Original File" );
01171 description = i18n(
"The requested operation required the renaming of "
01172
"the original file <strong>%1</strong>, however it could not be "
01173
"renamed." ).arg( errorText );
01174 causes << cAccess;
01175 solutions << sAccess;
01176
break;
01177
01178
case KIO::ERR_CANNOT_RENAME_PARTIAL:
01179 errorName = i18n(
"Could Not Rename Temporary File" );
01180 description = i18n(
"The requested operation required the creation of "
01181
"a temporary file <strong>%1</strong>, however it could not be "
01182
"created." ).arg( errorText );
01183 causes << cAccess;
01184 solutions << sAccess;
01185
break;
01186
01187
case KIO::ERR_CANNOT_SYMLINK:
01188 errorName = i18n(
"Could Not Create Link" );
01189 techName = i18n(
"Could Not Create Symbolic Link" );
01190 description = i18n(
"The requested symbolic link %1 could not be created." )
01191 .arg( errorText );
01192 causes << cAccess;
01193 solutions << sAccess;
01194
break;
01195
01196
case KIO::ERR_NO_CONTENT:
01197 errorName = i18n(
"No Content" );
01198 description = errorText;
01199
break;
01200
01201
case KIO::ERR_DISK_FULL:
01202 errorName = i18n(
"Disk Full" );
01203 description = i18n(
"The requested file <strong>%1</strong> could not be "
01204
"written to as there is inadequate disk space." ).arg( errorText );
01205 solutions << i18n(
"Free up enough disk space by 1) deleting unwanted and "
01206
"temporary files; 2) archiving files to removable media storage such as "
01207
"CD-Recordable discs; or 3) obtain more storage capacity." )
01208 << sSysadmin;
01209
break;
01210
01211
case KIO::ERR_IDENTICAL_FILES:
01212 errorName = i18n(
"Source and Destination Files Identical" );
01213 description = i18n(
"The operation could not be completed because the "
01214
"source and destination files are the same file." );
01215 solutions << i18n(
"Choose a different filename for the destination file." );
01216
break;
01217
01218
01219
case KIO::ERR_SLAVE_DEFINED:
01220 errorName = QString::null;
01221 description = errorText;
01222
break;
01223
01224
default:
01225
01226 errorName = i18n(
"Undocumented Error" );
01227 description =
buildErrorString( errorCode, errorText );
01228 }
01229
01230
QByteArray ret;
01231
QDataStream stream(ret, IO_WriteOnly);
01232 stream << errorName << techName << description << causes << solutions;
01233
return ret;
01234 }
01235
01236
#ifdef Q_OS_UNIX
01237
01238
#include <limits.h>
01239
#include <stdlib.h>
01240
#include <stdio.h>
01241
#include <qfile.h>
01242
01243
#include <config.h>
01244
01245
#ifdef HAVE_PATHS_H
01246
#include <paths.h>
01247
#endif
01248
#ifdef HAVE_SYS_STAT_H
01249
#include <sys/stat.h>
01250
#endif
01251
#include <sys/param.h>
01252
#ifdef HAVE_LIMITS_H
01253
#include <limits.h>
01254
#endif
01255
#ifdef HAVE_SYS_MNTTAB_H
01256
#include <sys/mnttab.h>
01257
#endif
01258
#ifdef HAVE_MNTENT_H
01259
#include <mntent.h>
01260
#elif defined(HAVE_SYS_MNTENT_H)
01261
#include <sys/mntent.h>
01262
#endif
01263
#ifdef HAVE_SYS_UCRED_H
01264
#include <sys/ucred.h>
01265
#endif
01266
#ifdef HAVE_SYS_MOUNT_H
01267
#include <sys/mount.h>
01268
#endif
01269
#ifdef HAVE_FSTAB_H
01270
#include <fstab.h>
01271
#endif
01272
#if defined(_AIX)
01273
#include <sys/mntctl.h>
01274
#include <sys/vmount.h>
01275
#include <sys/vfs.h>
01276
01277
01278
#ifndef mntctl
01279
extern "C" {
01280
int mntctl(
int command,
int size,
void* buffer);
01281 }
01282
#endif
01283
extern "C" struct vfs_ent *getvfsbytype(
int vfsType);
01284
extern "C" void endvfsent( );
01285
#endif
01286
01287
01288
01289
01290
01291
01292
01293
#ifndef HAVE_GETMNTINFO
01294
01295
#ifdef _PATH_MOUNTED
01296
01297
# undef MNTTAB
01298
# define MNTTAB _PATH_MOUNTED
01299
#else
01300
# ifndef MNTTAB
01301
# ifdef MTAB_FILE
01302
# define MNTTAB MTAB_FILE
01303
# else
01304
# define MNTTAB "/etc/mnttab"
01305
# endif
01306
# endif
01307
#endif
01308
01309
#ifndef FSTAB
01310
# ifdef _PATH_FSTAB
01311
# define FSTAB _PATH_FSTAB
01312
# else
01313
# define FSTAB "/etc/fstab"
01314
# endif
01315
#endif
01316
01317
01318
01319
01320
01321
01322
01323
01324
#ifdef HAVE_SETMNTENT
01325
#define SETMNTENT setmntent
01326
#define ENDMNTENT endmntent
01327
#define STRUCT_MNTENT struct mntent *
01328
#define STRUCT_SETMNTENT FILE *
01329
#define GETMNTENT(file, var) ((var = getmntent(file)) != 0)
01330
#define MOUNTPOINT(var) var->mnt_dir
01331
#define MOUNTTYPE(var) var->mnt_type
01332
#define HASMNTOPT(var, opt) hasmntopt(var, opt)
01333
#define FSNAME(var) var->mnt_fsname
01334
#elif defined(_AIX)
01335
01336
#else
01337
#define SETMNTENT fopen
01338
#define ENDMNTENT fclose
01339
#define STRUCT_MNTENT struct mnttab
01340
#define STRUCT_SETMNTENT FILE *
01341
#define GETMNTENT(file, var) (getmntent(file, &var) == 0)
01342
#define MOUNTPOINT(var) var.mnt_mountp
01343
#define MOUNTTYPE(var) var.mnt_fstype
01344
#define HASMNTOPT(var, opt) hasmntopt(&var, opt)
01345
#define FSNAME(var) var.mnt_special
01346
#endif
01347
01348
#endif
01349
01350
QString KIO::findDeviceMountPoint(
const QString& filename )
01351 {
01352
QString result;
01353
01354
#ifdef HAVE_VOLMGT
01355
01356
01357
01358
const char *volpath;
01359 FILE *mnttab;
01360
struct mnttab mnt;
01361
int len;
01362
QCString devname;
01363
01364
if( (volpath = volmgt_root()) == NULL ) {
01365
kdDebug( 7007 ) <<
"findDeviceMountPoint: "
01366 <<
"VOLMGT: can't find volmgt root dir" <<
endl;
01367
return QString::null;
01368 }
01369
01370
if( (mnttab = fopen( MNTTAB,
"r" )) == NULL ) {
01371
kdDebug( 7007 ) <<
"findDeviceMountPoint: "
01372 <<
"VOLMGT: can't open mnttab" <<
endl;
01373
return QString::null;
01374 }
01375
01376 devname = volpath;
01377 devname += QFile::encodeName( filename );
01378 devname +=
'/';
01379 len = devname.length();
01380
01381
01382
01383
01384
01385
01386
01387
01388
01389
01390
01391 rewind( mnttab );
01392 result = QString::null;
01393
while( getmntent( mnttab, &mnt ) == 0 ) {
01394
01395
01396
01397
01398
if( strncmp( devname.data(), mnt.mnt_special, len ) == 0
01399 || (strncmp( devname.data(), mnt.mnt_special, len - 3 ) == 0
01400 && mnt.mnt_special[len - 3] ==
'/' )
01401 || (strcmp(QFile::encodeName(filename).data()
01402 , mnt.mnt_special)==0)) {
01403 result = mnt.mnt_mountp;
01404
break;
01405 }
01406 }
01407 fclose( mnttab );
01408
#else
01409
01410
char realpath_buffer[MAXPATHLEN];
01411
QCString realname;
01412
01413 realname = QFile::encodeName(filename);
01414
01415
if (realpath(realname, realpath_buffer) != 0)
01416
01417 realname = realpath_buffer;
01418
01419
01420
01421
#ifdef HAVE_GETMNTINFO
01422
01423
struct statfs *mounted;
01424
01425
int num_fs = getmntinfo(&mounted, MNT_NOWAIT);
01426
01427
for (
int i=0;i<num_fs;i++) {
01428
01429
QCString device_name = mounted[i].f_mntfromname;
01430
01431
01432
01433
if (realpath(device_name, realpath_buffer) != 0)
01434
01435 device_name = realpath_buffer;
01436
01437
if (realname == device_name) {
01438 result = mounted[i].f_mntonname;
01439
break;
01440 }
01441 }
01442
01443
#elif defined(_AIX)
01444
01445
struct vmount *mntctl_buffer;
01446
struct vmount *vm;
01447
char *mountedfrom;
01448
char *mountedto;
01449
int fsname_len, num;
01450
int buf_sz = 4096;
01451
01452
01453
01454
01455
01456
01457
01458
01459
01460
01461
01462 mntctl_buffer = (
struct vmount*)malloc(buf_sz);
01463 num = mntctl(MCTL_QUERY, buf_sz, mntctl_buffer);
01464
if (num == 0)
01465 {
01466 buf_sz = *(
int*)mntctl_buffer;
01467 free(mntctl_buffer);
01468 mntctl_buffer = (
struct vmount*)malloc(buf_sz);
01469 num = mntctl(MCTL_QUERY, buf_sz, mntctl_buffer);
01470 }
01471
01472
if (num > 0)
01473 {
01474
01475 vm = mntctl_buffer;
01476
for ( ; num > 0; num-- )
01477 {
01478
01479 fsname_len = vmt2datasize(vm, VMT_STUB);
01480 mountedto = (
char*)malloc(fsname_len + 1);
01481 mountedto[fsname_len] =
'\0';
01482 strncpy(mountedto, (
char *)vmt2dataptr(vm, VMT_STUB), fsname_len);
01483
01484
01485 fsname_len = vmt2datasize(vm, VMT_OBJECT);
01486 mountedfrom = (
char*)malloc(fsname_len + 1);
01487 mountedfrom[fsname_len] =
'\0';
01488 strncpy(mountedfrom, (
char *)vmt2dataptr(vm, VMT_OBJECT), fsname_len);
01489
01490
QCString device_name = mountedfrom;
01491
01492
if (realpath(device_name, realpath_buffer) != 0)
01493
01494 device_name = realpath_buffer;
01495
01496 free(mountedfrom);
01497
01498
if (realname == device_name) {
01499 result = mountedto;
01500 free(mountedto);
01501
break;
01502 }
01503
01504 free(mountedto);
01505
01506
01507 vm = (
struct vmount *)((
char *)vm + vm->vmt_length);
01508 }
01509 }
01510
01511 free( mntctl_buffer );
01512
01513
#else
01514
01515 STRUCT_SETMNTENT mtab;
01516
01517
01518
01519
if ((mtab = SETMNTENT(MNTTAB,
"r")) == 0) {
01520
perror(
"setmntent");
01521
return QString::null;
01522 }
01523
01524
01525
01526
01527
01528
01529
01530
01531
01532
01533
01534 STRUCT_MNTENT me;
01535
01536
while (GETMNTENT(mtab, me))
01537 {
01538
01539
01540
QCString device_name = FSNAME(me);
01541
if (device_name.isEmpty() || (device_name ==
"none"))
01542
continue;
01543
01544
01545
01546
01547
01548
if (realpath(device_name, realpath_buffer) != 0)
01549
01550 device_name = realpath_buffer;
01551
01552
01553
01554
if (realname == device_name)
01555 {
01556 result = MOUNTPOINT(me);
01557
break;
01558 }
01559 }
01560
01561 ENDMNTENT(mtab);
01562
01563
#endif
01564
#endif
01565
01566
01567
return result;
01568 }
01569
01570
01571
static bool is_my_mountpoint(
const char *mountpoint,
const char *realname,
int &max )
01572 {
01573
int length = strlen(mountpoint);
01574
01575
if (!strncmp(mountpoint, realname, length)
01576 && length > max) {
01577 max = length;
01578
if (length == 1 || realname[length] ==
'/' || realname[length] ==
'\0')
01579
return true;
01580 }
01581
return false;
01582 }
01583
01584
typedef enum { Unseen, Right, Wrong } MountState;
01585
01589
static void check_mount_point(
const char *mounttype,
01590
const char *fsname,
01591 MountState &isslow, MountState &isautofs)
01592 {
01593
bool nfs = !strcmp(mounttype,
"nfs");
01594
bool autofs = !strcmp(mounttype,
"autofs") || !strcmp(mounttype,
"subfs");
01595
bool pid = (strstr(fsname,
":(pid") != 0);
01596
01597
if (nfs && !pid)
01598 isslow = Right;
01599
else if (isslow == Right)
01600 isslow = Wrong;
01601
01602
01603
if (autofs || (nfs && pid)) {
01604 isautofs = Right;
01605 isslow = Right;
01606 }
01607 }
01608
01609
01610
01611
static QString get_mount_info(
const QString& filename,
01612 MountState& isautofs, MountState& isslow, MountState& ismanual,
01613
QString& fstype)
01614 {
01615
static bool gotRoot =
false;
01616
static dev_t rootDevice;
01617
01618
struct cachedDevice_t
01619 {
01620 dev_t device;
01621
QString mountPoint;
01622 MountState isautofs;
01623 MountState isslow;
01624 MountState ismanual;
01625
QString fstype;
01626 };
01627
static struct cachedDevice_t *cachedDevice = 0;
01628
01629
if (!gotRoot)
01630 {
01631 KDE_struct_stat stat_buf;
01632 KDE_stat(
"/", &stat_buf);
01633 gotRoot =
true;
01634 rootDevice = stat_buf.st_dev;
01635 }
01636
01637
bool gotDevice =
false;
01638 KDE_struct_stat stat_buf;
01639
if (KDE_stat(QFile::encodeName(filename), &stat_buf) == 0)
01640 {
01641 gotDevice =
true;
01642
if (stat_buf.st_dev == rootDevice)
01643 {
01644
static const QString &root =
KGlobal::staticQString(
"/");
01645 isautofs = Wrong;
01646 isslow = Wrong;
01647 ismanual = Wrong;
01648 fstype = QString::null;
01649
return root;
01650 }
01651
if (cachedDevice && (stat_buf.st_dev == cachedDevice->device))
01652 {
01653
bool interestedInIsManual = ismanual != Wrong;
01654 isautofs = cachedDevice->isautofs;
01655 isslow = cachedDevice->isslow;
01656 ismanual = cachedDevice->ismanual;
01657 fstype = cachedDevice->fstype;
01658
01659
if ( !interestedInIsManual || ismanual != Unseen )
01660
return cachedDevice->mountPoint;
01661 }
01662 }
01663
01664
char realname[MAXPATHLEN];
01665
01666 memset(realname, 0, MAXPATHLEN);
01667
01668
01669
if (realpath(QFile::encodeName(filename), realname) == 0) {
01670
if( strlcpy(realname, QFile::encodeName(filename), MAXPATHLEN)>=MAXPATHLEN)
01671
return QString::null;
01672 }
01673
01674
int max = 0;
01675
QString mountPoint;
01676
01677
01678
01679
01680
01681
01682
01683
01684
01685
01686
01687
#ifdef HAVE_GETMNTINFO
01688
01689
struct statfs *mounted;
01690
char realpath_buffer[MAXPATHLEN];
01691
01692
int num_fs = getmntinfo(&mounted, MNT_NOWAIT);
01693
01694
for (
int i=0;i<num_fs;i++) {
01695
01696
QCString device_name = mounted[i].f_mntfromname;
01697
01698
01699
01700
if (realpath(device_name, realpath_buffer) != 0)
01701
01702 device_name = realpath_buffer;
01703
#ifdef __osf__
01704
char * mounttype = mnt_names[mounted[i].f_type];
01705
#else
01706
char * mounttype = mounted[i].f_fstypename;
01707
#endif
01708
if ( is_my_mountpoint( mounted[i].f_mntonname, realname, max ) )
01709 {
01710 mountPoint = QFile::decodeName(mounted[i].f_mntonname);
01711 fstype = QString::fromLatin1(mounttype);
01712 check_mount_point( mounttype, mounted[i].f_mntfromname,
01713 isautofs, isslow );
01714
01715
01716
if (ismanual == Unseen)
01717 {
01718
struct fstab *ft = getfsfile(mounted[i].f_mntonname);
01719
if (!ft || strstr(ft->fs_mntops,
"noauto"))
01720 ismanual = Right;
01721 }
01722 }
01723 }
01724
01725
#elif defined(_AIX)
01726
01727
struct vmount *mntctl_buffer;
01728
struct vmount *vm;
01729
char *mountedfrom;
01730
char *mountedto;
01731
int fsname_len, num;
01732
char realpath_buffer[MAXPATHLEN];
01733
int buf_sz = 4096;
01734
01735 mntctl_buffer = (
struct vmount*)malloc(buf_sz);
01736 num = mntctl(MCTL_QUERY, buf_sz, mntctl_buffer);
01737
if (num == 0)
01738 {
01739 buf_sz = *(
int*)mntctl_buffer;
01740 free(mntctl_buffer);
01741 mntctl_buffer = (
struct vmount*)malloc(buf_sz);
01742 num = mntctl(MCTL_QUERY, buf_sz, mntctl_buffer);
01743 }
01744
01745
if (num > 0)
01746 {
01747
01748 vm = (
struct vmount *)mntctl_buffer;
01749
for ( ; num > 0; num-- )
01750 {
01751
01752 fsname_len = vmt2datasize(vm, VMT_STUB);
01753 mountedto = (
char*)malloc(fsname_len + 1);
01754 mountedto[fsname_len] =
'\0';
01755 strncpy(mountedto, (
char *)vmt2dataptr(vm, VMT_STUB), fsname_len);
01756
01757 fsname_len = vmt2datasize(vm, VMT_OBJECT);
01758 mountedfrom = (
char*)malloc(fsname_len + 1);
01759 mountedfrom[fsname_len] =
'\0';
01760 strncpy(mountedfrom, (
char *)vmt2dataptr(vm, VMT_OBJECT), fsname_len);
01761
01762
01763
QCString device_name = mountedfrom;
01764
01765
if (realpath(device_name, realpath_buffer) != 0)
01766
01767 device_name = realpath_buffer;
01768
01769
01770
01771
01772
01773
struct vfs_ent* ent = getvfsbytype(vm->vmt_gfstype);
01774
01775
if ( is_my_mountpoint( mountedto, realname, max ) )
01776 {
01777 mountPoint = QFile::decodeName(mountedto);
01778 fstype = QString::fromLatin1(ent->vfsent_name);
01779 check_mount_point(ent->vfsent_name, device_name, isautofs, isslow);
01780
01781
if (ismanual == Unseen)
01782 {
01783
01784
01785 ismanual == Wrong;
01786 }
01787 }
01788
01789 free(mountedfrom);
01790 free(mountedto);
01791
01792
01793 vm = (
struct vmount *)((
char *)vm + vm->vmt_length);
01794 }
01795
01796 endvfsent( );
01797 }
01798
01799 free( mntctl_buffer );
01800
01801
#else
01802
01803 STRUCT_SETMNTENT mtab;
01804
01805
01806
if ((mtab = SETMNTENT(MNTTAB,
"r")) == 0) {
01807
perror(
"setmntent");
01808
return QString::null;
01809 }
01810
01811 STRUCT_MNTENT me;
01812
01813
while (
true) {
01814
if (!GETMNTENT(mtab, me))
01815
break;
01816
01817
if ( is_my_mountpoint( MOUNTPOINT(me), realname, max ) )
01818 {
01819 mountPoint = QFile::decodeName( MOUNTPOINT(me) );
01820 fstype = MOUNTTYPE(me);
01821 check_mount_point(MOUNTTYPE(me), FSNAME(me), isautofs, isslow);
01822
01823
01824
if (ismanual == Unseen)
01825 {
01826
01827
01828
QCString fsname_me = FSNAME(me);
01829
QCString mounttype_me = MOUNTTYPE(me);
01830
01831 STRUCT_SETMNTENT fstab;
01832
if ((fstab = SETMNTENT(FSTAB,
"r")) == 0) {
01833
continue;
01834 }
01835
01836
bool found =
false;
01837 STRUCT_MNTENT fe;
01838
while (GETMNTENT(fstab, fe))
01839 {
01840
if (fsname_me == FSNAME(fe))
01841 {
01842 found =
true;
01843
if (HASMNTOPT(fe,
"noauto") ||
01844 !strcmp(MOUNTTYPE(fe),
"supermount"))
01845 ismanual = Right;
01846
break;
01847 }
01848 }
01849
if (!found || (mounttype_me ==
"supermount"))
01850 ismanual = Right;
01851
01852 ENDMNTENT(fstab);
01853 }
01854 }
01855 }
01856
01857 ENDMNTENT(mtab);
01858
01859
#endif
01860
01861
if (isautofs == Right && isslow == Unseen)
01862 isslow = Right;
01863
01864
if (gotDevice)
01865 {
01866
if (!cachedDevice)
01867 cachedDevice =
new cachedDevice_t;
01868
01869 cachedDevice->device = stat_buf.st_dev;
01870 cachedDevice->mountPoint = mountPoint;
01871 cachedDevice->isautofs = isautofs;
01872 cachedDevice->isslow = isslow;
01873 cachedDevice->ismanual = ismanual;
01874 cachedDevice->fstype = fstype;
01875 }
01876
01877
return mountPoint;
01878 }
01879
01880
#else
01881
//dummy
01882 QString KIO::findDeviceMountPoint(
const QString& filename )
01883 {
01884
return QString::null;
01885 }
01886
#endif
01887
01888 QString KIO::findPathMountPoint(
const QString& filename)
01889 {
01890
#ifdef Q_OS_UNIX
01891
MountState isautofs = Unseen, isslow = Unseen, ismanual = Wrong;
01892
QString fstype;
01893
return get_mount_info(filename, isautofs, isslow, ismanual, fstype);
01894
#else
01895
return QString::null;
01896
#endif
01897
}
01898
01899 bool KIO::manually_mounted(
const QString& filename)
01900 {
01901
#ifdef Q_OS_UNIX
01902
MountState isautofs = Unseen, isslow = Unseen, ismanual = Unseen;
01903
QString fstype;
01904
QString mountPoint = get_mount_info(filename, isautofs, isslow, ismanual, fstype);
01905
return !mountPoint.isNull() && (ismanual == Right);
01906
#else
01907
return false;
01908
#endif
01909
}
01910
01911 bool KIO::probably_slow_mounted(
const QString& filename)
01912 {
01913
#ifdef Q_OS_UNIX
01914
MountState isautofs = Unseen, isslow = Unseen, ismanual = Wrong;
01915
QString fstype;
01916
QString mountPoint = get_mount_info(filename, isautofs, isslow, ismanual, fstype);
01917
return !mountPoint.isNull() && (isslow == Right);
01918
#else
01919
return false;
01920
#endif
01921
}
01922
01923 bool KIO::testFileSystemFlag(
const QString& filename, FileSystemFlag flag)
01924 {
01925
#ifdef Q_OS_UNIX
01926
MountState isautofs = Unseen, isslow = Unseen, ismanual = Wrong;
01927
QString fstype;
01928
QString mountPoint = get_mount_info(filename, isautofs, isslow, ismanual, fstype);
01929
kdDebug() <<
"testFileSystemFlag: fstype=" << fstype <<
endl;
01930
if (mountPoint.isNull())
01931
return false;
01932
bool isMsDos = ( fstype ==
"msdos" || fstype ==
"fat" || fstype ==
"vfat" );
01933
switch (flag) {
01934
case SupportsChmod:
01935
case SupportsChown:
01936
case SupportsUTime:
01937
case SupportsSymlinks:
01938
return !isMsDos;
01939
case CaseInsensitive:
01940
return isMsDos;
01941 }
01942
#endif
01943
return false;
01944 }
01945
01946 KIO::CacheControl
KIO::parseCacheControl(
const QString &cacheControl)
01947 {
01948
QString tmp = cacheControl.lower();
01949
01950
if (tmp ==
"cacheonly")
01951
return KIO::CC_CacheOnly;
01952
if (tmp ==
"cache")
01953
return KIO::CC_Cache;
01954
if (tmp ==
"verify")
01955
return KIO::CC_Verify;
01956
if (tmp ==
"refresh")
01957
return KIO::CC_Refresh;
01958
if (tmp ==
"reload")
01959
return KIO::CC_Reload;
01960
01961
kdDebug() <<
"unrecognized Cache control option:"<<cacheControl<<
endl;
01962
return KIO::CC_Verify;
01963 }
01964
01965 QString KIO::getCacheControlString(KIO::CacheControl cacheControl)
01966 {
01967
if (cacheControl == KIO::CC_CacheOnly)
01968
return "CacheOnly";
01969
if (cacheControl == KIO::CC_Cache)
01970
return "Cache";
01971
if (cacheControl == KIO::CC_Verify)
01972
return "Verify";
01973
if (cacheControl == KIO::CC_Refresh)
01974
return "Refresh";
01975
if (cacheControl == KIO::CC_Reload)
01976
return "Reload";
01977
kdDebug() <<
"unrecognized Cache control enum value:"<<cacheControl<<
endl;
01978
return QString::null;
01979 }