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