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