# kio Library API Documentation

Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Source Files

# global.cpp

    00001 /* This file is part of the KDE libraries
    00002    Copyright (C) 2000 David Faure <faure@kde.org>
    00003
    00004    $Id: global.cpp,v 1.101.2.6 2003/01/27 22:20:49 brade Exp $
    00005
    00006    This library is free software; you can redistribute it and/or
    00007    modify it under the terms of the GNU Library General Public
    00008    License version 2 as published by the Free Software Foundation.
    00009
    00010    This library is distributed in the hope that it will be useful,
    00011    but WITHOUT ANY WARRANTY; without even the implied warranty of
    00012    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00013    Library General Public License for more details.
    00014
    00015    You should have received a copy of the GNU Library General Public License
    00016    along with this library; see the file COPYING.LIB.  If not, write to
    00017    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    00018    Boston, MA 02111-1307, USA.
    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     // Giga-byte
    00051     if ( size >= 1073741824 )
    00052     {
    00053         fsize = (float) size / (float) 1073741824;
    00054         if ( fsize > 1024 ) // Tera-byte
    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     // Mega-byte
    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     // Kilo-byte
    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     // Just byte
    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)) // Limit to 23:59:59
    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 Directory", "%n Directories", 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' ) // %2f -> /
    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 //       result = i18n( "Unsupported action %1" ).arg( errorText );
    00208       break;
    00209     case  KIO::ERR_IS_DIRECTORY:
    00210       result = i18n( "%1 is a directory, but a file was expected." ).arg( errorText );
    00211       break;
    00212     case  KIO::ERR_IS_FILE:
    00213       result = i18n( "%1 is a file, but a directory was expected." ).arg( errorText );
    00214       break;
    00215     case  KIO::ERR_DOES_NOT_EXIST:
    00216       result = i18n( "The file or directory %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 directory named %1 already exists." ).arg( errorText );
    00223       break;
    00224     case  KIO::ERR_UNKNOWN_HOST:
    00225       result = 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 directory %1" ).arg( errorText );
    00235       break;
    00236     case  KIO::ERR_PROTOCOL_IS_NOT_A_FILESYSTEM:
    00237       result = i18n( "The protocol %1 does not implement a directory 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       // Do nothing in this case. The user doesn't need to be told what he just did.
    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 directory %1" ).arg( errorText );
    00292       break;
    00293     case  KIO::ERR_COULD_NOT_RMDIR:
    00294       result = i18n( "Could not remove directory %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     case  KIO::ERR_CHECKSUM_MISMATCH:
    00337       if (errorText)
    00338         result = i18n( "Warning: MD5 Checksum for %1 does not match checksum returned from server" ).arg(errorText);
    00339       else
    00340         result = i18n( "Warning: MD5 Checksum for %1 does not match checksum returned from server" ).arg("document");
    00341       break;
    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 QStringList KIO::Job::detailedErrorStrings( const KURL *reqUrl /*= 0L*/,
    00384                                             int method /*= -1*/ ) const
    00385 {
    00386   QString errorName, techName, description, ret2;
    00387   QStringList causes, solutions, ret;
    00388
    00389   QByteArray raw = rawErrorDetail( m_error, m_errorText, reqUrl, method );
    00390   QDataStream stream(raw, IO_ReadOnly);
    00391
    00392   stream >> errorName >> techName >> description >> causes >> solutions;
    00393
    00394   QString url, protocol, datetime;
    00395   if ( reqUrl ) {
    00396     url = reqUrl->htmlURL();
    00397     protocol = reqUrl->protocol();
    00398   } else {
    00399     url = i18n( "(unknown)" );
    00400   }
    00401
    00402   datetime = KGlobal::locale()->formatDateTime( QDateTime::currentDateTime(),
    00403                                                 false );
    00404
    00405   ret << errorName;
    00406   ret << QString::fromLatin1( "<qt><p><b>" ) + errorName +
    00407          QString::fromLatin1( "</b></p><p>" ) + description +
    00408          QString::fromLatin1( "</p>" );
    00409   ret2 = QString::fromLatin1( "<qt><p>" );
    00410   if ( techName != QString::null )
    00411     ret2 += i18n( "<b>Technical Reason</b>: " ) + techName + QString::fromLatin1( "</p>" );
    00412   ret2 += i18n( "</p><p><b>Details of the Request</b>:" );
    00413   ret2 += i18n( "</p><ul><li>URL: %1</li>" ).arg( url );
    00414   if ( protocol != QString::null ) {
    00415     ret2 += i18n( "<li>Protocol: %1</li>" ).arg( protocol );
    00416   }
    00417   ret2 += i18n( "<li>Date and Time: %1</li>" ).arg( datetime );
    00418   ret2 += i18n( "<li>Additional Information: %1</li></ul>" ).arg( m_errorText );
    00419   if ( causes.count() ) {
    00420     ret2 += i18n( "<p><b>Possible Causes</b>:</p><ul><li>" );
    00421     ret2 += causes.join( "</li><li>" );
    00422     ret2 += QString::fromLatin1( "</li></ul>" );
    00423   }
    00424   if ( solutions.count() ) {
    00425     ret2 += i18n( "<p><b>Possible Solutions</b>:</p><ul><li>" );
    00426     ret2 += solutions.join( "</li><li>" );
    00427     ret2 += QString::fromLatin1( "</li></ul>" );
    00428   }
    00429   ret << ret2;
    00430   return ret;
    00431 }
    00432
    00433 QByteArray KIO::rawErrorDetail(int errorCode, const QString &errorText,
    00434                                const KURL *reqUrl /*= 0L*/, int /*method = -1*/ )
    00435 {
    00436   QString url, host, protocol, datetime, domain, path, dir, filename;
    00437   bool isSlaveNetwork = false;
    00438   if ( reqUrl ) {
    00439     url = reqUrl->prettyURL();
    00440     host = reqUrl->host();
    00441     protocol = reqUrl->protocol();
    00442
    00443     if ( host.left(4) == "www." )
    00444       domain = host.mid(4);
    00445     else
    00446       domain = host;
    00447
    00448     path = reqUrl->path(1);
    00449     filename = reqUrl->filename();
    00450     dir =  path + filename;
    00451
    00452     // detect if protocol is a network protocol...
    00453     // add your hacks here...
    00454     if ( protocol == "http" ||
    00455          protocol == "https" ||
    00456          protocol == "ftp" ||
    00457          protocol == "sftp" ||
    00458          protocol == "webdav" ||
    00459          protocol == "webdavs" ||
    00460          protocol == "finger" ||
    00461          protocol == "fish" ||
    00462          protocol == "gopher" ||
    00463          protocol == "imap" ||
    00464          protocol == "imaps" ||
    00465          protocol == "lan" ||
    00466          protocol == "ldap" ||
    00467          protocol == "mailto" ||
    00468          protocol == "news" ||
    00469          protocol == "nntp" ||
    00470          protocol == "pop3" ||
    00471          protocol == "pop3s" ||
    00472          protocol == "smtp" ||
    00473          protocol == "smtps" ||
    00474          protocol == "telnet"
    00475         ) {
    00476       isSlaveNetwork = false;
    00477     }
    00478   } else {
    00479     // assume that the errorText has the location we are interested in
    00480     url = host = domain = path = filename = dir = errorText;
    00481     protocol = i18n( "(unknown)" );
    00482   }
    00483
    00484   datetime = KGlobal::locale()->formatDateTime( QDateTime::currentDateTime(),
    00485                                                 false );
    00486
    00487   QString errorName, techName, description;
    00488   QStringList causes, solutions;
    00489
    00490   // c == cause, s == solution
    00491   QString sSysadmin = i18n( "Contact your appropriate computer support system, "
    00492     "whether the system administrator, or technical support group for further "
    00493     "assistance." );
    00494   QString sServeradmin = i18n( "Contact the administrator of the server "
    00495     "for further assistance." );
    00496   // FIXME active link to permissions dialog
    00497   QString sAccess = i18n( "Check your access permissions on this resource." );
    00498   QString cAccess = i18n( "Your access permissions may be inadequate to "
    00499     "perform the requested operation on this resource." );
    00500   QString cLocked = i18n( "The file may be in use (and thus locked) by "
    00501     "another user or application." );
    00502   QString sQuerylock = i18n( "Check to make sure that no other "
    00503     "application or user is using the file or has locked the file." );
    00504   QString cHardware = i18n( "Although unlikely, a hardware error may have "
    00505     "occurred." );
    00506   QString cBug = i18n( "You may have encountered a bug in the program." );
    00507   QString cBuglikely = i18n( "This is most likely to be caused by a bug in the "
    00508     "program. Please consider submitting a full bug report as detailed below." );
    00509   QString sUpdate = i18n( "Update your software to the latest version. "
    00510     "Your distribution should provide tools to update your software." );
    00511   QString sBugreport = i18n( "When all else fails, please consider helping the "
    00512     "KDE team or the third party maintainer of this software by submitting a "
    00513     "high quality bug report. If the software is provided by a third party, "
    00514     "please contact them directly. Otherwise, first look to see if "
    00515     "the same bug has been submitted by someone else by searching at the "
    00516     "<a href=\"http://bugs.kde.org/\">KDE bug reporting website</a>. If not, take "
    00517     "note of the details given above, and include them in your bug report, along "
    00518     "with as many other details as you think might help." );
    00519   QString cNetwork = i18n( "There may have been a problem with your network "
    00520     "connection." );
    00521   // FIXME netconf kcontrol link
    00522   QString cNetconf = i18n( "There may have been a problem with your network "
    00523     "configuration. If you have been accessing the Internet with no problems "
    00524     "recently, this is unlikely." );
    00525   QString cNetpath = i18n( "There may have been a problem at some point along "
    00526     "the network path between the server and this computer." );
    00527   QString sTryagain = i18n( "Try again, either now or at a later time." );
    00528   QString cProtocol = i18n( "A protocol error or incompatibility may have occurred." );
    00529   QString sExists = i18n( "Ensure that the resource exists, and try again." );
    00530   QString cExists = i18n( "The specified resource may not exist." );
    00531   QString cTypo = i18n( "You may have incorrectly typed the location." );
    00532   QString sTypo = i18n( "Double-check that you have entered the correct location "
    00533     "and try again." );
    00534   QString sNetwork = i18n( "Check your network connection status." );
    00535
    00536   switch( errorCode ) {
    00537     case  KIO::ERR_CANNOT_OPEN_FOR_READING:
    00538       errorName = i18n( "Cannot Open Resource For Reading" );
    00539       description = i18n( "This means that the contents of the requested file "
    00540         "or directory <strong>%1</strong> could not be retrieved, as read "
    00541         "access could not be obtained." ).arg( dir );
    00542       causes << i18n( "You may not have permissions to read the file or open "
    00543         "the directory.") << cLocked << cHardware;
    00544       solutions << sAccess << sQuerylock << sSysadmin;
    00545       break;
    00546
    00547     case  KIO::ERR_CANNOT_OPEN_FOR_WRITING:
    00548       errorName = i18n( "Cannot Open Resource For Writing" );
    00549       description = i18n( "This means that the file, <strong>%1</strong>, could "
    00550         "not be written to as requested, because access with permission to "
    00551         "write could not be obtained." ).arg( filename );
    00552       causes << cAccess << cLocked << cHardware;
    00553       solutions << sAccess << sQuerylock << sSysadmin;
    00554       break;
    00555
    00556     case  KIO::ERR_CANNOT_LAUNCH_PROCESS:
    00557       errorName = i18n( "Cannot Initiate the %1 Protocol" ).arg( protocol );
    00558       techName = i18n( "Unable to Launch Process" );
    00559       description = i18n( "The program on your computer which provides access "
    00560         "to the <strong>%1</strong> protocol could not be started. This is "
    00561         "usually due to technical reasons." ).arg( protocol );
    00562       causes << i18n( "The program which provides compatibility with this "
    00563         "protocol may not have been updated with your last update of KDE. "
    00564         "This can cause the program to be incompatible with the current version "
    00565         "and thus not start." ) << cBug;
    00566       solutions << sUpdate << sSysadmin;
    00567       break;
    00568
    00569     case  KIO::ERR_INTERNAL:
    00570       errorName = i18n( "Internal Error" );
    00571       description = i18n( "The program on your computer which provides access "
    00572         "to the <strong>%1</strong> protocol has reported an internal error." )
    00573         .arg( protocol );
    00574       causes << cBuglikely;
    00575       solutions << sUpdate << sBugreport;
    00576       break;
    00577
    00578     case  KIO::ERR_MALFORMED_URL:
    00579       errorName = i18n( "Inproperly Formatted URL" );
    00580       description = i18n( "The <strong>U</strong>niform <strong>R</strong>esource "
    00581         "<strong>L</strong>ocator (URL) that you entered was not properly "
    00582         "formatted. The format of a URL is generally as follows:"
    00583         "<blockquote><strong>protocol://user:password@www.example.org:port/directory/"
    00584         "filename.extension?query=value</strong></blockquote>" );
    00585       solutions << sTypo;
    00586       break;
    00587
    00588     case  KIO::ERR_UNSUPPORTED_PROTOCOL:
    00589       errorName = i18n( "Unsupported Protocol %1" ).arg( protocol );
    00590       description = i18n( "The protocol <strong>%1</strong> is not supported "
    00591         "by the KDE programs currently installed on this computer." )
    00592         .arg( protocol );
    00593       causes << i18n( "The requested protocol may not be supported." )
    00594         << i18n( "The versions of the %1 protocol supported by this computer and "
    00595         "the server may be incompatible." ).arg( protocol );
    00596       solutions << i18n( "You may perform a search on the Internet for a KDE "
    00597         "program (called a kioslave or ioslave) which supports this protocol. "
    00598         "Places to search include <a href=\"http://apps.kde.com/\">"
    00599         "http://apps.kde.com/</a> and <a href=\"http://freshmeat.net/\">"
    00600         "http://freshmeat.net/</a>." )
    00601         << sUpdate << sSysadmin;
    00602       break;
    00603
    00604     case  KIO::ERR_NO_SOURCE_PROTOCOL:
    00605       errorName = i18n( "URL Does Not Refer to a Resource." );
    00606       techName = i18n( "Protocol is a Filter Protocol" );
    00607       description = i18n( "The <strong>U</strong>niform <strong>R</strong>esource "
    00608         "<strong>L</strong>ocator (URL) that you entered did not refer to a "
    00609         "specific resource." );
    00610       causes << i18n( "KDE is able to communicate through a protocol within a "
    00611         "protocol; the protocol specified is only for use in such situations, "
    00612         "however this is not one of these situations. This is a rare event, and "
    00613         "is likely to indicate a programming error." );
    00614       solutions << sTypo;
    00615       break;
    00616
    00617     case  KIO::ERR_UNSUPPORTED_ACTION:
    00618       errorName = i18n( "Unsupported Action: %1" ).arg( errorText );
    00619       description = i18n( "The requested action is not supported by the KDE "
    00620         "program which is implementing the <strong>%1</strong> protocol." )
    00621         .arg( protocol );
    00622       causes << i18n( "This error is very much dependent on the KDE program. The "
    00623         "additional information should give you more information than is available "
    00624         "to the KDE input/output architecture." );
    00625       solutions << i18n( "Attempt to find another way to accomplish the same "
    00626         "outcome." );
    00627       break;
    00628
    00629     case  KIO::ERR_IS_DIRECTORY:
    00630       errorName = i18n( "File Expected" );
    00631       description = i18n( "The request expected a file, however the "
    00632         "directory <strong>%1</strong> was found instead." ).arg( dir );
    00633       causes << i18n( "This may be an error on the server side." ) << cBug;
    00634       solutions << sUpdate << sSysadmin;
    00635       break;
    00636
    00637     case  KIO::ERR_IS_FILE:
    00638       errorName = i18n( "Directory Expected" );
    00639       description = i18n( "The request expected a directory, however "
    00640         "the file <strong>%1</strong> was found instead." ).arg( filename );
    00641       causes << cBug;
    00642       solutions << sUpdate << sSysadmin;
    00643       break;
    00644
    00645     case  KIO::ERR_DOES_NOT_EXIST:
    00646       errorName = i18n( "File or Directory Does Not Exist" );
    00647       description = i18n( "The specified file or directory <strong>%1</strong> "
    00648         "does not exist." ).arg( dir );
    00649       causes << cBug;
    00650       solutions << sUpdate << sSysadmin;
    00651       break;
    00652
    00653     case  KIO::ERR_FILE_ALREADY_EXIST:
    00654       errorName = i18n( "File Already Exists" );
    00655       description = i18n( "The requested file could not be created because a "
    00656         "file with the same name already exists." );
    00657       solutions << i18n ( "Try moving the current file out of the way first, "
    00658         "and then try again." )
    00659         << i18n ( "Delete the current file and try again." )
    00660         << i18n( "Choose an alternate filename for the new file." );
    00661       break;
    00662
    00663     case  KIO::ERR_DIR_ALREADY_EXIST:
    00664       errorName = i18n( "Directory Already Exists" );
    00665       description = i18n( "The requested directory could not be created because "
    00666         "a directory with the same name already exists." );
    00667       solutions << i18n( "Try moving the current directory out of the way first, "
    00668         "and then try again." )
    00669         << i18n( "Delete the current directory and try again." )
    00670         << i18n( "Choose an alternate name for the new directory." );
    00671       break;
    00672
    00673     case  KIO::ERR_UNKNOWN_HOST:
    00674       errorName = i18n( "Unknown Host" );
    00675       description = i18n( "An unknown host error indicates that the server with "
    00676         "the requested name, <strong>%1</strong>, could not be "
    00677         "located on the Internet." ).arg( host );
    00678       causes << i18n( "The name that you typed, %1, may not exist: it may be "
    00679         "incorrectly typed." ).arg( host )
    00680         << cNetwork << cNetconf;
    00681       solutions << sNetwork << sSysadmin;
    00682       break;
    00683
    00684     case  KIO::ERR_ACCESS_DENIED:
    00685       errorName = i18n( "Access Denied" );
    00686       description = i18n( "Access was denied to the specified resource, "
    00687         "<strong>%1</strong>." ).arg( url );
    00688       causes << i18n( "You may have supplied incorrect authentication details or "
    00689         "none at all." )
    00690         << i18n( "Your account may not have permission to access the "
    00691         "specified resource." );
    00692       solutions << i18n( "Retry the request and ensure your authentication details "
    00693         "are entered correctly." ) << sSysadmin;
    00694       if ( !isSlaveNetwork ) solutions << sServeradmin;
    00695       break;
    00696
    00697     case  KIO::ERR_WRITE_ACCESS_DENIED:
    00698       errorName = i18n( "Write Access Denied" );
    00699       description = i18n( "This means that an attempt to write to the file "
    00700         "<strong>%1</strong> was rejected." ).arg( filename );
    00701       causes << cAccess << cLocked << cHardware;
    00702       solutions << sAccess << sQuerylock << sSysadmin;
    00703       break;
    00704
    00705     case  KIO::ERR_CANNOT_ENTER_DIRECTORY:
    00706       errorName = i18n( "Unable to Enter Directory" );
    00707       description = i18n( "This means that an attempt to enter (in other words, "
    00708         "to open) the requested directory <strong>%1</strong> was rejected." )
    00709         .arg( dir );
    00710       causes << cAccess << cLocked;
    00711       solutions << sAccess << sQuerylock << sSysadmin;
    00712       break;
    00713
    00714     case  KIO::ERR_PROTOCOL_IS_NOT_A_FILESYSTEM:
    00715       errorName = i18n( "Directory Listing Unavailable" );
    00716       techName = i18n( "Protocol %1 is not a Filesystem" ).arg( protocol );
    00717       description = i18n( "This means that a request was made which requires "
    00718         "determining the contents of the directory, and the KDE program supporting "
    00719         "this protocol is unable to do so." );
    00720       causes << cBug;
    00721       solutions << sUpdate << sBugreport;
    00722       break;
    00723
    00724     case  KIO::ERR_CYCLIC_LINK:
    00725       errorName = i18n( "Cyclic Link Detected" );
    00726       description = i18n( "UNIX environments are commonly able to link a file or "
    00727         "directory to a separate name and/or location. KDE detected a link or "
    00728         "series of links that results in an infinite loop - i.e. the file was "
    00729         "(perhaps in a roundabout way) linked to itself." );
    00730       solutions << i18n( "Delete one part of the loop in order that it does not "
    00731         "cause an infinite loop, and try again." ) << sSysadmin;
    00732       break;
    00733
    00734     case  KIO::ERR_USER_CANCELED:
    00735       // Do nothing in this case. The user doesn't need to be told what he just did.
    00736       // rodda: However, if we have been called, an application is about to display
    00737       // this information anyway. If we don't return sensible information, the
    00738       // user sees a blank dialog (I have seen this myself)
    00739       errorName = i18n( "Request Aborted By User" );
    00740       description = i18n( "The request was not completed because it was "
    00741         "aborted." );
    00742       solutions << i18n( "Retry the request." );
    00743       break;
    00744
    00745     case  KIO::ERR_CYCLIC_COPY:
    00746       errorName = i18n( "Cyclic Link Detected During Copy" );
    00747       description = i18n( "UNIX environments are commonly able to link a file or "
    00748         "directory to a separate name and/or location. During the requested copy "
    00749         "operation, KDE detected a link or series of links that results in an "
    00750         "infinite loop - i.e. the file was (perhaps in a roundabout way) linked "
    00751         "to itself." );
    00752       solutions << i18n( "Delete one part of the loop in order that it does not "
    00753         "cause an infinite loop, and try again." ) << sSysadmin;
    00754       break;
    00755
    00756     case  KIO::ERR_COULD_NOT_CREATE_SOCKET:
    00757       errorName = i18n( "Could Not Create Network Connection" );
    00758       techName = i18n( "Could Not Create Socket" );
    00759       description = i18n( "This is a fairly technical error in which a required "
    00760         "device for network communications (a socket) could not be created." );
    00761       causes << i18n( "The network connection may be incorrectly configured, or "
    00762         "the network interface may not be enabled." );
    00763       solutions << sNetwork << sSysadmin;
    00764       break;
    00765
    00766     case  KIO::ERR_COULD_NOT_CONNECT:
    00767       errorName = i18n( "Connection to Server Refused" );
    00768       description = i18n( "The server <strong>%1</strong> refused to allow this "
    00769         "computer to make a connection." ).arg( host );
    00770       causes << i18n( "The server, while currently connected to the Internet, "
    00771         "may not be configured to allow requests." )
    00772         << i18n( "The server, while currently connected to the Internet, "
    00773         "may not be running the requested service (%1)." ).arg( protocol )
    00774         << i18n( "A network firewall (a device which restricts Internet "
    00775         "requests), either protecting your network or the network of the server, "
    00776         "may have intervened, preventing this request." );
    00777       solutions << sTryagain << sServeradmin << sSysadmin;
    00778       break;
    00779
    00780     case  KIO::ERR_CONNECTION_BROKEN:
    00781       errorName = i18n( "Connection to Server Closed Unexpectedly" );
    00782       description = i18n( "Although a connection was established to "
    00783         "<strong>%1</strong>, the connection was closed at an unexpected point "
    00784         "in the communication." ).arg( host );
    00785       causes << cNetwork << cNetpath << i18n( "A protocol error may have occurred, "
    00786         "causing the server to close the connection as a response to the error." );
    00787       solutions << sTryagain << sServeradmin << sSysadmin;
    00788       break;
    00789
    00790     case  KIO::ERR_NOT_FILTER_PROTOCOL:
    00791       errorName = i18n( "URL Resource Invalid." );
    00792       techName = i18n( "Protocol %1 is not a Filter Protocol" ).arg( protocol );
    00793       description = i18n( "The <strong>U</strong>niform <strong>R</strong>esource "
    00794         "<strong>L</strong>ocator (URL) that you entered did not refer to "
    00795         "a valid mechanism of accessing the specific resource, "
    00796         "<strong>%1%2</strong>." )
    00797         .arg( host != QString::null ? host + '/' : QString::null ).arg( dir );
    00798       causes << i18n( "KDE is able to communicate through a protocol within a "
    00799         "protocol. This request specified a protocol be used as such, however "
    00800         "this protocol is not capable of such an action. This is a rare event, "
    00801         "and is likely to indicate a programming error." );
    00802       solutions << sTypo << sSysadmin;
    00803       break;
    00804
    00805     case  KIO::ERR_COULD_NOT_MOUNT:
    00806       errorName = i18n( "Unable to Initialize Input/Output Device" );
    00807       techName = i18n( "Could Not Mount Device" );
    00808       description = i18n( "The requested device could not be initialized "
    00809         "(\"mounted\"). The reported error was: <strong>%1</strong>" )
    00810         .arg( errorText );
    00811       causes << i18n( "The device may not be ready, for example there may be "
    00812         "no media in a removable media device (i.e. no CD-ROM in a CD drive), "
    00813         "or in the case of a peripheral/portable device, the device may not "
    00814         "be correctly connected." )
    00815         << i18n( "You may not have permissions to initialize (\"mount\") the "
    00816         "device. On UNIX systems, often system administrator privileges are "
    00817         "required to initialize a device." )
    00818         << cHardware;
    00819       solutions << i18n( "Check that the device is ready; removable drives "
    00820         "must contain media, and portable devices must be connected and powered "
    00821         "on.; and try again." ) << sAccess << sSysadmin;
    00822       break;
    00823
    00824     case  KIO::ERR_COULD_NOT_UNMOUNT:
    00825       errorName = i18n( "Unable to Uninitialize Input/Output Device" );
    00826       techName = i18n( "Could Not Unmount Device" );
    00827       description = i18n( "The requested device could not be uninitialized "
    00828         "(\"unmounted\"). The reported error was: <strong>%1</strong>" )
    00829         .arg( errorText );
    00830       causes << i18n( "The device may be busy, that is, still in use by "
    00831         "another application or user. Even such things as having an open "
    00832         "browser window on a location on this device may cause the device to "
    00833         "remain in use." )
    00834         << i18n( "You may not have permissions to uninitialize (\"unmount\") "
    00835         "the device. On UNIX systems, system administrator privileges are "
    00836         "often required to uninitialize a device." )
    00837         << cHardware;
    00838       solutions << i18n( "Check that no applications are accessing the device, "
    00839         "and try again." ) << sAccess << sSysadmin;
    00840       break;
    00841
    00842     case  KIO::ERR_COULD_NOT_READ:
    00843       errorName = i18n( "Cannot Read From Resource" );
    00844       description = i18n( "This means that although the resource, "
    00845         "<strong>%1</strong>, was able to be opened, an error occurred while "
    00846         "reading the contents of the resource." ).arg( url );
    00847       causes << i18n( "You may not have permissions to read from the resource." );
    00848       if ( !isSlaveNetwork ) causes << cNetwork;
    00849       causes << cHardware;
    00850       solutions << sAccess;
    00851       if ( !isSlaveNetwork ) solutions << sNetwork;
    00852       solutions << sSysadmin;
    00853       break;
    00854
    00855     case  KIO::ERR_COULD_NOT_WRITE:
    00856       errorName = i18n( "Cannot Write to Resource" );
    00857       description = i18n( "This means that although the resource, <strong>%1</strong>"
    00858         ", was able to be opened, an error occurred while writing to the resource." )
    00859         .arg( url );
    00860       causes << i18n( "You may not have permissions to write to the resource." );
    00861       if ( !isSlaveNetwork ) causes << cNetwork;
    00862       causes << cHardware;
    00863       solutions << sAccess;
    00864       if ( !isSlaveNetwork ) solutions << sNetwork;
    00865       solutions << sSysadmin;
    00866       break;
    00867
    00868     case  KIO::ERR_COULD_NOT_BIND:
    00869       errorName = i18n( "Could Not Listen for Network Connections" );
    00870       techName = i18n( "Could Not Bind" );
    00871       description = i18n( "This is a fairly technical error in which a required "
    00872         "device for network communications (a socket) could not be established "
    00873         "to listen for incoming network connections." );
    00874       causes << i18n( "The network connection may be incorrectly configured, or "
    00875         "the network interface may not be enabled." );
    00876       solutions << sNetwork << sSysadmin;
    00877       break;
    00878
    00879     case  KIO::ERR_COULD_NOT_LISTEN:
    00880       errorName = i18n( "Could Not Listen for Network Connections" );
    00881       techName = i18n( "Could Not Listen" );
    00882       description = i18n( "This is a fairly technical error in which a required "
    00883         "device for network communications (a socket) could not be established "
    00884         "to listen for incoming network connections." );
    00885       causes << i18n( "The network connection may be incorrectly configured, or "
    00886         "the network interface may not be enabled." );
    00887       solutions << sNetwork << sSysadmin;
    00888       break;
    00889
    00890     case  KIO::ERR_COULD_NOT_ACCEPT:
    00891       errorName = i18n( "Could Not Accept Network Connection" );
    00892       description = i18n( "This is a fairly technical error in which an error "
    00893         "occurred while attempting to accept an incoming network connection." );
    00894       causes << i18n( "The network connection may be incorrectly configured, or "
    00895         "the network interface may not be enabled." )
    00896         << i18n( "You may not have permissions to accept the connection." );
    00897       solutions << sNetwork << sSysadmin;
    00898       break;
    00899
    00900     case  KIO::ERR_COULD_NOT_LOGIN:
    00901       errorName = i18n( "Could Not Login: %1" ).arg( errorText );
    00902       description = i18n( "An attempt to login to perform the requested "
    00903         "operation was unsuccessful." );
    00904       causes << i18n( "You may have supplied incorrect authentication details or "
    00905         "none at all." )
    00906         << i18n( "Your account may not have permission to access the "
    00907         "specified resource." ) << cProtocol;
    00908       solutions << i18n( "Retry the request and ensure your authentication details "
    00909         "are entered correctly." ) << sServeradmin << sSysadmin;
    00910       break;
    00911
    00912     case  KIO::ERR_COULD_NOT_STAT:
    00913       errorName = i18n( "Could Not Determine Resource Status" );
    00914       techName = i18n( "Could Not Stat Resource" );
    00915       description = i18n( "An attempt to determine information about the status "
    00916         "of the resource <strong>%1</strong>, such as the resource name, type, "
    00917         "size, etc., was unsuccessful." ).arg( url );
    00918       causes << i18n( "The specified resource may not have existed or may "
    00919         "not be accessible." ) << cProtocol << cHardware;
    00920       solutions << i18n( "Retry the request and ensure your authentication details "
    00921         "are entered correctly." ) << sSysadmin;
    00922       break;
    00923
    00924     case  KIO::ERR_COULD_NOT_CLOSEDIR:
    00925       //result = i18n( "Could not terminate listing %1" ).arg( errorText );
    00926       errorName = i18n( "Could Not Cancel Listing" );
    00927       techName = i18n( "FIXME: Document this" );
    00928       break;
    00929
    00930     case  KIO::ERR_COULD_NOT_MKDIR:
    00931       errorName = i18n( "Could Not Create Directory" );
    00932       description = i18n( "An attempt to create the requested directory failed." );
    00933       causes << cAccess << i18n( "The location where the directory was to be created "
    00934         "may not exist." );
    00935       if ( !isSlaveNetwork ) causes << cProtocol;
    00936       solutions << i18n( "Retry the request." ) << sAccess;
    00937       break;
    00938
    00939     case  KIO::ERR_COULD_NOT_RMDIR:
    00940       errorName = i18n( "Could Not Remove Directory" );
    00941       description = i18n( "An attempt to remove the specified directory, "
    00942         "<strong>%1</strong>, failed." ).arg( dir );
    00943       causes << i18n( "The specified directory may not exist." )
    00944         << i18n( "The specified directory may not be empty." )
    00945         << cAccess;
    00946       if ( !isSlaveNetwork ) causes << cProtocol;
    00947       solutions << i18n( "Ensure that the directory exists and is empty, and try "
    00948         "again." ) << sAccess;
    00949       break;
    00950
    00951     case  KIO::ERR_CANNOT_RESUME:
    00952       errorName = i18n( "Could Not Resume File Transfer" );
    00953       description = i18n( "The specified request asked that the transfer of "
    00954         "file <strong>%1</strong> be resumed at a certain point of the "
    00955         "transfer. This was not possible." ).arg( filename );
    00956       causes << i18n( "The protocol, or the server, may not support file "
    00957         "resuming." );
    00958       solutions << i18n( "Retry the request without attempting to resume "
    00959         "transfer." );
    00960       break;
    00961
    00962     case  KIO::ERR_CANNOT_RENAME:
    00963       errorName = i18n( "Could Not Rename Resource" );
    00964       description = i18n( "An attempt to rename the specified resource "
    00965         "<strong>%1</strong> failed." ).arg( url );
    00966       causes << cAccess << cExists;
    00967       if ( !isSlaveNetwork ) causes << cProtocol;
    00968       solutions << sAccess << sExists;
    00969       break;
    00970
    00971     case  KIO::ERR_CANNOT_CHMOD:
    00972       errorName = i18n( "Could Not Alter Permissions of Resource" );
    00973       description = i18n( "An attempt to alter the permissions on the specified "
    00974         "resource <strong>%1</strong> failed." ).arg( url );
    00975       causes << cAccess << cExists;
    00976       solutions << sAccess << sExists;
    00977       break;
    00978
    00979     case  KIO::ERR_CANNOT_DELETE:
    00980       errorName = i18n( "Could Not Delete Resource" );
    00981       description = i18n( "An attempt to delete the specified resource "
    00982         "<strong>%1</strong> failed." ).arg( url );
    00983       causes << cAccess << cExists;
    00984       solutions << sAccess << sExists;
    00985       break;
    00986
    00987     case  KIO::ERR_SLAVE_DIED:
    00988       errorName = i18n( "Unexpected Program Termination" );
    00989       description = i18n( "The program on your computer which provides access "
    00990         "to the <strong>%1</strong> protocol has unexpectedly terminated." )
    00991         .arg( url );
    00992       causes << cBuglikely;
    00993       solutions << sUpdate << sBugreport;
    00994       break;
    00995
    00996     case  KIO::ERR_OUT_OF_MEMORY:
    00997       errorName = i18n( "Out Of Memory" );
    00998       description = i18n( "The program on your computer which provides access "
    00999         "to the <strong>%1</strong> protocol could not obtain the memory "
    01000         "required to continue." ).arg( protocol );
    01001       causes << cBuglikely;
    01002       solutions << sUpdate << sBugreport;
    01003       break;
    01004
    01005     case  KIO::ERR_UNKNOWN_PROXY_HOST:
    01006       errorName = i18n( "Unknown Proxy Host" );
    01007       description = i18n( "While retrieving information about the specified "
    01008         "proxy host, <strong>%1</strong>, an Unknown Host error was encountered. "
    01009         "An unknown host error indicates that the requested name could not be "
    01010         "located on the Internet." ).arg( errorText );
    01011       causes << i18n( "There may have been a problem with your network "
    01012         "configuration, specifically your proxy's hostname. If you have been "
    01013         "accessing the Internet with no problems recently, this is unlikely." )
    01014         << cNetwork;
    01015       solutions << i18n( "Double-check your proxy settings and try again." )
    01016         << sSysadmin;
    01017       break;
    01018
    01019     case  KIO::ERR_COULD_NOT_AUTHENTICATE:
    01020       errorName = i18n( "Authentication Failed: Method %1 Not Supported" )
    01021          .arg( errorText );
    01022       description = i18n( "Although you may have supplied the correct "
    01023         "authentication details, the authentication failed because the "
    01024         "method that the server is using is not supported by the KDE "
    01025         "program implementing the protocol %1." ).arg( protocol );
    01026       solutions << i18n( "Please file a bug at <a href=\"http://bugs.kde.org/\">"
    01027         "http://bugs.kde.org/</a> to inform the KDE team of the unsupported "
    01028         "authentication method." ) << sSysadmin;
    01029       break;
    01030
    01031     case  KIO::ERR_ABORTED:
    01032       errorName = i18n( "Request Aborted" );
    01033       description = i18n( "The request was not completed because it was "
    01034         "aborted." );
    01035       solutions << i18n( "Retry the request." );
    01036       break;
    01037
    01038     case  KIO::ERR_INTERNAL_SERVER:
    01039       errorName = i18n( "Internal Error in Server" );
    01040       description = i18n( "The program on the server which provides access "
    01041         "to the <strong>%1</strong> protocol has reported an internal error: "
    01042         "%0." ).arg( protocol );
    01043       causes << i18n( "This is most likely to be caused by a bug in the "
    01044         "server program. Please consider submitting a full bug report as "
    01045         "detailed below." );
    01046       solutions << i18n( "Contact the administrator of the server "
    01047         "to advise them of the problem." )
    01048         << i18n( "If you know who the authors of the server software are, "
    01049         "submit the bug report directly to them." );
    01050       break;
    01051
    01052     case  KIO::ERR_SERVER_TIMEOUT:
    01053       errorName = i18n( "Timeout Error" );
    01054       description = i18n( "Although contact was made with the server, a "
    01055         "response was not received within the amount of time allocated for "
    01056         "the request as follows:<ul>"
    01057         "<li>Timeout for establishing a connection: %1 seconds</li>"
    01058         "<li>Timeout for receiving a response: %2 seconds</li>"
    01059         "<li>Timeout for accessing proxy servers: %3 seconds</li></ul>"
    01060         "Please note that you can alter these timeout settings in the KDE "
    01061         "Control Center, by selecting Network -> Preferences." )
    01062         .arg( KProtocolManager::connectTimeout() )
    01063         .arg( KProtocolManager::responseTimeout() )
    01064         .arg( KProtocolManager::proxyConnectTimeout() );
    01065       causes << cNetpath << i18n( "The server was too busy responding to other "
    01066         "requests to respond." );
    01067       solutions << sTryagain << sServeradmin;
    01068       break;
    01069
    01070     case  KIO::ERR_UNKNOWN:
    01071       errorName = i18n( "Unknown Error" );
    01072       description = i18n( "The program on your computer which provides access "
    01073         "to the <strong>%1</strong> protocol has reported an unknown error: "
    01074         "%2." ).arg( protocol ).arg( errorText );
    01075       causes << cBug;
    01076       solutions << sUpdate << sBugreport;
    01077       break;
    01078
    01079     case  KIO::ERR_UNKNOWN_INTERRUPT:
    01080       errorName = i18n( "Unknown Interruption" );
    01081       description = i18n( "The program on your computer which provides access "
    01082         "to the <strong>%1</strong> protocol has reported an interruption of "
    01083         "an unknown type: %2." ).arg( protocol ).arg( errorText );
    01084       causes << cBug;
    01085       solutions << sUpdate << sBugreport;
    01086       break;
    01087
    01088     case KIO::ERR_CANNOT_DELETE_ORIGINAL:
    01089       errorName = i18n( "Could Not Delete Original File" );
    01090       description = i18n( "The requested operation required the deleting of "
    01091         "the original file, most likely at the end of a file move operation. "
    01092         "The original file <strong>%1</strong> could not be deleted." )
    01093         .arg( errorText );
    01094       causes << cAccess;
    01095       solutions << sAccess;
    01096       break;
    01097
    01098     case KIO::ERR_CANNOT_DELETE_PARTIAL:
    01099       errorName = i18n( "Could Not Delete Temporary File" );
    01100       description = i18n( "The requested operation required the creation of "
    01101         "a temporary file in which to save the new file while being "
    01102         "downloaded. This temporary file <strong>%1</strong> could not be "
    01103         "deleted." ).arg( errorText );
    01104       causes << cAccess;
    01105       solutions << sAccess;
    01106       break;
    01107
    01108     case KIO::ERR_CANNOT_RENAME_ORIGINAL:
    01109       errorName = i18n( "Could Not Rename Original File" );
    01110       description = i18n( "The requested operation required the renaming of "
    01111         "the original file <strong>%1</strong>, however it could not be "
    01112         "renamed." ).arg( errorText );
    01113       causes << cAccess;
    01114       solutions << sAccess;
    01115       break;
    01116
    01117     case KIO::ERR_CANNOT_RENAME_PARTIAL:
    01118       errorName = i18n( "Could Not Rename Temporary File" );
    01119       description = i18n( "The requested operation required the creation of "
    01120         "a temporary file <strong>%1</strong>, however it could not be "
    01121         "created." ).arg( errorText );
    01122       causes << cAccess;
    01123       solutions << sAccess;
    01124       break;
    01125
    01126     case KIO::ERR_CANNOT_SYMLINK:
    01127       errorName = i18n( "Could Not Create Link" );
    01128       techName = i18n( "Could Not Create Symbolic Link" );
    01129       description = i18n( "The requested symbolic link %1 could not be created." )
    01130         .arg( errorText );
    01131       causes << cAccess;
    01132       solutions << sAccess;
    01133       break;
    01134
    01135     case KIO::ERR_NO_CONTENT:
    01136       errorName = i18n( "No Content" );
    01137       description = errorText;
    01138       break;
    01139
    01140     case KIO::ERR_DISK_FULL:
    01141       errorName = i18n( "Disk Full" );
    01142       description = i18n( "The requested file <strong>%1</strong> could not be "
    01143         "written to as there is inadequate disk space." ).arg( errorText );
    01144       solutions << i18n( "Free up enough disk space by 1) deleting unwanted and "
    01145         "temporary files; 2) archiving files to removable media storage such as "
    01146         "CD-Recordable discs; or 3) obtain more storage capacity." )
    01147         << sSysadmin;
    01148       break;
    01149
    01150     case KIO::ERR_IDENTICAL_FILES:
    01151       errorName = i18n( "Source and Destination Files Identical" );
    01152       description = i18n( "The operation could not be completed because the "
    01153         "source and destination files are the same file." );
    01154       solutions << i18n( "Choose a different filename for the destination file." );
    01155       break;
    01156
    01157     default:
    01158       // fall back to the plain error...
    01159       errorName = i18n( "Undocumented Error" );
    01160       description = buildErrorString( errorCode, errorText );
    01161   }
    01162
    01163   QByteArray ret;
    01164   QDataStream stream(ret, IO_WriteOnly);
    01165   stream << errorName << techName << description << causes << solutions;
    01166   return ret;
    01167 }
    01168
    01169 #include <limits.h>
    01170 #include <stdlib.h>
    01171 #include <stdio.h>
    01172 #include <qfile.h>
    01173
    01174 #include <config.h>
    01175
    01176 #ifdef HAVE_PATHS_H
    01177 #include <paths.h>
    01178 #endif
    01179 #ifdef HAVE_SYS_STAT_H
    01180 #include <sys/stat.h>
    01181 #endif
    01182 #include <sys/param.h>
    01183 #ifdef HAVE_LIMITS_H
    01184 #include <limits.h>
    01185 #endif
    01186 #ifdef HAVE_SYS_MNTTAB_H
    01187 #include <sys/mnttab.h>
    01188 #endif
    01189 #ifdef HAVE_MNTENT_H
    01190 #include <mntent.h>
    01191 #endif
    01192 #ifdef HAVE_SYS_UCRED_H
    01193 #include <sys/ucred.h>
    01194 #endif
    01195 #ifdef HAVE_SYS_MOUNT_H
    01196 #include <sys/mount.h>
    01197 #endif
    01198 #ifdef HAVE_FSTAB_H
    01199 #include <fstab.h>
    01200 #endif
    01201 #if defined(_AIX)
    01202 #include <sys/mntctl.h>
    01203 #include <sys/vmount.h>
    01204 #include <sys/vfs.h>
    01205 /* AIX does not prototype mntctl anywhere that I can find */
    01206 #ifndef mntctl
    01207 extern "C" {
    01208 int mntctl(int command, int size, void* buffer);
    01209 }
    01210 #endif
    01211 extern "C" struct vfs_ent *getvfsbytype(int vfsType);
    01212 extern "C" void endvfsent( );
    01213 #endif
    01214
    01215 /***************************************************************
    01216  *
    01217  * Utility functions
    01218  *
    01219  ***************************************************************/
    01220
    01221 #ifndef HAVE_GETMNTINFO
    01222
    01223 #ifdef _PATH_MOUNTED
    01224 // On some Linux, MNTTAB points to /etc/fstab !
    01225 # undef MNTTAB
    01226 # define MNTTAB _PATH_MOUNTED
    01227 #else
    01228 # ifndef MNTTAB
    01229 #  ifdef MTAB_FILE
    01230 #   define MNTTAB MTAB_FILE
    01231 #  else
    01232 #   define MNTTAB "/etc/mnttab"
    01233 #  endif
    01234 # endif
    01235 #endif
    01236
    01237 // There are (at least) four kind of APIs:
    01238 // setmntent + getmntent + struct mntent (linux...)
    01239 //             getmntent + struct mnttab
    01240 // mntctl                + struct vmount (AIX)
    01241 // getmntinfo + struct statfs&flags (BSD 4.4 and friends)
    01242 // getfsent + char* (BSD 4.3 and friends)
    01243
    01244 #ifdef HAVE_SETMNTENT
    01245 #define SETMNTENT setmntent
    01246 #define ENDMNTENT endmntent
    01247 #define STRUCT_MNTENT struct mntent *
    01248 #define STRUCT_SETMNTENT FILE *
    01249 #define GETMNTENT(file, var) ((var = getmntent(file)) != 0)
    01250 #define MOUNTPOINT(var) var->mnt_dir
    01251 #define MOUNTTYPE(var) var->mnt_type
    01252 #define HASMNTOPT(var, opt) hasmntopt(var, opt)
    01253 #define FSNAME(var) var->mnt_fsname
    01254 #elif defined(_AIX)
    01255 /* we don't need this stuff */
    01256 #else
    01257 #define SETMNTENT fopen
    01258 #define ENDMNTENT fclose
    01259 #define STRUCT_MNTENT struct mnttab
    01260 #define STRUCT_SETMNTENT FILE *
    01261 #define GETMNTENT(file, var) (getmntent(file, &var) == 0)
    01262 #define MOUNTPOINT(var) var.mnt_mountp
    01263 #define MOUNTTYPE(var) var.mnt_fstype
    01264 #define HASMNTOPT(var, opt) hasmntopt(&var, opt)
    01265 #define FSNAME(var) var.mnt_special
    01266 #endif
    01267
    01268 #endif /* HAVE_GETMNTINFO */
    01269
    01270 QString KIO::findDeviceMountPoint( const QString& filename )
    01271 {
    01272     QString result;
    01273
    01274 #ifdef HAVE_VOLMGT
    01275         /*
    01276          *  support for Solaris volume management
    01277          */
    01278         const char *volpath;
    01279         FILE *mnttab;
    01280         struct mnttab mnt;
    01281         int len;
    01282         QCString devname;
    01283
    01284         if( (volpath = volmgt_root()) == NULL ) {
    01285                 kdDebug( 7007 ) << "findDeviceMountPoint: "
    01286                         << "VOLMGT: can't find volmgt root dir" << endl;
    01287                 return QString::null;
    01288         }
    01289
    01290         if( (mnttab = fopen( MNTTAB, "r" )) == NULL ) {
    01291                 kdDebug( 7007 ) << "findDeviceMountPoint: "
    01292                         << "VOLMGT: can't open mnttab" << endl;
    01293                 return QString::null;
    01294         }
    01295
    01296         devname = volpath;
    01297         devname += QFile::encodeName( filename );
    01298         devname += '/';
    01299         len = devname.length();
    01300 //      kdDebug( 7007 ) << "findDeviceMountPoint: "
    01301 //              << "VOLMGT: searching mountpoint for \"" << devname << "\""
    01302 //              << endl;
    01303
    01304         /*
    01305          *  find the mountpoint
    01306          *  floppies:
    01307          *      /dev/disketteN    => <volpath>/dev/disketteN
    01308          *  CDROM, ZIP, and other media:
    01309          *      /dev/dsk/cXtYdZs2 => <volpath>/dev/dsk/cXtYdZ  (without slice#)
    01310          */
    01311         rewind( mnttab );
    01312         result = QString::null;
    01313         while( getmntent( mnttab, &mnt ) == 0 ) {
    01314                 /*
    01315                  *  either match the exact device name (floppies),
    01316                  *  or the device name without the slice#
    01317                  */
    01318                 if( strncmp( devname.data(), mnt.mnt_special, len ) == 0
    01319                         || (strncmp( devname.data(), mnt.mnt_special, len - 3 ) == 0
    01320                                 && mnt.mnt_special[len - 3] == '/' )
    01321                         || (strcmp(QFile::encodeName(filename).data()
    01322                                         , mnt.mnt_special)==0)) {
    01323                         result = mnt.mnt_mountp;
    01324                         break;
    01325                 }
    01326         }
    01327         fclose( mnttab );
    01328         devname.~QCString();
    01329 #else
    01330
    01331     char    realpath_buffer[MAXPATHLEN];
    01332     QCString realname;
    01333
    01334     realname = QFile::encodeName(filename);
    01335     /* If the path contains symlinks, get the real name */
    01336     if (realpath(realname, realpath_buffer) != 0)
    01337       // succes, use result from realpath
    01338       realname = realpath_buffer;
    01339
    01340 #ifdef HAVE_GETMNTINFO
    01341
    01342     struct statfs *mounted;
    01343
    01344     int num_fs = getmntinfo(&mounted, MNT_NOWAIT);
    01345
    01346     for (int i=0;i<num_fs;i++) {
    01347
    01348         QCString device_name = mounted[i].f_mntfromname;
    01349
    01350         // If the path contains symlinks, get
    01351         // the real name
    01352         if (realpath(device_name, realpath_buffer) != 0)
    01353             // succes, use result from realpath
    01354             device_name = realpath_buffer;
    01355
    01356         if (realname == device_name) {
    01357             result = mounted[i].f_mntonname;
    01358             break;
    01359         }
    01360     }
    01361
    01362 #elif defined(_AIX)
    01363
    01364     struct vmount *mntctl_buffer;
    01365     struct vmount *vm;
    01366     char *mountedfrom;
    01367     char *mountedto;
    01368     int fsname_len, num;
    01369     int buf_sz = 4096;
    01370
    01371     /* mntctl can be used to query mounted file systems.
    01372      * mntctl takes only the command MCTL_QUERY so far.
    01373      * The buffer is filled with an array of vmount structures, but these
    01374      * vmount structures have variable size.
    01375      * mntctl return values:
    01376      * -1 error
    01377      *  0 look in first word of buffer for required bytes, 4096 may be
    01378      *    a good starting size, but if tables grow too large, look here.
    01379      * >0 number of vmount structures
    01380      */
    01381     mntctl_buffer = (struct vmount*)malloc(buf_sz);
    01382     num = mntctl(MCTL_QUERY, buf_sz, mntctl_buffer);
    01383     if (num == 0)
    01384     {
    01385         buf_sz = *(int*)mntctl_buffer;
    01386         free(mntctl_buffer);
    01387         mntctl_buffer = (struct vmount*)malloc(buf_sz);
    01388         num = mntctl(MCTL_QUERY, buf_sz, mntctl_buffer);
    01389     }
    01390
    01391     if (num > 0)
    01392     {
    01393         /* iterate through items in the vmount structure: */
    01394         vm = mntctl_buffer;
    01395         for ( ; num > 0; num-- )
    01396         {
    01397             /* get the name of the mounted file systems: */
    01398             fsname_len = vmt2datasize(vm, VMT_STUB);
    01399             mountedto     = (char*)malloc(fsname_len + 1);
    01400             mountedto[fsname_len] = '\0';
    01401             strncpy(mountedto, (char *)vmt2dataptr(vm, VMT_STUB), fsname_len);
    01402
    01403             /* get the mount-from information: */
    01404             fsname_len = vmt2datasize(vm, VMT_OBJECT);
    01405             mountedfrom     = (char*)malloc(fsname_len + 1);
    01406             mountedfrom[fsname_len] = '\0';
    01407             strncpy(mountedfrom, (char *)vmt2dataptr(vm, VMT_OBJECT), fsname_len);
    01408
    01409             QCString device_name = mountedfrom;
    01410
    01411             if (realpath(device_name, realpath_buffer) != 0)
    01412                 // success, use result from realpath
    01413                 device_name = realpath_buffer;
    01414
    01415             free(mountedfrom);
    01416
    01417             if (realname == device_name) {
    01418                 result = mountedto;
    01419                 free(mountedto);
    01420                 break;
    01421             }
    01422
    01423             free(mountedto);
    01424
    01425             /* goto the next vmount structure: */
    01426             vm = (struct vmount *)((char *)vm + vm->vmt_length);
    01427         }
    01428     }
    01429
    01430     free( mntctl_buffer );
    01431
    01432 #else
    01433
    01434     STRUCT_SETMNTENT mtab;
    01435
    01436     //kdDebug( 7007 ) << "realname " << realname << endl;
    01437
    01438     /* Get the list of mounted file systems */
    01439
    01440     if ((mtab = SETMNTENT(MNTTAB, "r")) == 0) {
    01441         perror("setmntent");
    01442         return QString::null;
    01443     }
    01444
    01445     /* Loop over all file systems and see if we can find our
    01446      * mount point.
    01447      * Note that this is the mount point with the longest match.
    01448      * XXX: Fails if me->mnt_dir is not a realpath but goes
    01449      * through a symlink, e.g. /foo/bar where /foo is a symlink
    01450      * pointing to /local/foo.
    01451      *
    01452      * How kinky can you get with a filesystem?
    01453      */
    01454
    01455     STRUCT_MNTENT me;
    01456
    01457     while (GETMNTENT(mtab, me))
    01458     {
    01459       // There may be symbolic links into the /etc/mnttab
    01460       // So we have to find the real device name here as well!
    01461       QCString device_name = FSNAME(me);
    01462
    01463       //kdDebug( 7007 ) << "device_name=" << device_name << endl;
    01464
    01465       // If the path contains symlinks, get
    01466       // the real name
    01467       if (realpath(device_name, realpath_buffer) != 0)
    01468           // succes, use result from realpath
    01469          device_name = realpath_buffer;
    01470
    01471       //kdDebug( 7007 ) << "device_name after realpath =" << device_name << endl;
    01472
    01473       if (realname == device_name)
    01474       {
    01475           result = MOUNTPOINT(me);
    01476           break;
    01477       }
    01478     }
    01479
    01480     ENDMNTENT(mtab);
    01481
    01482 #endif /* GET_MNTINFO */
    01483 #endif /* HAVE_VOLMGT */
    01484
    01485     //kdDebug( 7007 ) << "Returning result " << result << endl;
    01486     return result;
    01487 }
    01488
    01489 // Don't just trust the return value, keep iterating to check for a better match (bigger max)
    01490 static bool is_my_mountpoint( const char *mountpoint, const char *realname, int &max )
    01491 {
    01492     int length = strlen(mountpoint);
    01493
    01494     if (!strncmp(mountpoint, realname, length)
    01495         && length > max) {
    01496         max = length;
    01497         if (length == 1 || realname[length] == '/' || realname[length] == '\0')
    01498             return true;
    01499     }
    01500     return false;
    01501 }
    01502
    01503 typedef enum { Unseen, Right, Wrong } MountState;
    01504
    01508 static void check_mount_point(const char *mounttype,
    01509                               const char *fsname,
    01510                               MountState &isslow, MountState &isautofs)
    01511 {
    01512     bool nfs = !strcmp(mounttype, "nfs");
    01513     bool autofs = !strcmp(mounttype, "autofs");
    01514     bool pid = (strstr(fsname, ":(pid") != 0);
    01515
    01516     if (nfs && !pid)
    01517         isslow = Right;
    01518     else if (isslow == Right)
    01519         isslow = Wrong;
    01520
    01521     /* Does this look like automounted? */
    01522     if (autofs || (nfs && pid)) {
    01523         isautofs = Right;
    01524         isslow = Right;
    01525     }
    01526 }
    01527
    01528 // returns the mount point, checks the mount state.
    01529 // if ismanual == Wrong this function does not check the manual mount state
    01530 static QString get_mount_info(const QString& filename,
    01531     MountState& isautofs, MountState& isslow, MountState& ismanual)
    01532 {
    01533     char realname[MAXPATHLEN];
    01534
    01535     memset(realname, 0, MAXPATHLEN);
    01536
    01537     /* If the path contains symlinks, get the real name */
    01538     if (realpath(QFile::encodeName(filename), realname) == 0) {
    01539         if( strlcpy(realname, QFile::encodeName(filename),MAXPATHLEN)>=MAXPATHLEN)
    01540             return QString::null;
    01541     }
    01542
    01543     int max = 0;
    01544     QString mountPoint;
    01545
    01546     /* Loop over all file systems and see if we can find our
    01547      * mount point.
    01548      * Note that this is the mount point with the longest match.
    01549      * XXX: Fails if me->mnt_dir is not a realpath but goes
    01550      * through a symlink, e.g. /foo/bar where /foo is a symlink
    01551      * pointing to /local/foo.
    01552      *
    01553      * How kinky can you get with a filesystem?
    01554      */
    01555
    01556 #ifdef HAVE_GETMNTINFO
    01557
    01558     struct statfs *mounted;
    01559     char    realpath_buffer[MAXPATHLEN];
    01560
    01561     int num_fs = getmntinfo(&mounted, MNT_NOWAIT);
    01562
    01563     for (int i=0;i<num_fs;i++) {
    01564
    01565         QCString device_name = mounted[i].f_mntfromname;
    01566
    01567         // If the path contains symlinks, get
    01568         // the real name
    01569         if (realpath(device_name, realpath_buffer) != 0)
    01570             // succes, use result from realpath
    01571             device_name = realpath_buffer;
    01572 #ifdef __osf__
    01573         char * mounttype = mnt_names[mounted[i].f_type];
    01574 #else
    01575         char * mounttype = mounted[i].f_fstypename;
    01576 #endif
    01577         if ( is_my_mountpoint( mounted[i].f_mntonname, realname, max ) )
    01578         {
    01579             mountPoint = QFile::decodeName(mounted[i].f_mntonname);
    01580             check_mount_point( mounttype, mounted[i].f_mntfromname,
    01581                                isautofs, isslow );
    01582             // keep going, looking for a potentially better one
    01583
    01584             if (ismanual == Unseen)
    01585             {
    01586                 struct fstab *ft = getfsfile(mounted[i].f_mntonname);
    01587                 if (!ft || strstr(ft->fs_mntops, "noauto"))
    01588                   ismanual = Right;
    01589             }
    01590         }
    01591     }
    01592
    01593 #elif defined(_AIX)
    01594
    01595     struct vmount *mntctl_buffer;
    01596     struct vmount *vm;
    01597     char *mountedfrom;
    01598     char *mountedto;
    01599     int fsname_len, num;
    01600     char realpath_buffer[MAXPATHLEN];
    01601     int buf_sz = 4096;
    01602
    01603     mntctl_buffer = (struct vmount*)malloc(buf_sz);
    01604     num = mntctl(MCTL_QUERY, buf_sz, mntctl_buffer);
    01605     if (num == 0)
    01606     {
    01607         buf_sz = *(int*)mntctl_buffer;
    01608         free(mntctl_buffer);
    01609         mntctl_buffer = (struct vmount*)malloc(buf_sz);
    01610         num = mntctl(MCTL_QUERY, buf_sz, mntctl_buffer);
    01611     }
    01612
    01613     if (num > 0)
    01614     {
    01615         /* iterate through items in the vmount structure: */
    01616         vm = (struct vmount *)mntctl_buffer;
    01617         for ( ; num > 0; num-- )
    01618         {
    01619             /* get the name of the mounted file systems: */
    01620             fsname_len = vmt2datasize(vm, VMT_STUB);
    01621             mountedto     = (char*)malloc(fsname_len + 1);
    01622             mountedto[fsname_len] = '\0';
    01623             strncpy(mountedto, (char *)vmt2dataptr(vm, VMT_STUB), fsname_len);
    01624
    01625             fsname_len = vmt2datasize(vm, VMT_OBJECT);
    01626             mountedfrom     = (char*)malloc(fsname_len + 1);
    01627             mountedfrom[fsname_len] = '\0';
    01628             strncpy(mountedfrom, (char *)vmt2dataptr(vm, VMT_OBJECT), fsname_len);
    01629
    01630             /* get the mount-from information: */
    01631             QCString device_name = mountedfrom;
    01632
    01633             if (realpath(device_name, realpath_buffer) != 0)
    01634                 // success, use result from realpath
    01635                 device_name = realpath_buffer;
    01636
    01637             /* Look up the string for the file system type,
    01638              * as listed in /etc/vfs.
    01639              * ex.: nfs,jfs,afs,cdrfs,sfs,cachefs,nfs3,autofs
    01640              */
    01641             struct vfs_ent* ent = getvfsbytype(vm->vmt_gfstype);
    01642
    01643             if ( is_my_mountpoint( mountedto, realname, max ) )
    01644             {
    01645                 mountPoint = QFile::decodeName(mountedto);
    01646                 check_mount_point(ent->vfsent_name, device_name, isautofs, isslow);
    01647
    01648                 if (ismanual == Unseen)
    01649                 {
    01650                     // TODO: add check for ismanual, I couldn't find any way
    01651                     // how to get the mount attribute from /etc/filesystems
    01652                     ismanual == Wrong;
    01653                 }
    01654             }
    01655
    01656             free(mountedfrom);
    01657             free(mountedto);
    01658
    01659             /* goto the next vmount structure: */
    01660             vm = (struct vmount *)((char *)vm + vm->vmt_length);
    01661         }
    01662
    01663         endvfsent( );
    01664     }
    01665
    01666     free( mntctl_buffer );
    01667
    01668 #else
    01669
    01670     STRUCT_SETMNTENT mtab;
    01671     /* Get the list of mounted file systems */
    01672
    01673     if ((mtab = SETMNTENT(MNTTAB, "r")) == 0) {
    01674         perror("setmntent");
    01675         return QString::null;
    01676     }
    01677
    01678     STRUCT_MNTENT me;
    01679
    01680     while (true) {
    01681         if (!GETMNTENT(mtab, me))
    01682             break;
    01683
    01684         if ( is_my_mountpoint( MOUNTPOINT(me), realname, max ) )
    01685         {
    01686             mountPoint = QFile::decodeName( MOUNTPOINT(me) );
    01687             check_mount_point(MOUNTTYPE(me), FSNAME(me), isautofs, isslow);
    01688             // we don't check if ismanual is Right, if /a/b is manually
    01689             // mounted /a/b/c can't be automounted. At least IMO.
    01690             if (ismanual == Unseen)
    01691             {
    01692                 // The next GETMNTENT call may destroy 'me'
    01693                 // Copy out the info that we need
    01694                 QCString fsname_me = FSNAME(me);
    01695                 QCString mounttype_me = MOUNTTYPE(me);
    01696
    01697                 STRUCT_SETMNTENT fstab;
    01698                 // TODO: #define FSTAB (FSTAB_FILE?), important for Solaris
    01699                 if ((fstab = SETMNTENT("/etc/fstab", "r")) == 0)
    01700                     continue;
    01701
    01702                 bool found = false;
    01703                 STRUCT_MNTENT fe;
    01704                 while (GETMNTENT(fstab, fe))
    01705                 {
    01706                     if (fsname_me == FSNAME(fe))
    01707                     {
    01708                         found = true;
    01709                         if (HASMNTOPT(fe, "noauto") ||
    01710                             !strcmp(MOUNTTYPE(fe), "supermount"))
    01711                             ismanual = Right;
    01712                         break;
    01713                     }
    01714                 }
    01715                 if (!found || (mounttype_me == "supermount"))
    01716                   ismanual = Right;
    01717
    01718                 ENDMNTENT(fstab);
    01719             }
    01720         }
    01721     }
    01722
    01723     ENDMNTENT(mtab);
    01724
    01725 #endif
    01726
    01727     if (isautofs == Right && isslow == Unseen)
    01728         isslow = Right;
    01729
    01730     return mountPoint;
    01731 }
    01732
    01733 QString KIO::findPathMountPoint(const QString& filename)
    01734 {
    01735   MountState isautofs = Unseen, isslow = Unseen, ismanual = Wrong;
    01736   return get_mount_info(filename, isautofs, isslow, ismanual);
    01737 }
    01738
    01739 bool KIO::manually_mounted(const QString& filename)
    01740 {
    01741   MountState isautofs = Unseen, isslow = Unseen, ismanual = Unseen;
    01742   QString mountPoint = get_mount_info(filename, isautofs, isslow, ismanual);
    01743   return (mountPoint != QString::null) && (ismanual == Right);
    01744 }
    01745
    01746 bool KIO::probably_slow_mounted(const QString& filename)
    01747 {
    01748   MountState isautofs = Unseen, isslow = Unseen, ismanual = Wrong;
    01749   QString mountPoint = get_mount_info(filename, isautofs, isslow, ismanual);
    01750   return (mountPoint != QString::null) && (isslow == Right);
    01751 }
    01752
    01753 KIO::CacheControl KIO::parseCacheControl(const QString &cacheControl)
    01754 {
    01755   QString tmp = cacheControl.lower();
    01756
    01757   if (tmp == "cacheonly")
    01758      return KIO::CC_CacheOnly;
    01759   if (tmp == "cache")
    01760      return KIO::CC_Cache;
    01761   if (tmp == "verify")
    01762      return KIO::CC_Verify;
    01763   if (tmp == "refresh")
    01764      return KIO::CC_Refresh;
    01765   if (tmp == "reload")
    01766      return KIO::CC_Reload;
    01767
    01768   kdWarning() << "unrecognized Cache control option:"<<cacheControl<<endl;
    01769   return KIO::CC_Verify;
    01770 }
    01771
    01772 QString KIO::getCacheControlString(KIO::CacheControl cacheControl)
    01773 {
    01774     if (cacheControl == KIO::CC_CacheOnly)
    01775         return "CacheOnly";
    01776     if (cacheControl == KIO::CC_Cache)
    01777         return "Cache";
    01778     if (cacheControl == KIO::CC_Verify)
    01779         return "Verify";
    01780     if (cacheControl == KIO::CC_Refresh)
    01781         return "Refresh";
    01782     if (cacheControl == KIO::CC_Reload)
    01783         return "Reload";
    01784     kdFatal() << "unrecognized Cache control enum value:"<<cacheControl<<endl;
    01785     return QString::null;
    01786 }

This file is part of the documentation for kdelibs Version 3.1.5.
Documentation copyright © 1996-2002 the KDE developers.
Generated on Wed Jan 28 13:12:45 2004 by doxygen 1.3.4 written by Dimitri van Heesch, © 1997-2001