main.cc

   1 /*
   2  * Copyright (c) 2000, Red Hat, Inc.
   3  * Copyright (c) 2003, Robert Collins <rbtcollins@hotmail.com>
   4  *
   5  *     This program is free software; you can redistribute it and/or modify
   6  *     it under the terms of the GNU General Public License as published by
   7  *     the Free Software Foundation; either version 2 of the License, or
   8  *     (at your option) any later version.
   9  *
  10  *     A copy of the GNU General Public License can be found at
  11  *     http://www.gnu.org/
  12  *
  13  * Written by DJ Delorie <dj@cygnus.com>
  14  *            Robert Collins <rbtcollins@hotmail.com>
  15  *
  16  *
  17  */
  18
  19 /* OK, here's how this works.  Each of the steps needed for install -
  20    dialogs, downloads, installs - are in their own files and have some
  21    "do_*" function (prototype in dialog.h) and a resource id (IDD_* or
  22    IDD_S_* in resource.h) for that step.  Each step is responsible for
  23    selecting the next step!  See the NEXT macro in dialog.h.  Note
  24    that the IDD_S_* ids are fake; those are for steps that don't
  25    really have a controlling dialog (some have progress dialogs, but
  26    those don't count, although they could).  Replace the IDD_S_* with
  27    IDD_* if you create a real dialog for those steps. */
  28
  29 #include "win32.h"
  30 #include <commctrl.h>
  31 #include <shellapi.h>
  32 #include "shlobj.h"
  33
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include "resource.h"
  37 #include "dialog.h"
  38 #include "state.h"
  39 #include "msg.h"
  40 #include "find.h"
  41 #include "mount.h"
  42 #include "LogFile.h"
  43 #include "setup_version.h"
  44
  45 #include "proppage.h"
  46 #include "propsheet.h"
  47
  48 // Page class headers
  49 #include "splash.h"
  50 #include "AntiVirus.h"
  51 #include "source.h"
  52 #include "root.h"
  53 #include "localdir.h"
  54 #include "net.h"
  55 #include "site.h"
  56 #include "choose.h"
  57 #include "prereq.h"
  58 #include "confirm.h"
  59 #include "threebar.h"
  60 #include "desktop.h"
  61 #include "postinstallresults.h"
  62
  63 #include "getopt++/GetOption.h"
  64 #include "getopt++/BoolOption.h"
  65 #include "getopt++/StringOption.h"
  66 #include "getopt++/StringChoiceOption.h"
  67 #include "mklink2.h"
  68
  69 #include "Exception.h"
  70 #include <stdexcept>
  71
  72 #include "UserSettings.h"
  73 #include "SourceSetting.h"
  74 #include "ConnectionSetting.h"
  75 #include "KeysSetting.h"
  76
  77 #include <wincon.h>
  78 #include <fstream>
  79
  80 #ifdef __MINGW64_VERSION_MAJOR
  81 extern char **_argv;
  82 #endif
  83
  84 bool is_64bit;
  85 bool is_new_install = false;
  86 std::string SetupArch;
  87 std::string SetupIniDir;
  88
  89 HINSTANCE hinstance;
  90
  91 static StringChoiceOption::StringChoices symlink_types({
  92     {"native", SymlinkTypeNative},
  93     {"lnk", SymlinkTypeShortcut},
  94     {"sys", SymlinkTypeMagic},
  95     {"wsl", SymlinkTypeWsl},
  96   });
  97
  98 static StringOption Arch ("", 'a', "arch", "Architecture to install (x86_64 or x86)", false);
  99 static BoolOption UnattendedOption (false, 'q', "quiet-mode", "Unattended setup mode");
 100 static BoolOption PackageManagerOption (false, 'M', "package-manager", "Semi-attended chooser-only mode");
 101 static BoolOption NoAdminOption (false, 'B', "no-admin", "Do not check for and enforce running as Administrator");
 102 static BoolOption WaitOption (false, 'W', "wait", "When elevating, wait for elevated child process");
 103 static BoolOption HelpOption (false, 'h', "help", "Print help");
 104 static BoolOption VersionOption (false, 'V', "version", "Show version");
 105 static StringOption SetupBaseNameOpt ("setup", 'i', "ini-basename", "Use a different basename, e.g. \"foo\", instead of \"setup\"", false);
 106 BoolOption UnsupportedOption (false, '\0', "allow-unsupported-windows", "Allow old, unsupported Windows versions");
 107 static BoolOption DeprecatedOption (false, 'w', "no-warn-deprecated-windows", "Warn about deprecated Windows versions");
 108 static StringChoiceOption SymlinkTypeOption(symlink_types, '\0', "symlink-type", "Symlink type (lnk, native, sys, wsl)", false, SymlinkTypeMagic);
 109 static StringOption GuiLangOption ("", '\0', "lang", "Specify GUI language langid");
 110
 111 std::string SetupBaseName;
 112
 113 static void inline
 114 set_cout ()
 115 {
 116   HANDLE my_stdout = GetStdHandle (STD_OUTPUT_HANDLE);
 117   if (my_stdout != INVALID_HANDLE_VALUE && GetFileType (my_stdout) != FILE_TYPE_UNKNOWN)
 118     return;
 119
 120   if (AttachConsole ((DWORD) -1))
 121     {
 122       std::ofstream *conout = new std::ofstream ("conout$");
 123       std::cout.rdbuf (conout->rdbuf ());
 124       std::cout.flush ();
 125     }
 126 }
 127
 128 // Other threads talk to these pages, so we need to have it externable.
 129 ThreeBarProgressPage Progress;
 130 PostInstallResultsPage PostInstallResults;
 131
 132 static inline void
 133 main_display ()
 134 {
 135   /* nondisplay classes */
 136   LocalDirSetting localDir;
 137   SourceSetting SourceSettings;
 138   ConnectionSetting ConnectionSettings;
 139   SiteSetting ChosenSites;
 140   ExtraKeysSetting ExtraKeys;
 141
 142   SplashPage Splash;
 143   AntiVirusPage AntiVirus;
 144   SourcePage Source;
 145   RootPage Root;
 146   LocalDirPage LocalDir;
 147   NetPage Net;
 148   SitePage Site;
 149   ChooserPage Chooser;
 150   PrereqPage Prereq;
 151   ConfirmPage Confirm;
 152   DesktopSetupPage Desktop;
 153   PropSheet MainWindow;
 154
 155   Log (LOG_TIMESTAMP) << "Current Directory: " << local_dir << endLog;
 156
 157   // Initialize common controls
 158   INITCOMMONCONTROLSEX icce = { sizeof (INITCOMMONCONTROLSEX),
 159                                 ICC_WIN95_CLASSES | ICC_LISTVIEW_CLASSES };
 160   InitCommonControlsEx (&icce);
 161
 162   // Initialize COM and ShellLink instance here.  For some reason
 163   // Windows 7 fails to create the ShellLink instance if this is
 164   // done later, in the thread which actually creates the shortcuts.
 165   extern IShellLink *sl;
 166   CoInitializeEx (NULL, COINIT_APARTMENTTHREADED);
 167   HRESULT res = CoCreateInstance (CLSID_ShellLink, NULL,
 168                                   CLSCTX_INPROC_SERVER, IID_IShellLink,
 169                                   (LPVOID *) & sl);
 170   if (res)
 171     {
 172       mbox (NULL, IDS_SHELLLINK_FAILED, MB_OK, res);
 173     }
 174
 175   // Init window class lib
 176   Window::SetAppInstance (hinstance);
 177
 178   // Create pages
 179   Splash.Create ();
 180   AntiVirus.Create ();
 181   Source.Create ();
 182   Root.Create ();
 183   LocalDir.Create ();
 184   Net.Create ();
 185   Site.Create ();
 186   Chooser.Create ();
 187   Prereq.Create ();
 188   Confirm.Create ();
 189   Progress.Create ();
 190   PostInstallResults.Create ();
 191   Desktop.Create ();
 192
 193   // Add pages to sheet
 194   MainWindow.AddPage (&Splash);
 195   MainWindow.AddPage (&AntiVirus);
 196   MainWindow.AddPage (&Source);
 197   MainWindow.AddPage (&Root);
 198   MainWindow.AddPage (&LocalDir);
 199   MainWindow.AddPage (&Net);
 200   MainWindow.AddPage (&Site);
 201   MainWindow.AddPage (&Chooser);
 202   MainWindow.AddPage (&Prereq);
 203   MainWindow.AddPage (&Confirm);
 204   MainWindow.AddPage (&Progress);
 205   MainWindow.AddPage (&PostInstallResults);
 206   MainWindow.AddPage (&Desktop);
 207
 208   // Create the PropSheet main window
 209   MainWindow.Create ();
 210
 211   // Uninitalize COM
 212   if (sl)
 213     sl->Release ();
 214   CoUninitialize ();
 215 }
 216
 217 int WINAPI
 218 WinMain (HINSTANCE h,
 219          HINSTANCE hPrevInstance, LPSTR command_line, int cmd_show)
 220 {
 221
 222   hinstance = h;
 223
 224   // Make sure the C runtime functions use the same codepage as the GUI
 225   char locale[12];
 226   snprintf(locale, sizeof locale, ".%u", GetACP());
 227   setlocale(LC_ALL, locale);
 228
 229   char **_argv;
 230   int argc;
 231   for (argc = 0, _argv = __argv; *_argv; _argv++)
 232     ++argc;
 233   _argv = __argv;
 234
 235   try {
 236     bool help_option = false;
 237     bool invalid_option = false;
 238     char cwd[MAX_PATH];
 239     GetCurrentDirectory (MAX_PATH, cwd);
 240     local_dir = std::string (cwd);
 241
 242     if (!GetOption::GetInstance ().Process (argc,_argv, NULL))
 243       help_option = invalid_option = true;
 244     else if (HelpOption)
 245       help_option = true;
 246
 247     if (!((std::string) Arch).size ())
 248       {
 249 #ifdef __x86_64__
 250         is_64bit = true;
 251 #else
 252         is_64bit = false;
 253 #endif
 254       }
 255     else if (((std::string) Arch).find ("64") != std::string::npos)
 256       is_64bit = true;
 257     else if (((std::string) Arch).find ("32") != std::string::npos
 258              || ((std::string) Arch).find ("x86") != std::string::npos)
 259       is_64bit = false;
 260     else
 261       {
 262         char buff[80 + ((std::string) Arch).size ()];
 263         sprintf (buff, "Invalid option for --arch:  \"%s\"",
 264                  ((std::string) Arch).c_str ());
 265         fprintf (stderr, "*** %s\n", buff);
 266         exit (1);
 267       }
 268
 269     if (GuiLangOption.isPresent())
 270       {
 271         // If option's value isn't numeric, perhaps we should try to interpret
 272         // it as a locale name?
 273         int rc = sscanf(((std::string)GuiLangOption).c_str(), "%hx", &langid);
 274         if (rc > 0)
 275           SetThreadUILanguage(langid);
 276       }
 277
 278     unattended_mode = PackageManagerOption ? chooseronly
 279                         : (UnattendedOption ? unattended : attended);
 280
 281     bool output_only = help_option || VersionOption;
 282
 283     SetupBaseName = SetupBaseNameOpt;
 284     SetupArch = is_64bit ? "x86_64" : "x86";
 285     SetupIniDir = SetupArch+"/";
 286
 287     /* Initialize well known SIDs.  We need the admin SID to test if we're
 288        supposed to elevate. */
 289     nt_sec.initialiseWellKnownSIDs ();
 290     /* Check if we have to elevate. */
 291     bool elevate = !output_only && OSMajorVersion () >= 6
 292                    && !NoAdminOption && !nt_sec.isRunAsAdmin ();
 293     std::string elevate_extra_args;
 294
 295     if (unattended_mode || output_only || !elevate)
 296       set_cout ();
 297
 298     /* Start logging only if we don't elevate.  Same for setting default
 299        security settings. */
 300     LogSingleton::SetInstance (*LogFile::createLogFile ());
 301     const char *sep = isdirsep (local_dir[local_dir.size () - 1])
 302                                 ? "" : "\\";
 303     /* Don't create log files for help or version output only. */
 304     if (!elevate && !output_only)
 305       {
 306         Logger ().setFile (LOG_BABBLE, local_dir + sep + "setup.log.full",
 307                            false);
 308         Logger ().setFile (0, local_dir + sep + "setup.log", true);
 309         Log (LOG_PLAIN) << "Starting cygwin install, version "
 310                         << setup_version << endLog;
 311       }
 312
 313     if (help_option)
 314       {
 315         if (invalid_option)
 316           Log (LOG_PLAIN) << "\nError during option processing.\n" << endLog;
 317         Log (LOG_PLAIN) << "Cygwin setup " << setup_version << endLog;
 318         Log (LOG_PLAIN) << "\nCommand Line Options:\n" << endLog;
 319         GetOption::GetInstance ().ParameterUsage (Log (LOG_PLAIN));
 320         Log (LOG_PLAIN) << endLog;
 321         Log (LOG_PLAIN) << "The default is to both download and install packages, unless either --download or --local-install is specified." << endLog;
 322         Logger ().exit (invalid_option ? 1 : 0, false);
 323         goto finish_up;
 324       }
 325
 326     if (VersionOption)
 327       {
 328         Log (LOG_PLAIN) << "Cygwin setup " << setup_version << endLog;
 329         Logger ().exit (0, false);
 330         goto finish_up;
 331       }
 332
 333     /* Check if Cygwin works on this Windows version */
 334     if (!UnsupportedOption && (OSMajorVersion () < 6))
 335       {
 336         mbox (NULL, IDS_UNSUPPORTED_WINDOWS_VERSION,
 337               MB_ICONEXCLAMATION | MB_OK);
 338         Logger ().exit (1, false);
 339       }
 340
 341     /* Warn if Windows version is deprecated for Cygwin */
 342     if (!DeprecatedOption && !elevate)
 343       {
 344         if
 345 #ifdef _X86_
 346           (TRUE)
 347 #else
 348           (!is_64bit)
 349 #endif
 350           mbox (NULL, IDS_DEPRECATED_WINDOWS_ARCH,
 351                 MB_ICONEXCLAMATION | MB_OK | MB_DSA_CHECKBOX);
 352         else if ((OSMajorVersion () == 6) && (OSMinorVersion() < 1))
 353           mbox (NULL, IDS_DEPRECATED_WINDOWS_VERSION,
 354                 MB_ICONEXCLAMATION | MB_OK | MB_DSA_CHECKBOX);
 355       }
 356
 357     /* Set default DACL and Group. */
 358     nt_sec.setDefaultSecurity ((root_scope == IDC_ROOT_SYSTEM));
 359
 360     /*
 361        If --symlink-type option isn't given, look for winsymlinks in CYGWIN
 362        env var for a default
 363
 364        Since the current environment doesn't get passed to the process started
 365        with with ShellExecuteEx, we need to convert the env var into an option
 366        for that elevated instance.
 367     */
 368     if (!SymlinkTypeOption.isPresent()) {
 369       std::string cygwin;
 370       DWORD len = GetEnvironmentVariable ("CYGWIN", &cygwin[0], 0);
 371       cygwin.resize(len);
 372       GetEnvironmentVariable ("CYGWIN", &cygwin[0], len);
 373
 374       if (cygwin.find("winsymlinks:native") != std::string::npos)
 375         {
 376           symlinkType = SymlinkTypeNative;
 377           elevate_extra_args.append("--symlink-type native");
 378         }
 379       else if (cygwin.find("winsymlinks:wsl") != std::string::npos)
 380         {
 381           symlinkType = SymlinkTypeWsl;
 382           elevate_extra_args.append("--symlink-type wsl");
 383         }
 384       else if (cygwin.find("winsymlinks:sys") != std::string::npos)
 385         {
 386           symlinkType = SymlinkTypeMagic;
 387           elevate_extra_args.append("--symlink-type sys");
 388         }
 389       else if (cygwin.find("winsymlinks:lnk") != std::string::npos)
 390         {
 391           // Ignore CYGWIN=winsymlinks:lnk, as '--symlink-type lnk' is not implemented
 392           // symlinkType = SymlinkTypeShortcut;
 393           // elevate_extra_args.append("--symlink-type lnk");
 394         }
 395       }
 396     else
 397       {
 398         symlinkType = (SymlinkTypeEnum)(int)SymlinkTypeOption;
 399       }
 400
 401     if (symlinkType == SymlinkTypeWsl)
 402       {
 403         VersionInfo v = GetVer();
 404         if ((v.major() < 10) ||
 405             ((v.major() == 10) && (v.buildNumber() < 14393)))
 406           {
 407             fprintf (stderr, "*** --symlink-type wsl requires Windows 10 1607 or later\n");
 408             exit(1);
 409           }
 410       }
 411     else if (symlinkType == SymlinkTypeNative)
 412       {
 413         if (!(elevate || is_developer_mode() || nt_sec.hasSymlinkCreationRights()))
 414           {
 415             fprintf (stderr, "*** --symlink-type native requires SeCreateSymbolicLink privilege or 'Developer Mode'\n");
 416             exit(1);
 417           }
 418       }
 419     else if (symlinkType == SymlinkTypeShortcut)
 420       {
 421         fprintf (stderr, "*** --symlink-type lnk is not implemented\n");
 422         exit(1);
 423       }
 424
 425     if (elevate)
 426       {
 427         char exe_path[MAX_PATH];
 428         if (!GetModuleFileName(NULL, exe_path, ARRAYSIZE(exe_path)))
 429           goto finish_up;
 430
 431         SHELLEXECUTEINFO sei = { sizeof(sei) };
 432         sei.lpVerb = "runas";
 433         sei.lpFile = exe_path;
 434         sei.nShow = SW_NORMAL;
 435         if (WaitOption)
 436           sei.fMask |= SEE_MASK_NOCLOSEPROCESS;
 437
 438         // Avoid another isRunAsAdmin check in the child.
 439         std::string command_line_cs (command_line);
 440         command_line_cs += " -";
 441         command_line_cs += NoAdminOption.shortOption();
 442         command_line_cs += " ";
 443         command_line_cs += elevate_extra_args;
 444         sei.lpParameters = command_line_cs.c_str ();
 445
 446         if (ShellExecuteEx(&sei))
 447           {
 448             DWORD exitcode = 0;
 449             /* Wait until child process is finished. */
 450             if (WaitOption && sei.hProcess != NULL)
 451               if (!WaitForSingleObject (sei.hProcess, INFINITE))
 452                 GetExitCodeProcess (sei.hProcess, &exitcode);
 453             Logger ().setExitMsg (IDS_ELEVATED);
 454             Logger ().exit (exitcode, false);
 455           }
 456         Log (LOG_PLAIN) << "Starting elevated child process failed" << endLog;
 457         Logger ().exit (1, false);
 458       }
 459     else
 460       {
 461         UserSettings Settings;
 462         UserSettings::instance().load (local_dir);
 463         main_display ();
 464         Settings.save ();       // Clean exit.. save user options.
 465         if (rebootneeded)
 466           Logger ().setExitMsg (IDS_REBOOT_REQUIRED);
 467         Logger ().exit (rebootneeded ? IDS_REBOOT_REQUIRED : 0);
 468       }
 469 finish_up:
 470     ;
 471   }
 472   TOPLEVEL_CATCH(NULL, "main");
 473
 474   // Never reached
 475   return 0;
 476 }