File indexing completed on 2024-12-15 04:13:43

 /*
     Kchmviewer - a CHM and EPUB file viewer with broad language support
     SPDX-FileCopyrightText: 2004-2014 George Yunaev gyunaev@ulduzsoft.com
 
     SPDX-License-Identifier: GPL-3.0-or-later
 */
 
 #include <QDebug>
 #include <QFile>
 #include <QVector>
 
 #include "ebook_chm.h"
 #include "ebook_chm_encoding.h"
 
 #include "bitfiddle.h"
 
 // Big-enough buffer size for use with various routines.
 #define BUF_SIZE 4096
 #define COMMON_BUF_LEN 1025
 
 #define TOPICS_ENTRY_LEN 16
 #define URLTBL_ENTRY_LEN 12
 
 //#define DEBUGPARSER(A)    qDebug A
 #define DEBUGPARSER(A)
 
 #define URL_SCHEME_CHM QStringLiteral("ms-its")
 
 EBook_CHM::EBook_CHM()
     : EBook()
     , m_chmFile(nullptr)
     , m_detectedLCID(0)
     , m_textCodec(nullptr)
     , m_textCodecForSpecialFiles(nullptr)
     , m_currentEncoding(QStringLiteral("UTF-8"))
     , m_envOptions(QString::fromLatin1(qgetenv("KCHMVIEWEROPTS")))
 {
 }
 
 EBook_CHM::~EBook_CHM()
 {
     close();
 }
 
 void EBook_CHM::close()
 {
     if (m_chmFile == nullptr) {
         return;
     }
 
     chm_close(m_chmFile);
 
     m_chmFile = nullptr;
     m_filename = m_font = QString();
 
     m_home.clear();
     m_topicsFile.clear();
     m_indexFile.clear();
 
     m_textCodec = nullptr;
     m_textCodecForSpecialFiles = nullptr;
     m_detectedLCID = 0;
     m_currentEncoding = QStringLiteral("UTF-8");
 }
 
 QString EBook_CHM::title() const
 {
     return encodeWithCurrentCodec(m_title);
 }
 
 QUrl EBook_CHM::homeUrl() const
 {
     return pathToUrl(QString::fromUtf8(m_home));
 }
 
 bool EBook_CHM::hasFeature(EBook::Feature code) const
 {
     switch (code) {
     case FEATURE_TOC:
         return m_tocAvailable;
 
     case FEATURE_INDEX:
         return m_indexAvailable;
 
     case FEATURE_ENCODING:
         return true;
     }
 
     return false;
 }
 
 bool EBook_CHM::getTableOfContents(QList<EBookTocEntry> &toc) const
 {
     if (parseBinaryTOC(toc)) {
         return true;
     }
 
     // Parse the plain text TOC
     QList<ParsedEntry> parsed;
 
     if (!parseFileAndFillArray(QString::fromUtf8(m_topicsFile), parsed, false)) {
         return false;
     }
 
     // Find out the root offset, and reduce the indent level to it
     // so the toc starts from zero offset.
     int root_offset = -1;
 
     // Fill up the real toc
     toc.reserve(parsed.size());
     for (const ParsedEntry &e : std::as_const(parsed)) {
         if (root_offset == -1) {
             root_offset = e.indent;
         }
 
         EBookTocEntry entry;
         entry.iconid = (EBookTocEntry::Icon)e.iconid;
         entry.indent = e.indent - root_offset;
         entry.name = e.name;
 
         if (!e.urls.empty()) {
             entry.url = e.urls[0];
         }
 
         toc.append(entry);
     }
 
     return true;
 }
 
 bool EBook_CHM::getIndex(QList<EBookIndexEntry> &index) const
 {
     // Parse the plain text index
     QList<ParsedEntry> parsed;
 
     if (!parseFileAndFillArray(QString::fromUtf8(m_indexFile), parsed, true)) {
         return false;
     }
 
     // Find out the root offset, and reduce the indent level to it
     // so the index starts from zero offset.
     int root_offset = 0;
 
     // Fill up the real index
     index.reserve(parsed.size());
 
     // Find the index root offset
     const QList<ParsedEntry> &parsedList = parsed;
     for (const ParsedEntry &e : parsedList) {
         if (e.urls.empty()) {
             continue;
         }
 
         root_offset = qMin(root_offset, e.indent);
     }
 
     // And apply the index
     for (const ParsedEntry &e : parsedList) {
         if (e.urls.empty()) {
             continue;
         }
 
         EBookIndexEntry entry;
         entry.name = e.name;
         entry.urls = e.urls;
         entry.seealso = e.seealso;
 
         // If the index array is empty, make sure the first entry is on root offset
         if (index.isEmpty()) {
             entry.indent = root_offset;
         } else {
             entry.indent = e.indent - root_offset;
         }
 
         index.append(entry);
         printf("%d: %s\n", entry.indent, qPrintable(entry.name));
     }
 
     return true;
 }
 
 bool EBook_CHM::getFileContentAsString(QString &str, const QUrl &url) const
 {
     return getTextContent(str, urlToPath(url));
 }
 
 bool EBook_CHM::getFileContentAsBinary(QByteArray &data, const QUrl &url) const
 {
     return getBinaryContent(data, urlToPath(url));
 }
 
 bool EBook_CHM::getBinaryContent(QByteArray &data, const QString &url) const
 {
     chmUnitInfo ui;
 
     if (!ResolveObject(url, &ui)) {
         return false;
     }
 
     data.resize(ui.length);
 
     if (RetrieveObject(&ui, (unsigned char *)data.data(), 0, ui.length)) {
         return true;
     }
 
     return false;
 }
 
 bool EBook_CHM::getTextContent(QString &str, const QString &url, bool internal_encoding) const
 {
     QByteArray buf;
 
     if (getBinaryContent(buf, url)) {
         unsigned int length = buf.size();
 
         if (length > 0) {
             buf.resize(length + 1);
             buf[length] = '\0';
 
             str = internal_encoding ? QString::fromUtf8(buf.constData()) : encodeWithCurrentCodec(buf.constData());
             return true;
         }
     }
 
     return false;
 }
 
 int EBook_CHM::getContentSize(const QString &url)
 {
     chmUnitInfo ui;
 
     if (!ResolveObject(url, &ui)) {
         return -1;
     }
 
     return ui.length;
 }
 
 bool EBook_CHM::load(const QString &archiveName)
 {
     QString filename;
 
     // If the file has a file:// prefix, remove it
     if (archiveName.startsWith(QLatin1String("file://"))) {
         filename = archiveName.mid(7); // strip it
     } else {
         filename = archiveName;
     }
 
     if (m_chmFile) {
         close();
     }
 
 #if defined(WIN32)
     m_chmFile = chm_open((BSTR)QFile::encodeName(filename).constData());
 #else
     m_chmFile = chm_open(QFile::encodeName(filename).constData());
 #endif
 
     if (m_chmFile == nullptr) {
         return false;
     }
 
     m_filename = filename;
 
     // Reset encoding
     m_textCodec = nullptr;
     m_textCodecForSpecialFiles = nullptr;
     m_currentEncoding = QStringLiteral("UTF-8");
 
     // Get information from /#WINDOWS and /#SYSTEM files (encoding, title, context file and so)
     // and guess the encoding
     getInfoFromWindows();
     getInfoFromSystem();
     guessTextEncoding();
 
     // Check whether the search tables are present
     if (ResolveObject(QStringLiteral("/#TOPICS"), &m_chmTOPICS) && ResolveObject(QStringLiteral("/#STRINGS"), &m_chmSTRINGS) && ResolveObject(QStringLiteral("/#URLTBL"), &m_chmURLTBL) &&
         ResolveObject(QStringLiteral("/#URLSTR"), &m_chmURLSTR)) {
         m_lookupTablesValid = true;
         fillTopicsUrlMap();
     } else {
         m_lookupTablesValid = false;
     }
 
     // Some CHM files have toc and index files, but do not set the name properly.
     // Some heuristics here.
     if (m_topicsFile.isEmpty() && hasFile(QStringLiteral("/toc.hhc"))) {
         m_topicsFile = "/toc.hhc";
     }
 
     if (m_indexFile.isEmpty() && hasFile(QStringLiteral("/index.hhk"))) {
         m_indexFile = "/index.hhk";
     }
 
     if (!m_topicsFile.isEmpty() || (m_lookupTablesValid && hasFile(QStringLiteral("/#TOCIDX")))) {
         m_tocAvailable = true;
     } else {
         m_tocAvailable = false;
     }
 
     if (!m_indexFile.isEmpty() || (m_lookupTablesValid && hasFile(QStringLiteral("/$WWKeywordLinks/BTree")))) {
         m_indexAvailable = true;
     } else {
         m_indexAvailable = false;
     }
 
     return true;
 }
 
 int EBook_CHM::findStringInQuotes(const QString &tag, int offset, QString &value, bool firstquote, bool decodeentities) const
 {
     int qbegin = tag.indexOf(QLatin1Char('"'), offset);
 
     if (qbegin == -1) {
         qFatal("EBook_CHMImpl::findStringInQuotes: cannot find first quote in <param> tag: '%s'", qPrintable(tag));
     }
 
     int qend = firstquote ? tag.indexOf(QLatin1Char('"'), qbegin + 1) : tag.lastIndexOf(QLatin1Char('"'));
 
     if (qend == -1 || qend <= qbegin) {
         qFatal("EBook_CHMImpl::findStringInQuotes: cannot find last quote in <param> tag: '%s'", qPrintable(tag));
     }
 
     // If we do not need to decode HTML entities, just return.
     if (decodeentities) {
         QString htmlentity = QString();
         bool fill_entity = false;
 
         value.reserve(qend - qbegin); // to avoid multiple memory allocations
 
         for (int i = qbegin + 1; i < qend; i++) {
             if (!fill_entity) {
                 if (tag[i] == QLatin1Char('&')) { // HTML entity starts
                     fill_entity = true;
                 } else {
                     value.append(tag[i]);
                 }
             } else {
                 if (tag[i] == QLatin1Char(';')) // HTML entity ends
                 {
                     // If entity is an ASCII code, just decode it
                     QString decode = m_htmlEntityDecoder.decode(htmlentity);
 
                     if (decode.isNull()) {
                         break;
                     }
 
                     value.append(decode);
                     htmlentity = QString();
                     fill_entity = false;
                 } else {
                     htmlentity.append(tag[i]);
                 }
             }
         }
     } else {
         value = tag.mid(qbegin + 1, qend - qbegin - 1);
     }
 
     return qend + 1;
 }
 
 bool EBook_CHM::parseFileAndFillArray(const QString &file, QList<ParsedEntry> &data, bool asIndex) const
 {
     QString src;
     const int MAX_NEST_DEPTH = 256;
 
     if (!getTextContent(src, file) || src.isEmpty()) {
         return false;
     }
 
     /*
         // Save the index for debugging purposes
         QFile outfile( "parsed.htm" );
 
         if ( outfile.open( QIODevice::WriteOnly ) )
         {
             QTextStream textstream( &outfile );
             textstream << src;
             outfile.close();
         }
     */
 
     EBookTocEntry::Icon defaultimagenum = EBookTocEntry::IMAGE_AUTO;
     int pos = 0, indent = 0, root_indent_offset = 0;
     bool in_object = false, root_indent_offset_set = false;
 
     ParsedEntry entry;
     entry.iconid = defaultimagenum;
 
     // Split the HHC file by HTML tags
     int stringlen = src.length();
 
     while (pos < stringlen && (pos = src.indexOf(QLatin1Char('<'), pos)) != -1) {
         int i, word_end = 0;
 
         for (i = ++pos; i < stringlen; i++) {
             // If a " or ' is found, skip to the next one.
             if ((src[i] == QLatin1Char('"') || src[i] == QLatin1Char('\''))) {
                 // find where quote ends, either by another quote, or by '>' symbol (some people don't know HTML)
                 int nextpos = src.indexOf(src[i], i + 1);
                 if (nextpos == -1 && (nextpos = src.indexOf(QLatin1Char('>'), i + 1)) == -1) {
                     qWarning("EBook_CHMImpl::ParseHhcAndFillTree: corrupted TOC: %s", qPrintable(src.mid(i)));
                     return false;
                 }
 
                 i = nextpos;
             } else if (src[i] == QLatin1Char('>')) {
                 break;
             } else if (!src[i].isLetterOrNumber() && src[i] != QLatin1Char('/') && !word_end) {
                 word_end = i;
             }
         }
 
         QString tagword, tag = src.mid(pos, i - pos);
 
         if (word_end) {
             tagword = src.mid(pos, word_end - pos).toLower();
         } else {
             tagword = tag.toLower();
         }
 
         // DEBUGPARSER(("tag: '%s', tagword: '%s'\n", qPrintable( tag ), qPrintable( tagword ) ));
 
         // <OBJECT type="text/sitemap"> - a topic entry
         if (tagword == QLatin1String("object") && tag.indexOf(QLatin1String("text/sitemap"), 0, Qt::CaseInsensitive) != -1) {
             in_object = true;
         } else if (tagword == QLatin1String("/object") && in_object) {
             // a topic entry closed. Add a tree item
             if (entry.name.isEmpty() && entry.urls.isEmpty()) {
                 qWarning("EBook_CHMImpl::ParseAndFillTopicsTree: <object> tag is parsed, but both name and url are empty.");
             } else {
                 // If the name is empty, use the URL as name
                 if (entry.name.isEmpty()) {
                     entry.name = entry.urls[0].toString();
                 }
 
                 if (!root_indent_offset_set) {
                     root_indent_offset_set = true;
                     root_indent_offset = indent;
 
                     if (root_indent_offset > 1) {
                         qWarning("CHM has improper index; root indent offset is %d", root_indent_offset);
                     }
                 }
 
                 // Trim the entry name
                 entry.name = entry.name.trimmed();
 
                 int real_indent = indent - root_indent_offset;
 
                 entry.indent = real_indent;
                 data.push_back(entry);
             }
 
             entry.name = QString();
             entry.urls.clear();
             entry.iconid = defaultimagenum;
             entry.seealso.clear();
             in_object = false;
         } else if (tagword == QLatin1String("param") && in_object) {
             // <param name="Name" value="First Page">
             int offset; // strlen("param ")
             const QString name_pattern = QStringLiteral("name="), value_pattern = QStringLiteral("value=");
             QString pname, pvalue;
 
             if ((offset = tag.indexOf(name_pattern, 0, Qt::CaseInsensitive)) == -1) {
                 qFatal("EBook_CHMImpl::ParseAndFillTopicsTree: bad <param> tag '%s': no name=\n", qPrintable(tag));
             }
 
             // offset+5 skips 'name='
             offset = findStringInQuotes(tag, offset + name_pattern.length(), pname, true, false);
             pname = pname.toLower();
 
             if ((offset = tag.indexOf(value_pattern, offset, Qt::CaseInsensitive)) == -1) {
                 qFatal("EBook_CHMImpl::ParseAndFillTopicsTree: bad <param> tag '%s': no value=\n", qPrintable(tag));
             }
 
             // offset+6 skips 'value='
             findStringInQuotes(tag, offset + value_pattern.length(), pvalue, false, true);
 
             // DEBUGPARSER(("<param>: name '%s', value '%s'", qPrintable( pname ), qPrintable( pvalue )));
 
             if (pname == QLatin1String("name") || pname == QLatin1String("keyword")) {
                 // Some help files contain duplicate names, where the second name is empty. Work it around by keeping the first one
                 if (!pvalue.isEmpty()) {
                     entry.name = pvalue;
                 }
             } else if (pname == QLatin1String("merge")) {
                 // MERGE implementation is experimental
                 QUrl mergeurl = pathToUrl(pvalue);
                 QString mergecontent;
 
                 if (getFileContentAsString(mergecontent, mergeurl) && !mergecontent.isEmpty()) {
                     qWarning("MERGE is used in index; the implementation is experimental. Please let me know if it works");
 
                     // Merge the read value into the current parsed file.
                     // To save memory it is done in a kinda hacky way:
                     src = mergecontent + src.mid(i);
                     pos = 0;
                     stringlen = src.length();
                 } else {
                     qWarning("MERGE is used in index but file %s was not found in CHM archive", qPrintable(pvalue));
                 }
             } else if (pname == QLatin1String("local")) {
                 // Check for URL duplication
                 QUrl url = pathToUrl(pvalue);
 
                 if (!entry.urls.contains(url)) {
                     entry.urls.push_back(url);
                 }
             } else if (pname == QLatin1String("see also") && asIndex && entry.name != pvalue) {
                 entry.urls.push_back(QUrl(QStringLiteral("seealso")));
                 entry.seealso = pvalue;
             } else if (pname == QLatin1String("imagenumber")) {
                 bool bok;
                 int imgnum = pvalue.toInt(&bok);
 
                 if (bok && imgnum >= 0 && imgnum < EBookTocEntry::MAX_BUILTIN_ICONS) {
                     entry.iconid = (EBookTocEntry::Icon)imgnum;
                 }
             }
         } else if (tagword == QLatin1String("ul")) // increase indent level
         {
             // Fix for buggy help files
             if (++indent >= MAX_NEST_DEPTH) {
                 qFatal("EBook_CHMImpl::ParseAndFillTopicsTree: max nest depth (%d) is reached, error in help file", MAX_NEST_DEPTH);
             }
 
             DEBUGPARSER(("<ul>: new intent is %d\n", indent - root_indent_offset));
         } else if (tagword == QLatin1String("/ul")) // decrease indent level
         {
             if (--indent < root_indent_offset) {
                 indent = root_indent_offset;
             }
 
             DEBUGPARSER(("</ul>: new intent is %d\n", indent - root_indent_offset));
         }
 
         pos = i;
     }
 
     // Dump our array
     //    for ( int i = 0; i < data.size(); i++ )
     //        qDebug() << data[i].indent << data[i].name << data[i].urls;
 
     return true;
 }
 
 bool EBook_CHM::ResolveObject(const QString &fileName, chmUnitInfo *ui) const
 {
     return m_chmFile != nullptr && ::chm_resolve_object(m_chmFile, qPrintable(fileName), ui) == CHM_RESOLVE_SUCCESS;
 }
 
 bool EBook_CHM::hasFile(const QString &fileName) const
 {
     chmUnitInfo ui;
 
     return m_chmFile != nullptr && ::chm_resolve_object(m_chmFile, qPrintable(fileName), &ui) == CHM_RESOLVE_SUCCESS;
 }
 
 size_t EBook_CHM::RetrieveObject(const chmUnitInfo *ui, unsigned char *buffer, LONGUINT64 fileOffset, LONGINT64 bufferSize) const
 {
     return ::chm_retrieve_object(m_chmFile, const_cast<chmUnitInfo *>(ui), buffer, fileOffset, bufferSize);
 }
 
 bool EBook_CHM::getInfoFromWindows()
 {
 #define WIN_HEADER_LEN 0x08
     unsigned char buffer[BUF_SIZE];
     unsigned int factor;
     chmUnitInfo ui;
     long size = 0;
 
     if (ResolveObject(QStringLiteral("/#WINDOWS"), &ui)) {
         if (!RetrieveObject(&ui, buffer, 0, WIN_HEADER_LEN)) {
             return false;
         }
 
         unsigned int entries = get_int32_le(reinterpret_cast<unsigned int *>(buffer));
         unsigned int entry_size = get_int32_le(reinterpret_cast<unsigned int *>(buffer + 0x04));
 
         QVector<unsigned char> uptr(entries * entry_size);
         unsigned char *raw = (unsigned char *)uptr.data();
 
         if (!RetrieveObject(&ui, raw, 8, entries * entry_size)) {
             return false;
         }
 
         if (!ResolveObject(QStringLiteral("/#STRINGS"), &ui)) {
             return false;
         }
 
         for (unsigned int i = 0; i < entries; ++i) {
             unsigned int offset = i * entry_size;
 
             unsigned int off_title = get_int32_le(reinterpret_cast<unsigned int *>(raw + offset + 0x14));
             unsigned int off_home = get_int32_le(reinterpret_cast<unsigned int *>(raw + offset + 0x68));
             unsigned int off_hhc = get_int32_le(reinterpret_cast<unsigned int *>(raw + offset + 0x60));
             unsigned int off_hhk = get_int32_le(reinterpret_cast<unsigned int *>(raw + offset + 0x64));
 
             factor = off_title / 4096;
 
             if (size == 0) {
                 size = RetrieveObject(&ui, buffer, factor * 4096, BUF_SIZE);
             }
 
             if (size && off_title) {
                 m_title = QByteArray((const char *)(buffer + off_title % 4096));
             }
 
             if (factor != off_home / 4096) {
                 factor = off_home / 4096;
                 size = RetrieveObject(&ui, buffer, factor * 4096, BUF_SIZE);
             }
 
             if (size && off_home) {
                 m_home = QByteArray("/") + QByteArray((const char *)buffer + off_home % 4096);
             }
 
             if (factor != off_hhc / 4096) {
                 factor = off_hhc / 4096;
                 size = RetrieveObject(&ui, buffer, factor * 4096, BUF_SIZE);
             }
 
             if (size && off_hhc) {
                 m_topicsFile = QByteArray("/") + QByteArray((const char *)buffer + off_hhc % 4096);
             }
 
             if (factor != off_hhk / 4096) {
                 factor = off_hhk / 4096;
                 size = RetrieveObject(&ui, buffer, factor * 4096, BUF_SIZE);
             }
 
             if (size && off_hhk) {
                 m_indexFile = QByteArray("/") + QByteArray((const char *)buffer + off_hhk % 4096);
             }
         }
     }
     return true;
 }
 
 bool EBook_CHM::getInfoFromSystem()
 {
     unsigned char buffer[BUF_SIZE];
     chmUnitInfo ui;
 
     int index = 0;
     unsigned char *cursor = nullptr, *p;
     unsigned short value = 0;
     long size = 0;
 
     // Run the first loop to detect the encoding. We need this, because title could be
     // already encoded in user encoding. Same for file names
     if (!ResolveObject(QStringLiteral("/#SYSTEM"), &ui)) {
         return false;
     }
 
     // Can we pull BUFF_SIZE bytes of the #SYSTEM file?
     if ((size = RetrieveObject(&ui, buffer, 4, BUF_SIZE)) == 0) {
         return false;
     }
 
     buffer[size - 1] = 0;
 
     // First loop to detect the encoding
     for (index = 0; index < (size - 1 - (long)sizeof(unsigned short));) {
         cursor = buffer + index;
         value = UINT16ARRAY(cursor);
 
         switch (value) {
         case 0:
             index += 2;
             cursor = buffer + index;
 
             if (m_topicsFile.isEmpty()) {
                 m_topicsFile = QByteArray("/") + QByteArray((const char *)buffer + index + 2);
             }
 
             break;
 
         case 1:
             index += 2;
             cursor = buffer + index;
 
             if (m_indexFile.isEmpty()) {
                 m_indexFile = QByteArray("/") + QByteArray((const char *)buffer + index + 2);
             }
             break;
 
         case 2:
             index += 2;
             cursor = buffer + index;
 
             if (m_home.isEmpty() || m_home == "/") {
                 m_home = QByteArray("/") + QByteArray((const char *)buffer + index + 2);
             }
             break;
 
         case 3:
             index += 2;
             cursor = buffer + index;
             m_title = QByteArray((const char *)(buffer + index + 2));
             break;
 
         case 4:
             index += 2;
             cursor = buffer + index;
 
             p = buffer + index + 2;
             m_detectedLCID = (short)(p[0] | (p[1] << 8));
 
             break;
 
         case 6:
             index += 2;
             cursor = buffer + index;
 
             if (m_topicsFile.isEmpty()) {
                 QString topicAttempt = QStringLiteral("/");
                 topicAttempt += QString(QString::fromUtf8((const char *)buffer + index + 2));
 
                 QString tmp = topicAttempt + QStringLiteral(".hhc");
 
                 if (ResolveObject(tmp, &ui)) {
                     m_topicsFile = qPrintable(tmp);
                 }
 
                 tmp = topicAttempt + QStringLiteral(".hhk");
 
                 if (ResolveObject(tmp, &ui)) {
                     m_indexFile = qPrintable(tmp);
                 }
             }
             break;
 
         case 16:
             index += 2;
             cursor = buffer + index;
 
             m_font = QString(QString::fromUtf8((const char *)buffer + index + 2));
             break;
 
         default:
             index += 2;
             cursor = buffer + index;
         }
 
         value = UINT16ARRAY(cursor);
         index += value + 2;
     }
 
     return true;
 }
 
 QString EBook_CHM::getTopicByUrl(const QUrl &url)
 {
     QMap<QUrl, QString>::const_iterator it = m_url2topics.constFind(url);
 
     if (it == m_url2topics.constEnd()) {
         return QString();
     }
 
     return it.value();
 }
 
 static int chm_enumerator_callback(struct chmFile *, struct chmUnitInfo *ui, void *context)
 {
     EBook_CHM tmp;
     ((QList<QUrl> *)context)->push_back(tmp.pathToUrl(QString::fromUtf8(ui->path)));
     return CHM_ENUMERATOR_CONTINUE;
 }
 
 bool EBook_CHM::enumerateFiles(QList<QUrl> &files)
 {
     files.clear();
     return chm_enumerate(m_chmFile, CHM_ENUMERATE_ALL, chm_enumerator_callback, &files);
 }
 
 QString EBook_CHM::currentEncoding() const
 {
     return m_currentEncoding;
 }
 
 bool EBook_CHM::setCurrentEncoding(const char *encoding)
 {
     m_currentEncoding = QString::fromUtf8(encoding);
     return changeFileEncoding(m_currentEncoding);
 }
 
 bool EBook_CHM::isSupportedUrl(const QUrl &url)
 {
     return url.scheme() == URL_SCHEME_CHM;
 }
 
 bool EBook_CHM::guessTextEncoding()
 {
     if (!m_detectedLCID) {
         qWarning("Could not detect LCID");
         return false;
     }
 
     QString enc = Ebook_CHM_Encoding::guessByLCID(m_detectedLCID);
 
     if (changeFileEncoding(enc)) {
         m_currentEncoding = enc;
         return true;
     }
 
     return false;
 }
 
 bool EBook_CHM::changeFileEncoding(const QString &qtencoding)
 {
     // Encoding could be either simple Qt codepage, or set like CP1251/KOI8, which allows to
     // set up encodings separately for text (first) and internal files (second)
     int p = qtencoding.indexOf(QLatin1Char('/'));
 
     if (p != -1) {
         QString global = qtencoding.left(p);
         QString special = qtencoding.mid(p + 1);
 
         m_textCodec = QTextCodec::codecForName(global.toUtf8());
 
         if (!m_textCodec) {
             qWarning("Could not set up Text Codec for encoding '%s'", qPrintable(global));
             return false;
         }
 
         m_textCodecForSpecialFiles = QTextCodec::codecForName(special.toUtf8());
 
         if (!m_textCodecForSpecialFiles) {
             qWarning("Could not set up Text Codec for encoding '%s'", qPrintable(special));
             return false;
         }
     } else {
         m_textCodecForSpecialFiles = m_textCodec = QTextCodec::codecForName(qtencoding.toUtf8());
 
         if (!m_textCodec) {
             qWarning("Could not set up Text Codec for encoding '%s'", qPrintable(qtencoding));
             return false;
         }
     }
 
     m_htmlEntityDecoder.changeEncoding(m_textCodec);
     return true;
 }
 
 void EBook_CHM::fillTopicsUrlMap()
 {
     if (!m_lookupTablesValid) {
         return;
     }
 
     // Read those tables
     QVector<unsigned char> topics(m_chmTOPICS.length), urltbl(m_chmURLTBL.length), urlstr(m_chmURLSTR.length), strings(m_chmSTRINGS.length);
 
     if (!RetrieveObject(&m_chmTOPICS, (unsigned char *)topics.data(), 0, m_chmTOPICS.length) || !RetrieveObject(&m_chmURLTBL, (unsigned char *)urltbl.data(), 0, m_chmURLTBL.length) ||
         !RetrieveObject(&m_chmURLSTR, (unsigned char *)urlstr.data(), 0, m_chmURLSTR.length) || !RetrieveObject(&m_chmSTRINGS, (unsigned char *)strings.data(), 0, m_chmSTRINGS.length)) {
         return;
     }
 
     for (LONGUINT64 i = 0; i < m_chmTOPICS.length; i += TOPICS_ENTRY_LEN) {
         unsigned int off_title = get_int32_le(reinterpret_cast<unsigned int *>(topics.data() + i + 4));
         unsigned int off_url = get_int32_le(reinterpret_cast<unsigned int *>(topics.data() + i + 8));
         off_url = get_int32_le(reinterpret_cast<unsigned int *>(urltbl.data() + off_url + 8)) + 8;
 
         QUrl url = pathToUrl(QString::fromUtf8((const char *)urlstr.data() + off_url));
 
         if (off_title < (unsigned int)strings.size()) {
             m_url2topics[url] = encodeWithCurrentCodec((const char *)strings.data() + off_title);
         } else {
             m_url2topics[url] = QStringLiteral("Untitled");
         }
     }
 }
 
 bool EBook_CHM::parseBinaryTOC(QList<EBookTocEntry> &toc) const
 {
     if (!m_lookupTablesValid) {
         return false;
     }
 
     QByteArray tocidx, topics, urltbl, urlstr, strings;
 
     // Read the index tables
     if (!getBinaryContent(tocidx, QStringLiteral("/#TOCIDX")) || !getBinaryContent(topics, QStringLiteral("/#TOPICS")) || !getBinaryContent(urltbl, QStringLiteral("/#URLTBL")) || !getBinaryContent(urlstr, QStringLiteral("/#URLSTR")) ||
         !getBinaryContent(strings, QStringLiteral("/#STRINGS"))) {
         return false;
     }
 
     // Shamelessly stolen from xchm
     if (!RecurseLoadBTOC(tocidx, topics, urltbl, urlstr, strings, UINT32ARRAY(tocidx.data()), toc, 0)) {
         qWarning("Failed to parse binary TOC, fallback to text-based TOC");
         toc.clear();
         return false;
     }
 
     return true;
 }
 
 //
 // This piece of code was based on the one in xchm written by  Razvan Cojocaru <razvanco@gmx.net>
 //
 bool EBook_CHM::RecurseLoadBTOC(const QByteArray &tocidx, const QByteArray &topics, const QByteArray &urltbl, const QByteArray &urlstr, const QByteArray &strings, int offset, QList<EBookTocEntry> &entries, int level) const
 {
     while (offset) {
         // If this is end of TOCIDX, return.
         if (tocidx.size() < offset + 20) {
             return true;
         }
 
         unsigned int flags = UINT32ARRAY(tocidx.data() + offset + 4);
         int index = UINT32ARRAY(tocidx.data() + offset + 8);
 
         if ((flags & 0x04) || (flags & 0x08)) {
             QString name, value;
 
             if ((flags & 0x08) == 0) {
                 if (strings.size() < index + 1) {
                     qWarning("EBook_CHM::RecurseLoadBTOC: invalid name index (%d) for book TOC entry!", index);
                     return false;
                 }
 
                 name = encodeWithCurrentCodec(strings.data() + index);
             } else {
                 if (topics.size() < (index * 16) + 12) {
                     qWarning("EBook_CHM::RecurseLoadBTOC: invalid name index (%d) for local TOC entry!", index);
                     return false;
                 }
 
                 int tocoffset = (int)UINT32ARRAY(topics.data() + (index * 16) + 4);
 
                 if (strings.size() < tocoffset + 1) {
                     qWarning("EBook_CHM::RecurseLoadBTOC: invalid name tocoffset (%d) for TOC entry!", tocoffset);
                     return false;
                 }
 
                 if (tocoffset < 0) {
                     name.clear();
                 } else {
                     name = encodeWithCurrentCodec(strings.data() + tocoffset);
                 }
 
                 // #URLTBL index
                 tocoffset = (int)UINT32ARRAY(topics.data() + (index * 16) + 8);
 
                 if (tocoffset < 0 || urltbl.size() < tocoffset + 12) {
                     qWarning("EBook_CHM::RecurseLoadBTOC: invalid url index (%d) for TOC entry!", tocoffset);
                     return false;
                 }
 
                 tocoffset = (int)UINT32ARRAY(urltbl.data() + tocoffset + 8);
 
                 if (tocoffset < 0 || urlstr.size() < tocoffset) {
                     qWarning("EBook_CHM::RecurseLoadBTOC: invalid url offset (%d) for TOC entry!", tocoffset);
                     return false;
                 }
 
                 value = encodeWithCurrentCodec(urlstr.data() + tocoffset + 8);
             }
 
             EBookTocEntry entry;
             entry.name = name.trimmed();
 
             if (!entry.name.isEmpty()) {
                 if (!value.isEmpty()) {
                     entry.url = pathToUrl(value);
                 }
 
                 entry.iconid = EBookTocEntry::IMAGE_AUTO;
                 entry.indent = level;
                 entries.push_back(entry);
             }
         }
 
         if (flags & 0x04) {
             // book
             if (tocidx.size() < offset + 24) {
                 qWarning("EBook_CHM::RecurseLoadBTOC: invalid child entry offset (%d)", offset);
                 return false;
             }
 
             unsigned int childoffset = UINT32ARRAY(tocidx.data() + offset + 20);
 
             if (childoffset) {
                 if (!RecurseLoadBTOC(tocidx, topics, urltbl, urlstr, strings, childoffset, entries, level + 1)) {
                     return false;
                 }
             }
         }
 
         offset = UINT32ARRAY(tocidx.data() + offset + 0x10);
     }
 
     return true;
 }
 
 bool EBook_CHM::hasOption(const QString &name) const
 {
     if (!m_envOptions.isEmpty() && m_envOptions.contains(name)) {
         return true;
     }
 
     return false;
 }
 
 QUrl EBook_CHM::pathToUrl(const QString &link) const
 {
     if (link.startsWith(QLatin1String("http://")) || link.startsWith(QLatin1String("https://"))) {
         return QUrl(link);
     }
 
     QUrl url;
     url.setScheme(URL_SCHEME_CHM);
     url.setHost(URL_SCHEME_CHM);
 
     // Does the link contain the fragment as well?
     int off = link.indexOf(QLatin1Char('#'));
     QString path;
 
     if (off != -1) {
         path = link.left(off);
         url.setFragment(link.mid(off + 1));
     } else {
         path = link;
     }
 
     if (!path.startsWith(QLatin1Char('/'))) {
         path.prepend(QLatin1Char('/'));
     }
 
     url.setPath(QUrl::fromPercentEncoding(path.toUtf8()));
     return url;
 }
 
 QString EBook_CHM::urlToPath(const QUrl &link) const
 {
     if (link.scheme() == URL_SCHEME_CHM) {
         if (link.path() == QLatin1String("/") || link.path().isEmpty()) {
             return QString::fromUtf8(m_home);
         }
 
         return link.path();
     }
 
     return QLatin1String("");
 }
 
 EBook_CHM::ParsedEntry::ParsedEntry()
 {
     iconid = 0;
     indent = 0;
 }