File indexing completed on 2024-05-12 03:56:42

 /*
     This file is part of the KDE libraries
     SPDX-FileCopyrightText: 1999-2000 Waldo Bastian <bastian@kde.org>
     SPDX-FileCopyrightText: 1999 Mario Weilguni <mweilguni@sime.com>
     SPDX-FileCopyrightText: 2001 Lubos Lunak <l.lunak@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-only
 */
 
 #include <cerrno>
 #include <locale.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include <QFile>
 #include <QLibrary>
 #include <QPluginLoader>
 #include <QString>
 
 #ifdef Q_OS_WIN
 #include <QProcess>
 #include <QStandardPaths>
 #include <QStringList>
 
 #include <process.h>
 #include <qt_windows.h>
 #endif
 
 #ifndef Q_OS_WIN
 #include <unistd.h>
 
 /* These are to link libkio even if 'smart' linker is used */
 #include <kio/authinfo.h>
 extern "C" KIO::AuthInfo *_kioworker_init_kio()
 {
     return new KIO::AuthInfo();
 }
 #endif
 
 int main(int argc, char **argv)
 {
     if (argc < 5) {
         fprintf(stderr, "Usage: kioworker <worker-lib> <protocol> <klauncher-socket> <app-socket>\n\nThis program is part of KDE.\n");
         return 1;
     }
 
     setlocale(LC_ALL, "");
     QString libname = QFile::decodeName(argv[1]);
 
     if (libname.isEmpty()) {
         fprintf(stderr, "library path is empty.\n");
         return 1;
     }
 
     // Use QPluginLoader to locate the library when using a relative path
     // But we need to use QLibrary to actually load it, because of resolve()!
     QString libpath = QPluginLoader(libname).fileName();
     if (libpath.isEmpty()) {
         fprintf(stderr, "could not locate %s, check QT_PLUGIN_PATH\n", qPrintable(libname));
         return 1;
     }
 
     QLibrary lib(libpath);
     if (!lib.load()) {
         fprintf(stderr, "could not open %s: %s\n", qPrintable(libname), qPrintable(lib.errorString()));
         return 1;
     }
 
     QFunctionPointer sym = lib.resolve("kdemain");
     if (!sym) {
         fprintf(stderr, "Could not find kdemain: %s\n", qPrintable(lib.errorString()));
         return 1;
     }
 
     const QByteArray workerDebugWait = qgetenv("KIOWORKER_DEBUG_WAIT");
 
 #ifdef Q_OS_WIN
     // enter debugger in case debugging is activated
     if (workerDebugWait == "all" || workerDebugWait == argv[2]) {
 #ifdef Q_CC_MSVC
         // msvc debugger or windbg supports jit debugging, the latter requires setting up windbg jit with windbg -i
         DebugBreak();
 #else
         // gdb does not support win32 jit debug support, so implement it by ourself
         WCHAR buf[1024];
         GetModuleFileName(NULL, buf, 1024);
         QStringList params;
         params << QString::fromUtf16(reinterpret_cast<const char16_t *>(buf));
         params << QString::number(GetCurrentProcessId());
         const QString gdbExec = QStandardPaths::findExecutable(QStringLiteral("gdb"));
         if (gdbExec.isEmpty()) {
             fprintf(stderr, "Could not find 'gdb' executable in PATH\n");
             return 1;
         }
         QProcess::startDetached(gdbExec, params);
         Sleep(1000);
 #endif
     }
 #if defined(Q_CC_MSVC)
     else {
         QString workerDebugPopup(QString::fromLocal8Bit(qgetenv("KIOWORKER_DEBUG_POPUP")));
         if (workerDebugPopup == QLatin1String("all") || workerDebugPopup == QString::fromLocal8Bit(argv[2])) {
             // A workaround for OSes where DebugBreak() does not work in administrative mode (actually Vista with msvc 2k5)
             // - display a native message box so developer can attach the debugger to the KIO worker process and click OK.
             MessageBoxA(
                 NULL,
                 QStringLiteral("Please attach the debugger to process #%1 (%2)").arg(getpid()).arg(QString::fromLocal8Bit(argv[0])).toLatin1().constData(),
                 QStringLiteral("\"%1\" KIO Worker Debugging").arg(QString::fromLocal8Bit(argv[2])).toLatin1().constData(),
                 MB_OK | MB_ICONINFORMATION | MB_TASKMODAL);
         }
     }
 #endif
 #endif // Q_OS_WIN
 
 #if defined(Q_OS_UNIX)
     // Enter debugger in case debugging is activated
     if (workerDebugWait == "all" || workerDebugWait == argv[2]) {
         const pid_t pid = getpid();
         fprintf(stderr,
                 "kioworker: Suspending process to debug io worker(s): %s\n"
                 "kioworker: 'gdb kioworker %d' to debug\n"
                 "kioworker: 'kill -SIGCONT %d' to continue\n",
                 workerDebugWait.constData(),
                 pid,
                 pid);
 
         kill(pid, SIGSTOP);
     }
 #endif
 
     int (*func)(int, char *[]) = (int (*)(int, char *[]))sym;
 
     // We need argv[0] to remain /path/to/kioworker
     // so that applicationDirPath() is correct on non-Linux (no /proc)
     // and we want to skip argv[1] so the kioworker exe is transparent to kdemain.
     const int newArgc = argc - 1;
     QVarLengthArray<char *, 5> newArgv(newArgc);
     newArgv[0] = argv[0];
     for (int i = 1; i < newArgc; ++i) {
         newArgv[i] = argv[i + 1];
     }
 
     return func(newArgc, newArgv.data()); /* Launch! */
 }