no need for pre release tag

Signed-off-by: Rachel Powers <508861+Ryex@users.noreply.github.com>

CMakeLists.txt

@@ -140,9 +140,8 @@ set(Launcher_HELP_URL "https://prismlauncher.org/wiki/help-pages/%1" CACHE STRIN
 ######## Set version numbers ########
 set(Launcher_VERSION_MAJOR 8)
 set(Launcher_VERSION_MINOR 0)
-set(Launcher_VERSION_PRERELEASE "")
 
-set(Launcher_VERSION_NAME "${Launcher_VERSION_MAJOR}.${Launcher_VERSION_MINOR}${Launcher_VERSION_PRERELEASE}")
+set(Launcher_VERSION_NAME "${Launcher_VERSION_MAJOR}.${Launcher_VERSION_MINOR}")
 set(Launcher_VERSION_NAME4 "${Launcher_VERSION_MAJOR}.${Launcher_VERSION_MINOR}.0.0")
 set(Launcher_VERSION_NAME4_COMMA "${Launcher_VERSION_MAJOR},${Launcher_VERSION_MINOR},0,0")
 

buildconfig/BuildConfig.cpp.in

@@ -58,7 +58,6 @@ Config::Config()
     // Version information
     VERSION_MAJOR = @Launcher_VERSION_MAJOR@;
     VERSION_MINOR = @Launcher_VERSION_MINOR@;
-    VERSION_PRERELEASE = "@Launcher_VERSION_PRERELEASE@";
 
     BUILD_PLATFORM = "@Launcher_BUILD_PLATFORM@";
     BUILD_ARTIFACT = "@Launcher_BUILD_ARTIFACT@";
@@ -129,7 +128,7 @@ Config::Config()
 
 QString Config::versionString() const
 {
-    return QString("%1.%2%3").arg(VERSION_MAJOR).arg(VERSION_MINOR).arg(VERSION_PRERELEASE);
+    return QString("%1.%2").arg(VERSION_MAJOR).arg(VERSION_MINOR);
 }
 
 QString Config::printableVersionString() const

buildconfig/BuildConfig.h

@@ -60,8 +60,6 @@ class Config {
     /// The minor version number.
     int VERSION_MINOR;
 
-    QString VERSION_PRERELEASE;
-
     /**
      * The version channel
      * This is used by the updater to determine what channel the current version came from.

launcher/filelink/FileLink.cpp

@@ -40,8 +40,11 @@
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
 #endif
+#include <fcntl.h>
+#include <io.h>
 #include <stdio.h>
 #include <windows.h>
+#include <iostream>
 #endif
 
 // Snippet from https://github.com/gulrak/filesystem#using-it-as-single-file-header
@@ -63,26 +66,112 @@ namespace fs = std::filesystem;
 namespace fs = ghc::filesystem;
 #endif
 
+#if defined Q_OS_WIN32
+
+// taken from https://stackoverflow.com/a/25927081
+// getting a proper output to console with redirection support on windows is apparently hell
+void BindCrtHandlesToStdHandles(bool bindStdIn, bool bindStdOut, bool bindStdErr)
+{
+    // Re-initialize the C runtime "FILE" handles with clean handles bound to "nul". We do this because it has been
+    // observed that the file number of our standard handle file objects can be assigned internally to a value of -2
+    // when not bound to a valid target, which represents some kind of unknown internal invalid state. In this state our
+    // call to "_dup2" fails, as it specifically tests to ensure that the target file number isn't equal to this value
+    // before allowing the operation to continue. We can resolve this issue by first "re-opening" the target files to
+    // use the "nul" device, which will place them into a valid state, after which we can redirect them to our target
+    // using the "_dup2" function.
+    if (bindStdIn) {
+        FILE* dummyFile;
+        freopen_s(&dummyFile, "nul", "r", stdin);
+    }
+    if (bindStdOut) {
+        FILE* dummyFile;
+        freopen_s(&dummyFile, "nul", "w", stdout);
+    }
+    if (bindStdErr) {
+        FILE* dummyFile;
+        freopen_s(&dummyFile, "nul", "w", stderr);
+    }
+
+    // Redirect unbuffered stdin from the current standard input handle
+    if (bindStdIn) {
+        HANDLE stdHandle = GetStdHandle(STD_INPUT_HANDLE);
+        if (stdHandle != INVALID_HANDLE_VALUE) {
+            int fileDescriptor = _open_osfhandle((intptr_t)stdHandle, _O_TEXT);
+            if (fileDescriptor != -1) {
+                FILE* file = _fdopen(fileDescriptor, "r");
+                if (file != NULL) {
+                    int dup2Result = _dup2(_fileno(file), _fileno(stdin));
+                    if (dup2Result == 0) {
+                        setvbuf(stdin, NULL, _IONBF, 0);
+                    }
+                }
+            }
+        }
+    }
+
+    // Redirect unbuffered stdout to the current standard output handle
+    if (bindStdOut) {
+        HANDLE stdHandle = GetStdHandle(STD_OUTPUT_HANDLE);
+        if (stdHandle != INVALID_HANDLE_VALUE) {
+            int fileDescriptor = _open_osfhandle((intptr_t)stdHandle, _O_TEXT);
+            if (fileDescriptor != -1) {
+                FILE* file = _fdopen(fileDescriptor, "w");
+                if (file != NULL) {
+                    int dup2Result = _dup2(_fileno(file), _fileno(stdout));
+                    if (dup2Result == 0) {
+                        setvbuf(stdout, NULL, _IONBF, 0);
+                    }
+                }
+            }
+        }
+    }
+
+    // Redirect unbuffered stderr to the current standard error handle
+    if (bindStdErr) {
+        HANDLE stdHandle = GetStdHandle(STD_ERROR_HANDLE);
+        if (stdHandle != INVALID_HANDLE_VALUE) {
+            int fileDescriptor = _open_osfhandle((intptr_t)stdHandle, _O_TEXT);
+            if (fileDescriptor != -1) {
+                FILE* file = _fdopen(fileDescriptor, "w");
+                if (file != NULL) {
+                    int dup2Result = _dup2(_fileno(file), _fileno(stderr));
+                    if (dup2Result == 0) {
+                        setvbuf(stderr, NULL, _IONBF, 0);
+                    }
+                }
+            }
+        }
+    }
+
+    // Clear the error state for each of the C++ standard stream objects. We need to do this, as attempts to access the
+    // standard streams before they refer to a valid target will cause the iostream objects to enter an error state. In
+    // versions of Visual Studio after 2005, this seems to always occur during startup regardless of whether anything
+    // has been read from or written to the targets or not.
+    if (bindStdIn) {
+        std::wcin.clear();
+        std::cin.clear();
+    }
+    if (bindStdOut) {
+        std::wcout.clear();
+        std::cout.clear();
+    }
+    if (bindStdErr) {
+        std::wcerr.clear();
+        std::cerr.clear();
+    }
+}
+#endif
+
 FileLinkApp::FileLinkApp(int& argc, char** argv) : QCoreApplication(argc, argv), socket(new QLocalSocket(this))
 {
 #if defined Q_OS_WIN32
-    // attach the parent console
+    // attach the parent console if stdout not already captured
-    if (AttachConsole(ATTACH_PARENT_PROCESS)) {
+    auto stdout_type = GetFileType(GetStdHandle(STD_OUTPUT_HANDLE));
-        // if attach succeeds, reopen and sync all the i/o
+    if (stdout_type == FILE_TYPE_CHAR || stdout_type == FILE_TYPE_UNKNOWN) {
-        if (freopen("CON", "w", stdout)) {
+        if (AttachConsole(ATTACH_PARENT_PROCESS)) {
-            std::cout.sync_with_stdio();
+            BindCrtHandlesToStdHandles(true, true, true);
+            consoleAttached = true;
         }
-        if (freopen("CON", "w", stderr)) {
-            std::cerr.sync_with_stdio();
-        }
-        if (freopen("CON", "r", stdin)) {
-            std::cin.sync_with_stdio();
-        }
-        auto out = GetStdHandle(STD_OUTPUT_HANDLE);
-        DWORD written;
-        const char* endline = "\n";
-        WriteConsole(out, endline, strlen(endline), &written, NULL);
-        consoleAttached = true;
     }
 #endif
     setOrganizationName(BuildConfig.LAUNCHER_NAME);

launcher/updater/prismupdater/PrismUpdater.cpp

@@ -39,8 +39,8 @@
 #include <QProcess>
 #include <memory>
 
-#include <QProgressDialog>
 #include <sys.h>
+#include <QProgressDialog>
 
 #if defined Q_OS_WIN32
 #ifndef WIN32_LEAN_AND_MEAN
@@ -209,7 +209,7 @@ PrismUpdaterApp::PrismUpdaterApp(int& argc, char** argv) : QApplication(argc, ar
             BindCrtHandlesToStdHandles(true, true, true);
             consoleAttached = true;
         }
-    } 
+    }
 #endif
     setOrganizationName(BuildConfig.LAUNCHER_NAME);
     setOrganizationDomain(BuildConfig.LAUNCHER_DOMAIN);
@@ -272,8 +272,6 @@ PrismUpdaterApp::PrismUpdaterApp(int& argc, char** argv) : QApplication(argc, ar
     auto prism_update_url = parser.value("update-url");
     if (prism_update_url.isEmpty())
         prism_update_url = BuildConfig.UPDATER_GITHUB_REPO;
-    if (prism_update_url.isEmpty())
-        prism_update_url = "https://github.com/PrismLauncher/PrismLauncher";
 
     m_prismRepoUrl = QUrl::fromUserInput(prism_update_url);
 
@@ -354,18 +352,20 @@ PrismUpdaterApp::PrismUpdaterApp(int& argc, char** argv) : QApplication(argc, ar
             QFile::remove(oldName);
         };
 
-        moveFile(logBase.arg(1), logBase.arg(2));
+        if (FS::ensureFolderPathExists("logs")) {
-        moveFile(logBase.arg(0), logBase.arg(1));
+            moveFile(logBase.arg(1), logBase.arg(2));
+            moveFile(logBase.arg(0), logBase.arg(1));
+        }
 
         logFile = std::unique_ptr<QFile>(new QFile(logBase.arg(0)));
         if (!logFile->open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate)) {
             showFatalErrorMessage(tr("The launcher data folder is not writable!"),
-                                  tr("The launcher couldn't create a log file - the data folder is not writable.\n"
+                                  tr("The updater couldn't create a log file - the data folder is not writable.\n"
                                      "\n"
                                      "Make sure you have write permissions to the data folder.\n"
                                      "(%1)\n"
                                      "\n"
-                                     "The launcher cannot continue until you fix this problem.")
+                                     "The updater cannot continue until you fix this problem.")
                                       .arg(m_dataPath));
             return;
         }
@@ -560,8 +560,7 @@ void PrismUpdaterApp::run()
             stdOutStream.flush();
 
             return exit(100);
-        }
+        } else {
-        else {
             return exit(0);
         }
     }
@@ -1155,7 +1154,7 @@ bool PrismUpdaterApp::loadPrismVersionFromExe(const QString& exe_path)
     if (first_parts.length() < 2)
         return false;
     m_prismBinaryName = first_parts.takeFirst();
-    auto version = first_parts.takeFirst();
+    auto version = first_parts.takeFirst().trimmed();
     m_prismVersion = version;
     if (version.contains('-')) {
         auto index = version.indexOf('-');