runtime/kioslave/man/kio_man.cpp

   1 /*  This file is part of the KDE libraries
   2     Copyright (c) 2000 Matthias Hoelzer-Kluepfel <mhk@caldera.de>
   3
   4     This library is free software; you can redistribute it and/or
   5     modify it under the terms of the GNU Library General Public
   6     License as published by the Free Software Foundation; either
   7     version 2 of the License, or (at your option) any later version.
   8
   9     This library is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12     Library General Public License for more details.
  13
  14     You should have received a copy of the GNU Library General Public License
  15     along with this library; see the file COPYING.LIB.  If not, write to
  16     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17     Boston, MA 02110-1301, USA.
  18 */
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <sys/stat.h>
  22 #include <string.h>
  23 #include <dirent.h>
  24
  25 #include <QByteArray>
  26 #include <QDir>
  27 #include <QFile>
  28 #include <QTextStream>
  29 #include <QDataStream>
  30 #include <Qt3Support/Q3PtrList>
  31 #include <QMap>
  32 #include <QRegExp>
  33 #include <QTextCodec>
  34
  35 #include <kdebug.h>
  36 #include <kcomponentdata.h>
  37 #include <kglobal.h>
  38 #include <kstandarddirs.h>
  39 #include <k3process.h>
  40 #include <klocale.h>
  41 #include <kmimetype.h>
  42
  43 #include "kio_man.h"
  44 #include "kio_man.moc"
  45 #include "man2html.h"
  46 #include <assert.h>
  47 #include <kfilterbase.h>
  48 #include <kfilterdev.h>
  49
  50 using namespace KIO;
  51
  52 MANProtocol *MANProtocol::_self = 0;
  53
  54 #define SGML2ROFF_DIRS "/usr/lib/sgml"
  55
  56 /*
  57  * Drop trailing ".section[.gz]" from name
  58  */
  59 static
  60 void stripExtension( QString *name )
  61 {
  62     int pos = name->length();
  63
  64     if ( name->indexOf(".gz", -3) != -1 )
  65         pos -= 3;
  66     else if ( name->indexOf(".z", -2, Qt::CaseInsensitive) != -1 )
  67         pos -= 2;
  68     else if ( name->indexOf(".bz2", -4) != -1 )
  69         pos -= 4;
  70     else if ( name->indexOf(".bz", -3) != -1 )
  71         pos -= 3;
  72
  73     if ( pos > 0 )
  74         pos = name->lastIndexOf('.', pos-1);
  75
  76     if ( pos > 0 )
  77         name->truncate( pos );
  78 }
  79
  80 static
  81 bool parseUrl(const QString& _url, QString &title, QString &section)
  82 {
  83     section.clear();
  84
  85     QString url = _url;
  86     if (url.at(0) == '/') {
  87         if (KStandardDirs::exists(url)) {
  88             title = url;
  89             return true;
  90         } else
  91         {
  92             // If the directory does not exist, then it is perhaps a normal man page
  93             kDebug(7107) << url << " does not exist";
  94         }
  95     }
  96
  97     while (url.at(0) == '/')
  98         url.remove(0,1);
  99
 100     title = url;
 101
 102     int pos = url.indexOf('(');
 103     if (pos < 0)
 104         return true;
 105
 106     title = title.left(pos);
 107
 108     section = url.mid(pos+1);
 109     section = section.left(section.length()-1);
 110
 111     return true;
 112 }
 113
 114
 115 MANProtocol::MANProtocol(const QByteArray &pool_socket, const QByteArray &app_socket)
 116     : QObject(), SlaveBase("man", pool_socket, app_socket)
 117 {
 118     assert(!_self);
 119     _self = this;
 120     const QString common_dir = KGlobal::dirs()->findResourceDir( "html", "en/common/kde-default.css" );
 121     const QString strPath=QString( "file:%1/en/common" ).arg( common_dir );
 122     m_htmlPath=strPath.toLocal8Bit(); // ### TODO encode for HTML
 123     m_cssPath=strPath.toLocal8Bit(); // ### TODO encode for CSS
 124     section_names << "1" << "2" << "3" << "3n" << "3p" << "4" << "5" << "6" << "7"
 125                   << "8" << "9" << "l" << "n";
 126     m_manCSSFile = KStandardDirs::locate( "data", "kio_man/kio_man.css" );
 127 }
 128
 129 MANProtocol *MANProtocol::self() { return _self; }
 130
 131 MANProtocol::~MANProtocol()
 132 {
 133     _self = 0;
 134 }
 135
 136 void MANProtocol::parseWhatIs( QMap<QString, QString> &i, QTextStream &t, const QString &mark )
 137 {
 138     QRegExp re( mark );
 139     QString l;
 140     while ( !t.atEnd() )
 141     {
 142         l = t.readLine();
 143         int pos = re.indexIn( l );
 144         if (pos != -1)
 145         {
 146             QString names = l.left(pos);
 147             QString descr = l.mid(pos + re.matchedLength());
 148             while ((pos = names.indexOf(",")) != -1)
 149             {
 150                 i[names.left(pos++)] = descr;
 151                 while (names[pos] == ' ')
 152                     pos++;
 153                 names = names.mid(pos);
 154             }
 155             i[names] = descr;
 156         }
 157     }
 158 }
 159
 160 bool MANProtocol::addWhatIs(QMap<QString, QString> &i, const QString &name, const QString &mark)
 161 {
 162     QFile f(name);
 163     if (!f.open(QIODevice::ReadOnly))
 164         return false;
 165     QTextStream t(&f);
 166     parseWhatIs( i, t, mark );
 167     return true;
 168 }
 169
 170 QMap<QString, QString> MANProtocol::buildIndexMap(const QString &section)
 171 {
 172     QMap<QString, QString> i;
 173     QStringList man_dirs = manDirectories();
 174     // Supplementary places for whatis databases
 175     man_dirs += m_mandbpath;
 176     if (!man_dirs.contains("/var/cache/man"))
 177         man_dirs << "/var/cache/man";
 178     if (!man_dirs.contains("/var/catman"))
 179         man_dirs << "/var/catman";
 180
 181     QStringList names;
 182     names << "whatis.db" << "whatis";
 183     QString mark = "\\s+\\(" + section + "[a-z]*\\)\\s+-\\s+";
 184
 185     for ( QStringList::ConstIterator it_dir = man_dirs.begin();
 186           it_dir != man_dirs.end();
 187           ++it_dir )
 188     {
 189         if ( QFile::exists( *it_dir ) ) {
 190             QStringList::ConstIterator it_name;
 191             for ( it_name = names.begin();
 192                   it_name != names.end();
 193                   it_name++ )
 194             {
 195                 if (addWhatIs(i, (*it_dir) + '/' + (*it_name), mark))
 196                     break;
 197             }
 198             if ( it_name == names.end() ) {
 199                 K3Process proc;
 200                 proc << "whatis" << "-M" << (*it_dir) << "-w" << "*";
 201                 myStdStream.clear();
 202                 connect( &proc, SIGNAL( receivedStdout(K3Process *, char *, int ) ),
 203                          SLOT( slotGetStdOutput( K3Process *, char *, int ) ) );
 204                 proc.start( K3Process::Block, K3Process::Stdout );
 205                 QTextStream t( &myStdStream, QIODevice::ReadOnly );
 206                 parseWhatIs( i, t, mark );
 207             }
 208         }
 209     }
 210     return i;
 211 }
 212
 213 QStringList MANProtocol::manDirectories()
 214 {
 215     checkManPaths();
 216     //
 217     // Build a list of man directories including translations
 218     //
 219     QStringList man_dirs;
 220
 221     for ( QStringList::ConstIterator it_dir = m_manpath.begin();
 222           it_dir != m_manpath.end();
 223           it_dir++ )
 224     {
 225         // Translated pages in "<mandir>/<lang>" if the directory
 226         // exists
 227         QStringList languages = KGlobal::locale()->languageList();
 228
 229         for (QStringList::ConstIterator it_lang = languages.begin();
 230              it_lang != languages.end();
 231              it_lang++ )
 232         {
 233             if ( !(*it_lang).isEmpty() && (*it_lang) != QString("C") ) {
 234                 QString dir = (*it_dir) + '/' + (*it_lang);
 235
 236                 struct stat sbuf;
 237
 238                 if ( ::stat( QFile::encodeName( dir ), &sbuf ) == 0
 239                     && S_ISDIR( sbuf.st_mode ) )
 240                 {
 241                     const QString p = QDir(dir).canonicalPath();
 242                     if (!man_dirs.contains(p)) man_dirs += p;
 243                 }
 244             }
 245         }
 246
 247         // Untranslated pages in "<mandir>"
 248         const QString p = QDir(*it_dir).canonicalPath();
 249         if (!man_dirs.contains(p)) man_dirs += p;
 250     }
 251     return man_dirs;
 252 }
 253
 254 QStringList MANProtocol::findPages(const QString &_section,
 255                                    const QString &title,
 256                                    bool full_path)
 257 {
 258     QString section = _section;
 259
 260     QStringList list;
 261
 262     // kDebug() << "findPages '" << section << "' '" << title << "'\n";
 263     if ( (!title.isEmpty()) && (title.at(0) == '/') ) {
 264        list.append(title);
 265        return list;
 266     }
 267
 268     const QString star( "*" );
 269
 270     //
 271     // Find man sections in this directory
 272     //
 273     QStringList sect_list;
 274     if ( section.isEmpty() )
 275         section = star;
 276
 277     if ( section != star )
 278     {
 279         //
 280         // Section given as argument
 281         //
 282         sect_list += section;
 283         while ( (!section.isEmpty()) && (section.at(section.length() - 1).isLetter()) ) {
 284             section.truncate(section.length() - 1);
 285             sect_list += section;
 286         }
 287     } else {
 288         sect_list += section;
 289     }
 290
 291     QStringList man_dirs = manDirectories();
 292
 293     //
 294     // Find man pages in the sections listed above
 295     //
 296     for ( int i=0;i<sect_list.count(); i++)
 297     {
 298             QString it_s=sect_list.at(i);
 299             QString it_real = it_s.toLower();
 300         //
 301         // Find pages
 302         //
 303         //kDebug(7107)<<"Before inner loop";
 304         for ( QStringList::const_iterator it_dir = man_dirs.begin();
 305               it_dir != man_dirs.end();
 306               it_dir++ )
 307         {
 308             QString man_dir = (*it_dir);
 309             //
 310             // Sections = all sub directories "man*" and "sman*"
 311             //
 312             DIR *dp = ::opendir( QFile::encodeName( man_dir ) );
 313
 314             if ( !dp )
 315                 continue;
 316
 317             struct dirent *ep;
 318
 319             const QString man = QString("man");
 320             const QString sman = QString("sman");
 321
 322             while ( (ep = ::readdir( dp )) != 0L ) {
 323
 324                 const QString file = QFile::decodeName( ep->d_name );
 325                 QString sect = QString();
 326
 327                 if ( file.startsWith( man ) )
 328                     sect = file.mid(3);
 329                 else if (file.startsWith(sman))
 330                     sect = file.mid(4);
 331
 332                 if (sect.toLower()==it_real) it_real = sect;
 333
 334                 // Only add sect if not already contained, avoid duplicates
 335                 if (!sect_list.contains(sect) && _section.isEmpty())  {
 336                     //kDebug() << "another section " << sect;
 337                     sect_list += sect;
 338                 }
 339             }
 340
 341             //kDebug(7107) <<" after while loop";
 342             ::closedir( dp );
 343 #if 0
 344             kDebug(7107)<<"================-";
 345             kDebug(7107)<<"star=="<<star;
 346             kDebug(7107)<<"it_s=="<<it_s;
 347             kDebug(7107)<<"================+";
 348 #endif
 349             if ( it_s != star ) { // in that case we only look around for sections
 350                 //kDebug(7107)<<"Within if ( it_s != star )";
 351                 const QString dir = man_dir + QString("/man") + (it_real) + '/';
 352                 const QString sdir = man_dir + QString("/sman") + (it_real) + '/';
 353
 354                 //kDebug(7107)<<"calling findManPagesInSection";
 355                 findManPagesInSection(dir, title, full_path, list);
 356                 findManPagesInSection(sdir, title, full_path, list);
 357             }
 358             kDebug(7107)<<"After if";
 359         }
 360     }
 361
 362     //kDebug(7107) << "finished " << list << " " << sect_list;
 363
 364     return list;
 365 }
 366
 367 void MANProtocol::findManPagesInSection(const QString &dir, const QString &title, bool full_path, QStringList &list)
 368 {
 369     kDebug() << "findManPagesInSection " << dir << " " << title;
 370     bool title_given = !title.isEmpty();
 371
 372     DIR *dp = ::opendir( QFile::encodeName( dir ) );
 373
 374     if ( !dp )
 375         return;
 376
 377     struct dirent *ep;
 378
 379     while ( (ep = ::readdir( dp )) != 0L ) {
 380         if ( ep->d_name[0] != '.' ) {
 381
 382             QString name = QFile::decodeName( ep->d_name );
 383
 384             // check title if we're looking for a specific page
 385             if ( title_given ) {
 386                 if ( !name.startsWith( title ) ) {
 387                     continue;
 388                 }
 389                 else {
 390                     // beginning matches, do a more thorough check...
 391                     QString tmp_name = name;
 392                     stripExtension( &tmp_name );
 393                     if ( tmp_name != title )
 394                         continue;
 395                 }
 396             }
 397
 398             if ( full_path )
 399                 name.prepend( dir );
 400
 401             list += name ;
 402         }
 403     }
 404     ::closedir( dp );
 405 }
 406
 407 void MANProtocol::output(const char *insert)
 408 {
 409     if (insert)
 410     {
 411         m_outputBuffer.write(insert,strlen(insert));
 412     }
 413     if (!insert || m_outputBuffer.pos() >= 2048)
 414     {
 415         m_outputBuffer.close();
 416         data(m_outputBuffer.buffer());
 417         m_outputBuffer.setData(QByteArray());
 418         m_outputBuffer.open(QIODevice::WriteOnly);
 419     }
 420 }
 421
 422 #ifndef SIMPLE_MAN2HTML
 423 // called by man2html
 424 extern char *read_man_page(const char *filename)
 425 {
 426     return MANProtocol::self()->readManPage(filename);
 427 }
 428
 429 // called by man2html
 430 extern void output_real(const char *insert)
 431 {
 432     MANProtocol::self()->output(insert);
 433 }
 434 #endif
 435
 436 static QString text2html(const QString& txt)
 437 {
 438     QString reply = txt;
 439
 440     reply = reply.replace('&', "&amp;");
 441     reply = reply.replace('<', "&lt;");
 442     reply = reply.replace('>', "&gt;");
 443     reply = reply.replace('"', "&dquot;");
 444     reply = reply.replace('\'', "&quot;");
 445     return reply;
 446 }
 447
 448
 449 void MANProtocol::get(const KUrl& url )
 450 {
 451     kDebug(7107) << "GET " << url.url();
 452
 453     QString title, section;
 454
 455     if (!parseUrl(url.path(), title, section))
 456     {
 457         showMainIndex();
 458         return;
 459     }
 460
 461     // tell the mimetype
 462     mimeType("text/html");
 463
 464     // see if an index was requested
 465     if (url.query().isEmpty() && (title.isEmpty() || title == "/" || title == "."))
 466     {
 467         if (section == "index" || section.isEmpty())
 468             showMainIndex();
 469         else
 470             showIndex(section);
 471         return;
 472     }
 473
 474     const QStringList foundPages=findPages(section, title);
 475     bool pageFound=true;
 476
 477     if (foundPages.isEmpty())
 478     {
 479        outputError(i18n("No man page matching to %1 found.<br /><br />"
 480            "Check that you have not mistyped the name of the page that you want.<br />"
 481            "Be careful that you must take care about upper case and lower case characters!<br />"
 482            "If everything looks correct, then perhaps you need to set a better search path "
 483            "for man pages, be it by the environment variable MANPATH or a matching file "
 484            "in the directory /etc .", text2html(title)));
 485        pageFound=false;
 486     }
 487     else if (foundPages.count()>1)
 488     {
 489        pageFound=false;
 490        //check for the case that there is foo.1 and foo.1.gz found:
 491        // ### TODO make it more generic (other extensions)
 492        if ((foundPages.count()==2) &&
 493            (((foundPages[0]+".gz") == foundPages[1]) ||
 494             (foundPages[0] == (foundPages[1]+".gz"))))
 495           pageFound=true;
 496        else
 497           outputMatchingPages(foundPages);
 498     }
 499     //yes, we found exactly one man page
 500
 501     if (pageFound)
 502     {
 503        setResourcePath(m_htmlPath,m_cssPath);
 504        m_outputBuffer.open(QIODevice::WriteOnly);
 505        const QByteArray filename=QFile::encodeName(foundPages[0]);
 506        char *buf = readManPage(filename);
 507
 508        if (!buf)
 509        {
 510           outputError(i18n("Open of %1 failed.", title));
 511           finished();
 512           return;
 513        }
 514        // will call output_real
 515        scan_man_page(buf);
 516        delete [] buf;
 517
 518        output(0); // flush
 519
 520        m_outputBuffer.close();
 521        data(m_outputBuffer.buffer());
 522        m_outputBuffer.setData(QByteArray());
 523        // tell we are done
 524        data(QByteArray());
 525     }
 526     finished();
 527 }
 528
 529 void MANProtocol::slotGetStdOutput(K3Process* /* p */, char *s, int len)
 530 {
 531   myStdStream += QString::fromLocal8Bit(s, len);
 532 }
 533
 534 char *MANProtocol::readManPage(const char *_filename)
 535 {
 536     QByteArray filename = _filename;
 537
 538     char *buf = NULL;
 539
 540     /* Determine type of man page file by checking its path. Determination by
 541      * MIME type with KMimeType doesn't work reliablely. E.g., Solaris 7:
 542      * /usr/man/sman7fs/pcfs.7fs -> text/x-csrc : WRONG
 543      * If the path name constains the string sman, assume that it's SGML and
 544      * convert it to roff format (used on Solaris). */
 545     //QString file_mimetype = KMimeType::findByPath(QString(filename), 0, false)->name();
 546     if (QString(filename).contains("sman", Qt::CaseInsensitive)) //file_mimetype == "text/html" || )
 547     {
 548         myStdStream =QString();
 549         K3Process proc;
 550
 551         /* Determine path to sgml2roff, if not already done. */
 552         getProgramPath();
 553         proc << mySgml2RoffPath << filename;
 554
 555         connect(&proc, SIGNAL(receivedStdout (K3Process *, char *, int)),
 556                 this, SLOT(slotGetStdOutput(K3Process *, char *, int)));
 557         proc.start(K3Process::Block, K3Process::All);
 558
 559         const QByteArray cstr=myStdStream.toLatin1();
 560         const int len = cstr.size()-1;
 561         buf = new char[len + 4];
 562         memmove(buf + 1, cstr.data(), len);
 563         buf[0]=buf[len]='\n'; // Start and end with a end of line
 564         buf[len+1]=buf[len+2]='\0'; // Two additional NUL characters at end
 565     }
 566     else
 567     {
 568         if (QDir::isRelativePath(filename)) {
 569             kDebug(7107) << "relative " << filename;
 570             filename = QDir::cleanPath(lastdir + '/' + filename).toUtf8();
 571             if (!KStandardDirs::exists(filename)) { // exists perhaps with suffix
 572                 lastdir = filename.left(filename.lastIndexOf('/'));
 573                 QDir mandir(lastdir);
 574                 mandir.setNameFilters(QStringList() << (filename.mid(filename.lastIndexOf('/') + 1) + ".*"));
 575                 filename = lastdir + '/' + QFile::encodeName(mandir.entryList().first());
 576             }
 577             kDebug(7107) << "resolved to " << filename;
 578         }
 579         lastdir = filename.left(filename.lastIndexOf('/'));
 580
 581         QIODevice *fd= KFilterDev::deviceForFile(filename);
 582
 583         if ( !fd || !fd->open(QIODevice::ReadOnly))
 584         {
 585            delete fd;
 586            return 0;
 587         }
 588         QByteArray array(fd->readAll());
 589         kDebug(7107) << "read " << array.size();
 590         fd->close();
 591         delete fd;
 592
 593         if (array.isEmpty())
 594             return 0;
 595
 596         const int len = array.size();
 597         buf = new char[len + 4];
 598         memmove(buf + 1, array.data(), len);
 599         buf[0]=buf[len]='\n'; // Start and end with a end of line
 600         buf[len+1]=buf[len+2]='\0'; // Two NUL characters at end
 601     }
 602     return buf;
 603 }
 604
 605
 606 void MANProtocol::outputError(const QString& errmsg)
 607 {
 608     QByteArray array;
 609     QTextStream os(&array, QIODevice::WriteOnly);
 610     os.setCodec( "UTF-8" );
 611
 612     os << "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Strict//EN\">" << endl;
 613     os << "<html><head><meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">" << endl;
 614     os << "<title>" << i18n("Man output") << "</title>\n" << endl;
 615     if ( !m_manCSSFile.isEmpty() )
 616         os << "<link href=\"file:///" << m_manCSSFile << "\" type=\"text/css\" rel=\"stylesheet\">" << endl;
 617     os << "</head>" << endl;
 618     os << "<body>" << i18n("<h1>KDE Man Viewer Error</h1>") << errmsg << "</body>" << endl;
 619     os << "</html>" << endl;
 620
 621     data(array);
 622 }
 623
 624 void MANProtocol::outputMatchingPages(const QStringList &matchingPages)
 625 {
 626     QByteArray array;
 627     QTextStream os(&array, QIODevice::WriteOnly);
 628     os.setCodec( "UTF-8" );
 629
 630     os << "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Strict//EN\">" << endl;
 631     os << "<html>\n<head><meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">"<<endl;
 632     os << "<title>" << i18n("Man output") <<"</title>" << endl;
 633     if ( !m_manCSSFile.isEmpty() )
 634         os << "<link href=\"file:///" << m_manCSSFile << "\" type=\"text/css\" rel=\"stylesheet\">" << endl;
 635     os << "</head>" <<endl;
 636     os << "<body><h1>" << i18n("There is more than one matching man page.");
 637     os << "</h1>\n<ul>\n";
 638
 639     int acckey=1;
 640     for (QStringList::ConstIterator it = matchingPages.begin(); it != matchingPages.end(); ++it)
 641     {
 642       os<<"<li><a href='man:"<<(*it)<<"' accesskey='"<< acckey <<"'>"<< *it <<"</a><br>\n<br>\n";
 643       acckey++;
 644     }
 645     os << "</ul>\n";
 646     os << "<hr>\n";
 647     os << "<p>" << i18n("Note: if you read a man page in your language,"
 648        " be aware it can contain some mistakes or be obsolete."
 649        " In case of doubt, you should have a look at the English version.") << "</p>";
 650
 651     os << "</body>\n</html>"<<endl;
 652
 653     data(array);
 654     finished();
 655 }
 656
 657 void MANProtocol::stat( const KUrl& url)
 658 {
 659     kDebug(7107) << "ENTERING STAT " << url.url();
 660
 661     QString title, section;
 662
 663     if (!parseUrl(url.path(), title, section))
 664     {
 665         error(KIO::ERR_MALFORMED_URL, url.url());
 666         return;
 667     }
 668
 669     kDebug(7107) << "URL " << url.url() << " parsed to title='" << title << "' section=" << section;
 670
 671     UDSEntry entry;
 672     entry.insert(KIO::UDSEntry::UDS_NAME, title);
 673     entry.insert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFREG);
 674
 675     QString newUrl = "man:"+title;
 676     if (!section.isEmpty())
 677         newUrl += QString("(%1)").arg(section);
 678     entry.insert(KIO::UDSEntry::UDS_URL, newUrl);
 679
 680     entry.insert(KIO::UDSEntry::UDS_MIME_TYPE, QString::fromLatin1("text/html"));
 681
 682     statEntry(entry);
 683
 684     finished();
 685 }
 686
 687
 688 extern "C"
 689 {
 690
 691     int KDE_EXPORT kdemain( int argc, char **argv ) {
 692
 693         KComponentData componentData("kio_man");
 694
 695         kDebug(7107) <<  "STARTING " << getpid();
 696
 697         if (argc != 4)
 698         {
 699             fprintf(stderr, "Usage: kio_man protocol domain-socket1 domain-socket2\n");
 700             exit(-1);
 701         }
 702
 703         MANProtocol slave(argv[2], argv[3]);
 704         slave.dispatchLoop();
 705
 706         kDebug(7107) << "Done";
 707
 708         return 0;
 709     }
 710
 711 }
 712
 713 void MANProtocol::mimetype(const KUrl & /*url*/)
 714 {
 715     mimeType("text/html");
 716     finished();
 717 }
 718
 719 static QString sectionName(const QString& section)
 720 {
 721     if (section == "1")
 722         return i18n("User Commands");
 723     else if (section == "2")
 724         return i18n("System Calls");
 725     else if (section == "3")
 726         return i18n("Subroutines");
 727     else if (section == "3p")
 728         return i18n("Perl Modules");
 729     else if (section == "3n")
 730         return i18n("Network Functions");
 731     else if (section == "4")
 732         return i18n("Devices");
 733     else if (section == "5")
 734         return i18n("File Formats");
 735     else if (section == "6")
 736         return i18n("Games");
 737     else if (section == "7")
 738         return i18n("Miscellaneous");
 739     else if (section == "8")
 740         return i18n("System Administration");
 741     else if (section == "9")
 742         return i18n("Kernel");
 743     else if (section == "l")
 744         return i18n("Local Documentation");
 745     else if (section == "n")
 746         return i18n("New");
 747
 748     return QString();
 749 }
 750
 751 QStringList MANProtocol::buildSectionList(const QStringList& dirs) const
 752 {
 753     QStringList l;
 754
 755     for (QStringList::ConstIterator it = section_names.begin();
 756             it != section_names.end(); ++it)
 757     {
 758             for (QStringList::ConstIterator dir = dirs.begin();
 759                     dir != dirs.end(); ++dir)
 760             {
 761                 QDir d((*dir)+"/man"+(*it));
 762                 if (d.exists())
 763                 {
 764                     l << *it;
 765                     break;
 766                 }
 767             }
 768     }
 769     return l;
 770 }
 771
 772 void MANProtocol::showMainIndex()
 773 {
 774     QByteArray array;
 775     QTextStream os(&array, QIODevice::WriteOnly);
 776     os.setCodec( "UTF-8" );
 777
 778     // print header
 779     os << "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Strict//EN\">" << endl;
 780     os << "<html><head><meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">" << endl;
 781     os << "<title>" << i18n("UNIX Manual Index") << "</title>" << endl;
 782     if (!m_manCSSFile.isEmpty())
 783         os << "<link href=\"file:///" << m_manCSSFile << "\" type=\"text/css\" rel=\"stylesheet\">" << endl;
 784     os << "</head>" << endl;
 785     os << "<body><h1>" << i18n("UNIX Manual Index") << "</h1>" << endl;
 786
 787     // ### TODO: why still the environment variable
 788     const QString sectList = getenv("MANSECT");
 789     QStringList sections;
 790     if (sectList.isEmpty())
 791         sections = buildSectionList(manDirectories());
 792     else
 793         sections = sectList.split( ':');
 794
 795     os << "<table>" << endl;
 796
 797     QStringList::ConstIterator it;
 798     for (it = sections.begin(); it != sections.end(); ++it)
 799         os << "<tr><td><a href=\"man:(" << *it << ")\" accesskey=\"" <<
 800         (((*it).length()==1)?(*it):(*it).right(1))<<"\">" << i18n("Section ")
 801         << *it << "</a></td><td>&nbsp;</td><td> " << sectionName(*it) << "</td></tr>" << endl;
 802
 803     os << "</table>" << endl;
 804
 805     // print footer
 806     os << "</body></html>" << endl;
 807
 808     data(array);
 809     finished();
 810 }
 811
 812 void MANProtocol::constructPath(QStringList& constr_path, QStringList constr_catmanpath)
 813 {
 814     QMap<QString, QString> manpath_map;
 815     QMap<QString, QString> mandb_map;
 816
 817     // Add paths from /etc/man.conf
 818     //
 819     // Explicit manpaths may be given by lines starting with "MANPATH" or
 820     // "MANDATORY_MANPATH" (depending on system ?).
 821     // Mappings from $PATH to manpath are given by lines starting with
 822     // "MANPATH_MAP"
 823
 824     QRegExp manpath_regex( "^MANPATH\\s" );
 825     QRegExp mandatory_regex( "^MANDATORY_MANPATH\\s" );
 826     QRegExp manpath_map_regex( "^MANPATH_MAP\\s" );
 827     QRegExp mandb_map_regex( "^MANDB_MAP\\s" );
 828     //QRegExp section_regex( "^SECTION\\s" );
 829     QRegExp space_regex( "\\s+" ); // for parsing manpath map
 830
 831     QFile mc("/etc/man.conf");             // Caldera
 832     if (!mc.exists())
 833         mc.setFileName("/etc/manpath.config"); // SuSE, Debian
 834     if (!mc.exists())
 835         mc.setFileName("/etc/man.config");  // Mandrake
 836
 837     if (mc.open(QIODevice::ReadOnly))
 838     {
 839         QTextStream is(&mc);
 840         is.setCodec( QTextCodec::codecForLocale () );
 841
 842         while (!is.atEnd())
 843         {
 844             const QString line = is.readLine();
 845             if ( manpath_regex.indexIn(line) == 0 )
 846             {
 847                 const QString path = line.mid(8).trimmed();
 848                 constr_path += path;
 849             }
 850             else if ( mandatory_regex.indexIn(line) == 0 )
 851             {
 852                 const QString path = line.mid(18).trimmed();
 853                 constr_path += path;
 854             }
 855             else if ( manpath_map_regex.indexIn(line) == 0 )
 856             {
 857                         // The entry is "MANPATH_MAP  <path>  <manpath>"
 858                 const QStringList mapping =
 859                         line.split( space_regex);
 860
 861                 if ( mapping.count() == 3 )
 862                 {
 863                     const QString dir = QDir::cleanPath( mapping[1] );
 864                     const QString mandir = QDir::cleanPath( mapping[2] );
 865
 866                     manpath_map[ dir ] = mandir;
 867                 }
 868             }
 869             else if ( mandb_map_regex.indexIn(line) == 0 )
 870             {
 871                         // The entry is "MANDB_MAP  <manpath>  <catmanpath>"
 872                 const QStringList mapping =
 873                         line.split( space_regex);
 874
 875                 if ( mapping.count() == 3 )
 876                 {
 877                     const QString mandir = QDir::cleanPath( mapping[1] );
 878                     const QString catmandir = QDir::cleanPath( mapping[2] );
 879
 880                     mandb_map[ mandir ] = catmandir;
 881                 }
 882             }
 883     /* sections are not used
 884             else if ( section_regex.find(line, 0) == 0 )
 885             {
 886             if ( !conf_section.isEmpty() )
 887             conf_section += ':';
 888             conf_section += line.mid(8).trimmed();
 889         }
 890     */
 891         }
 892         mc.close();
 893     }
 894
 895     // Default paths
 896     static const char *manpaths[] = {
 897         "/usr/X11/man",
 898         "/usr/X11R6/man",
 899         "/usr/man",
 900         "/usr/local/man",
 901         "/usr/exp/man",
 902         "/usr/openwin/man",
 903         "/usr/dt/man",
 904         "/opt/freetool/man",
 905         "/opt/local/man",
 906         "/usr/tex/man",
 907         "/usr/www/man",
 908         "/usr/lang/man",
 909         "/usr/gnu/man",
 910         "/usr/share/man",
 911         "/usr/motif/man",
 912         "/usr/titools/man",
 913         "/usr/sunpc/man",
 914         "/usr/ncd/man",
 915         "/usr/newsprint/man",
 916         NULL };
 917
 918
 919     int i = 0;
 920     while (manpaths[i]) {
 921         if ( constr_path.indexOf( QString( manpaths[i] ) ) == -1 )
 922             constr_path += QString( manpaths[i] );
 923         i++;
 924     }
 925
 926     // Directories in $PATH
 927     // - if a manpath mapping exists, use that mapping
 928     // - if a directory "<path>/man" or "<path>/../man" exists, add it
 929     //   to the man path (the actual existence check is done further down)
 930
 931     if ( ::getenv("PATH") ) {
 932         const QStringList path =
 933               QString::fromLocal8Bit( ::getenv("PATH") ).split( ":", QString::SkipEmptyParts );
 934
 935         for ( QStringList::const_iterator it = path.begin();
 936               it != path.end();
 937               ++it )
 938         {
 939             const QString dir = QDir::cleanPath( *it );
 940             QString mandir = manpath_map[ dir ];
 941
 942             if ( !mandir.isEmpty() ) {
 943                                 // a path mapping exists
 944                 if ( constr_path.indexOf( mandir ) == -1 )
 945                     constr_path += mandir;
 946             }
 947             else {
 948                                 // no manpath mapping, use "<path>/man" and "<path>/../man"
 949
 950                 mandir = dir + QString( "/man" );
 951                 if ( constr_path.indexOf( mandir ) == -1 )
 952                     constr_path += mandir;
 953
 954                 int pos = dir.lastIndexOf( '/' );
 955                 if ( pos > 0 ) {
 956                     mandir = dir.left( pos ) + QString("/man");
 957                     if ( constr_path.indexOf( mandir ) == -1 )
 958                         constr_path += mandir;
 959                 }
 960             }
 961             QString catmandir = mandb_map[ mandir ];
 962             if ( !mandir.isEmpty() )
 963             {
 964                 if ( constr_catmanpath.indexOf( catmandir ) == -1 )
 965                     constr_catmanpath += catmandir;
 966             }
 967             else
 968             {
 969             // What is the default mapping?
 970                 catmandir = mandir;
 971                 catmandir.replace("/usr/share/","/var/cache/");
 972                 if ( constr_catmanpath.indexOf( catmandir ) == -1 )
 973                     constr_catmanpath += catmandir;
 974             }
 975         }
 976     }
 977 }
 978
 979 void MANProtocol::checkManPaths()
 980 {
 981     static bool inited = false;
 982
 983     if (inited)
 984         return;
 985
 986     inited = true;
 987
 988     const QString manpath_env = QString::fromLocal8Bit( ::getenv("MANPATH") );
 989     //QString mansect_env = QString::fromLocal8Bit( ::getenv("MANSECT") );
 990
 991     // Decide if $MANPATH is enough on its own or if it should be merged
 992     // with the constructed path.
 993     // A $MANPATH starting or ending with ":", or containing "::",
 994     // should be merged with the constructed path.
 995
 996     bool construct_path = false;
 997
 998     if ( manpath_env.isEmpty()
 999         || manpath_env[0] == ':'
1000         || manpath_env[manpath_env.length()-1] == ':'
1001         || manpath_env.contains( "::" ) )
1002     {
1003         construct_path = true; // need to read config file
1004     }
1005
1006     // Constucted man path -- consists of paths from
1007     //   /etc/man.conf
1008     //   default dirs
1009     //   $PATH
1010     QStringList constr_path;
1011     QStringList constr_catmanpath; // catmanpath
1012
1013     QString conf_section;
1014
1015     if ( construct_path )
1016     {
1017         constructPath(constr_path, constr_catmanpath);
1018     }
1019
1020     m_mandbpath=constr_catmanpath;
1021
1022     // Merge $MANPATH with the constructed path to form the
1023     // actual manpath.
1024     //
1025     // The merging syntax with ":" and "::" in $MANPATH will be
1026     // satisfied if any empty string in path_list_env (there
1027     // should be 1 or 0) is replaced by the constructed path.
1028
1029     const QStringList path_list_env = manpath_env.split( ':', QString::KeepEmptyParts);
1030
1031     for ( QStringList::const_iterator it = path_list_env.begin();
1032           it != path_list_env.end();
1033           ++it )
1034     {
1035         struct stat sbuf;
1036
1037         QString dir = (*it);
1038
1039         if ( !dir.isEmpty() ) {
1040             // Add dir to the man path if it exists
1041             if ( m_manpath.indexOf( dir ) == -1 ) {
1042                 if ( ::stat( QFile::encodeName( dir ), &sbuf ) == 0
1043                     && S_ISDIR( sbuf.st_mode ) )
1044                 {
1045                     m_manpath += dir;
1046                 }
1047             }
1048         }
1049         else {
1050             // Insert constructed path ($MANPATH was empty, or
1051             // there was a ":" at an end or "::")
1052
1053             for ( QStringList::Iterator it2 = constr_path.begin();
1054                   it2 != constr_path.end();
1055                   it2++ )
1056             {
1057                 dir = (*it2);
1058
1059                 if ( !dir.isEmpty() ) {
1060                     if ( m_manpath.indexOf( dir ) == -1 ) {
1061                         if ( ::stat( QFile::encodeName( dir ), &sbuf ) == 0
1062                             && S_ISDIR( sbuf.st_mode ) )
1063                         {
1064                             m_manpath += dir;
1065                         }
1066                     }
1067                 }
1068             }
1069         }
1070     }
1071
1072 /* sections are not used
1073     // Sections
1074     QStringList m_mansect = mansect_env.split( ':', QString::KeepEmptyParts);
1075
1076     const char* default_sect[] =
1077         { "1", "2", "3", "4", "5", "6", "7", "8", "9", "n", 0L };
1078
1079     for ( int i = 0; default_sect[i] != 0L; i++ )
1080         if ( m_mansect.indexOf( QString( default_sect[i] ) ) == -1 )
1081             m_mansect += QString( default_sect[i] );
1082 */
1083
1084 }
1085
1086
1087 //#define _USE_OLD_CODE
1088
1089 #ifdef _USE_OLD_CODE
1090 #ifdef __GNUC__
1091 #warning "using old code"
1092 #endif
1093 #else
1094
1095 // Define this, if you want to compile with qsort from stdlib.h
1096 // else the Qt Heapsort will be used.
1097 // Note, qsort seems to be a bit faster (~10%) on a large man section
1098 // eg. man section 3
1099 #define _USE_QSORT
1100
1101 // Setup my own structure, with char pointers.
1102 // from now on only pointers are copied, no strings
1103 //
1104 // containing the whole path string,
1105 // the beginning of the man page name
1106 // and the length of the name
1107 struct man_index_t {
1108     char *manpath;  // the full path including man file
1109     const char *manpage_begin;  // pointer to the begin of the man file name in the path
1110     int manpage_len; // len of the man file name
1111 };
1112 typedef man_index_t *man_index_ptr;
1113
1114 #ifdef _USE_QSORT
1115 int compare_man_index(const void *s1, const void *s2)
1116 {
1117     struct man_index_t *m1 = *(struct man_index_t **)s1;
1118     struct man_index_t *m2 = *(struct man_index_t **)s2;
1119     int i;
1120     // Compare the names of the pages
1121     // with the shorter length.
1122     // Man page names are not '\0' terminated, so
1123     // this is a bit tricky
1124     if ( m1->manpage_len > m2->manpage_len)
1125     {
1126         i = qstrnicmp( m1->manpage_begin,
1127                       m2->manpage_begin,
1128                       m2->manpage_len);
1129         if (!i)
1130             return 1;
1131         return i;
1132     }
1133
1134     if ( m1->manpage_len < m2->manpage_len)
1135     {
1136         i = qstrnicmp( m1->manpage_begin,
1137                       m2->manpage_begin,
1138                       m1->manpage_len);
1139         if (!i)
1140             return -1;
1141         return i;
1142     }
1143
1144     return qstrnicmp( m1->manpage_begin,
1145                      m2->manpage_begin,
1146                      m1->manpage_len);
1147 }
1148
1149 #else /* !_USE_QSORT */
1150 #ifdef __GNUC__
1151 #warning using heapsort
1152 #endif
1153 // Set up my own man page list,
1154 // with a special compare function to sort itself
1155 typedef QList<struct man_index_t*> QManIndexListBase;
1156 typedef QList<struct man_index_t*>::Iterator QManIndexListIterator;
1157
1158 class QManIndexList : public QManIndexListBase
1159 {
1160 public:
1161 private:
1162     int compareItems( Q3PtrCollection::Item s1, Q3PtrCollection::Item s2 )
1163         {
1164             struct man_index_t *m1 = (struct man_index_t *)s1;
1165             struct man_index_t *m2 = (struct man_index_t *)s2;
1166             int i;
1167             // compare the names of the pages
1168             // with the shorter length
1169             if (m1->manpage_len > m2->manpage_len)
1170             {
1171                 i = qstrnicmp(m1->manpage_begin,
1172                              m2->manpage_begin,
1173                              m2->manpage_len);
1174                 if (!i)
1175                     return 1;
1176                 return i;
1177             }
1178
1179             if (m1->manpage_len > m2->manpage_len)
1180             {
1181
1182                 i = qstrnicmp(m1->manpage_begin,
1183                              m2->manpage_begin,
1184                              m1->manpage_len);
1185                 if (!i)
1186                     return -1;
1187                 return i;
1188             }
1189
1190             return qstrnicmp(m1->manpage_begin,
1191                             m2->manpage_begin,
1192                             m1->manpage_len);
1193         }
1194 };
1195
1196 #endif /* !_USE_QSORT */
1197 #endif /* !_USE_OLD_CODE */
1198
1199
1200
1201
1202 void MANProtocol::showIndex(const QString& section)
1203 {
1204     QByteArray array;
1205     QTextStream os(&array, QIODevice::WriteOnly);
1206     os.setCodec( "UTF-8" );
1207
1208     // print header
1209     os << "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Strict//EN\">" << endl;
1210     os << "<html><head><meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">" << endl;
1211     os << "<title>" << i18n("UNIX Manual Index") << "</title>" << endl;
1212     if ( !m_manCSSFile.isEmpty() )
1213         os << "<link href=\"file:///" << m_manCSSFile << "\" type=\"text/css\" rel=\"stylesheet\">" << endl;
1214     os << "</head>" << endl;
1215     os << "<body><div class=\"secidxmain\">" << endl;
1216     os << "<h1>" << i18n( "Index for Section %1: %2", section, sectionName(section)) << "</h1>" << endl;
1217
1218     // compose list of search paths -------------------------------------------------------------
1219
1220     checkManPaths();
1221     infoMessage(i18n("Generating Index"));
1222
1223     // search for the man pages
1224         QStringList pages = findPages( section, QString() );
1225
1226         QMap<QString, QString> indexmap = buildIndexMap(section);
1227
1228     // print out the list
1229     os << "<table>" << endl;
1230
1231 #ifdef _USE_OLD_CODE
1232     pages.sort();
1233
1234     QMap<QString, QString> pagemap;
1235
1236     QStringList::ConstIterator page;
1237     for (page = pages.begin(); page != pages.end(); ++page)
1238     {
1239         QString fileName = *page;
1240
1241         stripExtension( &fileName );
1242
1243         pos = fileName.lastIndexOf('/');
1244         if (pos > 0)
1245             fileName = fileName.mid(pos+1);
1246
1247         if (!fileName.isEmpty())
1248             pagemap[fileName] = *page;
1249
1250     }
1251
1252     for (QMap<QString,QString>::ConstIterator it = pagemap.begin();
1253          it != pagemap.end(); ++it)
1254     {
1255         os << "<tr><td><a href=\"man:" << it.data() << "\">\n"
1256            << it.key() << "</a></td><td>&nbsp;</td><td> "
1257            << (indexmap.contains(it.key()) ? indexmap[it.key()] : "" )
1258            << "</td></tr>"  << endl;
1259     }
1260
1261 #else /* ! _USE_OLD_CODE */
1262
1263 #ifdef _USE_QSORT
1264
1265     int listlen = pages.count();
1266     man_index_ptr *indexlist = new man_index_ptr[listlen];
1267     listlen = 0;
1268
1269 #else /* !_USE_QSORT */
1270
1271     QManIndexList manpages;
1272     manpages.setAutoDelete(true);
1273
1274 #endif /* _USE_QSORT */
1275
1276     QStringList::const_iterator page;
1277     for (page = pages.begin(); page != pages.end(); ++page)
1278     {
1279         // I look for the beginning of the man page name
1280         // i.e. "bla/pagename.3.gz" by looking for the last "/"
1281         // Then look for the end of the name by searching backwards
1282         // for the last ".", not counting zip extensions.
1283         // If the len of the name is >0,
1284         // store it in the list structure, to be sorted later
1285
1286         char *manpage_end;
1287         struct man_index_t *manindex = new man_index_t;
1288         manindex->manpath = strdup((*page).toUtf8());
1289
1290         manindex->manpage_begin = strrchr(manindex->manpath, '/');
1291         if (manindex->manpage_begin)
1292         {
1293             manindex->manpage_begin++;
1294             assert(manindex->manpage_begin >= manindex->manpath);
1295         }
1296         else
1297         {
1298             manindex->manpage_begin = manindex->manpath;
1299             assert(manindex->manpage_begin >= manindex->manpath);
1300         }
1301
1302         // Skip extension ".section[.gz]"
1303
1304         char *begin = (char*)(manindex->manpage_begin);
1305         int len = strlen( begin );
1306         char *end = begin+(len-1);
1307
1308         if ( len >= 3 && strcmp( end-2, ".gz" ) == 0 )
1309             end -= 3;
1310         else if ( len >= 2 && strcmp( end-1, ".Z" ) == 0 )
1311             end -= 2;
1312         else if ( len >= 2 && strcmp( end-1, ".z" ) == 0 )
1313             end -= 2;
1314         else if ( len >= 4 && strcmp( end-3, ".bz2" ) == 0 )
1315             end -= 4;
1316
1317         while ( end >= begin && *end != '.' )
1318             end--;
1319
1320         if ( end < begin )
1321             manpage_end = 0;
1322         else
1323             manpage_end = end;
1324
1325         if (NULL == manpage_end)
1326         {
1327             // no '.' ending ???
1328             // set the pointer past the end of the filename
1329             manindex->manpage_len = (*page).length();
1330             manindex->manpage_len -= (manindex->manpage_begin - manindex->manpath);
1331             assert(manindex->manpage_len >= 0);
1332         }
1333         else
1334         {
1335             manindex->manpage_len = (manpage_end - manindex->manpage_begin);
1336             assert(manindex->manpage_len >= 0);
1337         }
1338
1339         if (0 < manindex->manpage_len)
1340         {
1341
1342 #ifdef _USE_QSORT
1343
1344             indexlist[listlen] = manindex;
1345             listlen++;
1346
1347 #else /* !_USE_QSORT */
1348
1349             manpages.append(manindex);
1350
1351 #endif /* _USE_QSORT */
1352
1353         }
1354     }
1355
1356     //
1357     // Now do the sorting on the page names
1358     // and the printout afterwards
1359     // While printing avoid duplicate man page names
1360     //
1361
1362     struct man_index_t dummy_index = {0l,0l,0};
1363     struct man_index_t *last_index = &dummy_index;
1364
1365 #ifdef _USE_QSORT
1366
1367     // sort and print
1368     qsort(indexlist, listlen, sizeof(struct man_index_t *), compare_man_index);
1369
1370     QChar firstchar, tmp;
1371     QString indexLine="<div class=\"secidxshort\">\n";
1372     if (indexlist[0]->manpage_len>0)
1373     {
1374         firstchar=QChar((indexlist[0]->manpage_begin)[0]).toLower();
1375
1376         const QString appendixstr = QString(
1377             " [<a href=\"#%1\" accesskey=\"%2\">%3</a>]\n"
1378         ).arg(firstchar).arg(firstchar).arg(firstchar);
1379         indexLine.append(appendixstr);
1380     }
1381     os << "<tr><td class=\"secidxnextletter\"" << " colspan=\"3\">\n  <a name=\""
1382        << firstchar << "\">" << firstchar <<"</a>\n</td></tr>" << endl;
1383
1384     for (int i=0; i<listlen; i++)
1385     {
1386         struct man_index_t *manindex = indexlist[i];
1387
1388         // qstrncmp():
1389         // "last_man" has already a \0 string ending, but
1390         // "manindex->manpage_begin" has not,
1391         // so do compare at most "manindex->manpage_len" of the strings.
1392         if (last_index->manpage_len == manindex->manpage_len &&
1393             !qstrncmp(last_index->manpage_begin,
1394                       manindex->manpage_begin,
1395                       manindex->manpage_len)
1396             )
1397         {
1398             continue;
1399         }
1400
1401         tmp=QChar((manindex->manpage_begin)[0]).toLower();
1402         if (firstchar != tmp)
1403         {
1404             firstchar = tmp;
1405             os << "<tr><td class=\"secidxnextletter\"" << " colspan=\"3\">\n  <a name=\""
1406                << firstchar << "\">" << firstchar << "</a>\n</td></tr>" << endl;
1407
1408             const QString appendixstr = QString(
1409                 " [<a href=\"#%1\" accesskey=\"%2\">%3</a>]\n"
1410             ).arg(firstchar).arg(firstchar).arg(firstchar);
1411             indexLine.append(appendixstr);
1412         }
1413         os << "<tr><td><a href=\"man:"
1414            << manindex->manpath << "\">\n";
1415
1416         ((char *)manindex->manpage_begin)[manindex->manpage_len] = '\0';
1417         os << manindex->manpage_begin
1418            << "</a></td><td>&nbsp;</td><td> "
1419            << (indexmap.contains(manindex->manpage_begin) ? indexmap[manindex->manpage_begin] : "" )
1420            << "</td></tr>"  << endl;
1421         last_index = manindex;
1422     }
1423     indexLine.append("</div>");
1424
1425     for (int i=0; i<listlen; i++) {
1426         ::free(indexlist[i]->manpath);   // allocated by strdup
1427         delete indexlist[i];
1428     }
1429
1430     delete [] indexlist;
1431
1432 #else /* !_USE_QSORT */
1433
1434     manpages.sort(); // using
1435
1436     for (QManIndexListIterator mit(manpages);
1437          mit.current();
1438          ++mit )
1439     {
1440         struct man_index_t *manindex = mit.current();
1441
1442         // qstrncmp():
1443         // "last_man" has already a \0 string ending, but
1444         // "manindex->manpage_begin" has not,
1445         // so do compare at most "manindex->manpage_len" of the strings.
1446         if (last_index->manpage_len == manindex->manpage_len &&
1447             !qstrncmp(last_index->manpage_begin,
1448                       manindex->manpage_begin,
1449                       manindex->manpage_len)
1450             )
1451         {
1452             continue;
1453         }
1454
1455         os << "<tr><td><a href=\"man:"
1456            << manindex->manpath << "\">\n";
1457
1458         manindex->manpage_begin[manindex->manpage_len] = '\0';
1459         os << manindex->manpage_begin
1460            << "</a></td><td>&nbsp;</td><td> "
1461            << (indexmap.contains(manindex->manpage_begin) ? indexmap[manindex->manpage_begin] : "" )
1462            << "</td></tr>"  << endl;
1463         last_index = manindex;
1464     }
1465 #endif /* _USE_QSORT */
1466 #endif /* _USE_OLD_CODE */
1467
1468     os << "</table></div>" << endl;
1469
1470     os << indexLine << endl;
1471
1472     // print footer
1473     os << "</body></html>" << endl;
1474
1475     infoMessage(QString());
1476     mimeType("text/html");
1477     data(array);
1478     finished();
1479 }
1480
1481 void MANProtocol::listDir(const KUrl &url)
1482 {
1483     kDebug( 7107 ) << "ENTER listDir: " << url.prettyUrl();
1484
1485     QString title;
1486     QString section;
1487
1488     if ( !parseUrl(url.path(), title, section) ) {
1489         error( KIO::ERR_MALFORMED_URL, url.url() );
1490         return;
1491     }
1492
1493     QStringList list = findPages( section, QString(), false );
1494
1495     UDSEntryList uds_entry_list;
1496
1497     QStringList::Iterator it = list.begin();
1498     const QStringList::Iterator end = list.end();
1499
1500     for ( ; it != end; ++it ) {
1501         stripExtension( &(*it) );
1502
1503         UDSEntry     uds_entry;
1504         uds_entry.insert( KIO::UDSEntry::UDS_NAME, *it );
1505         uds_entry_list.append( uds_entry );
1506     }
1507
1508     listEntries( uds_entry_list );
1509     finished();
1510 }
1511
1512 void MANProtocol::getProgramPath()
1513 {
1514   if (!mySgml2RoffPath.isEmpty())
1515     return;
1516
1517   mySgml2RoffPath = KGlobal::dirs()->findExe("sgml2roff");
1518   if (!mySgml2RoffPath.isEmpty())
1519     return;
1520
1521   /* sgml2roff isn't found in PATH. Check some possible locations where it may be found. */
1522   mySgml2RoffPath = KGlobal::dirs()->findExe("sgml2roff", QString(SGML2ROFF_DIRS));
1523   if (!mySgml2RoffPath.isEmpty())
1524     return;
1525
1526   /* Cannot find sgml2roff program: */
1527   outputError(i18n("Could not find the sgml2roff program on your system. Please install it, if necessary, and extend the search path by adjusting the environment variable PATH before starting KDE."));
1528   finished();
1529   exit();
1530 }