[93128] | 1 | /** $Id: VBoxOs2AdditionsInstall.cpp 96407 2022-08-22 17:43:14Z vboxsync $ */
|
---|
| 2 | /** @file
|
---|
| 3 | * VBoxOs2AdditionsInstall - Barebone OS/2 Guest Additions Installer.
|
---|
| 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
[96407] | 7 | * Copyright (C) 2022 Oracle and/or its affiliates.
|
---|
[93128] | 8 | *
|
---|
[96407] | 9 | * This file is part of VirtualBox base platform packages, as
|
---|
| 10 | * available from https://www.virtualbox.org.
|
---|
| 11 | *
|
---|
| 12 | * This program is free software; you can redistribute it and/or
|
---|
| 13 | * modify it under the terms of the GNU General Public License
|
---|
| 14 | * as published by the Free Software Foundation, in version 3 of the
|
---|
| 15 | * License.
|
---|
| 16 | *
|
---|
| 17 | * This program is distributed in the hope that it will be useful, but
|
---|
| 18 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
| 20 | * General Public License for more details.
|
---|
| 21 | *
|
---|
| 22 | * You should have received a copy of the GNU General Public License
|
---|
| 23 | * along with this program; if not, see <https://www.gnu.org/licenses>.
|
---|
| 24 | *
|
---|
| 25 | * SPDX-License-Identifier: GPL-3.0-only
|
---|
[93128] | 26 | */
|
---|
| 27 |
|
---|
| 28 |
|
---|
| 29 | /*********************************************************************************************************************************
|
---|
| 30 | * Header Files *
|
---|
| 31 | *********************************************************************************************************************************/
|
---|
| 32 | #define INCL_BASE
|
---|
| 33 | #include <os2.h>
|
---|
| 34 | #include <VBox/version.h>
|
---|
| 35 |
|
---|
| 36 | #include <string.h>
|
---|
| 37 | #include <iprt/ctype.h>
|
---|
| 38 | #include <iprt/path.h>
|
---|
| 39 |
|
---|
| 40 |
|
---|
| 41 | /*********************************************************************************************************************************
|
---|
[93136] | 42 | * Defined Constants And Macros *
|
---|
| 43 | *********************************************************************************************************************************/
|
---|
| 44 | #define SKIP_CONFIG_SYS 0x01
|
---|
| 45 | #define SKIP_STARTUP_CMD 0x02
|
---|
| 46 | #define SKIP_SERVICE 0x04
|
---|
| 47 | #define SKIP_SHARED_FOLDERS 0x08
|
---|
| 48 | #define SKIP_GRAPHICS 0x10
|
---|
| 49 | #define SKIP_MOUSE 0x20
|
---|
| 50 | #define SKIP_LIBC_DLLS 0x40
|
---|
| 51 |
|
---|
| 52 | /** NIL HFILE value. */
|
---|
| 53 | #define MY_NIL_HFILE (~(HFILE)0)
|
---|
| 54 |
|
---|
[93144] | 55 | #if defined(DOXYGEN_RUNNING)
|
---|
| 56 | /** Enabled extra debug output in the matching functions. */
|
---|
| 57 | # define DEBUG_MATCHING
|
---|
| 58 | #endif
|
---|
[93136] | 59 |
|
---|
[93144] | 60 |
|
---|
[93136] | 61 | /*********************************************************************************************************************************
|
---|
| 62 | * Structures and Typedefs *
|
---|
| 63 | *********************************************************************************************************************************/
|
---|
| 64 | typedef struct FILEEDITOR
|
---|
| 65 | {
|
---|
| 66 | size_t cbOrg;
|
---|
| 67 | char *pszOrg;
|
---|
| 68 | size_t cbNew;
|
---|
| 69 | size_t cbNewAlloc;
|
---|
| 70 | char *pszNew;
|
---|
[93144] | 71 | bool fAppendEof;
|
---|
[93136] | 72 | bool fOverflowed;
|
---|
[93144] | 73 | size_t cBogusChars;
|
---|
[93136] | 74 | } FILEEDITOR;
|
---|
| 75 |
|
---|
| 76 |
|
---|
| 77 | /*********************************************************************************************************************************
|
---|
[93128] | 78 | * Global Variables *
|
---|
| 79 | *********************************************************************************************************************************/
|
---|
| 80 | /** Where the files to install (default: same dir as this program). */
|
---|
| 81 | static CHAR g_szSrcPath[CCHMAXPATH];
|
---|
| 82 | /** The length of g_szSrcPath, including a trailing slash. */
|
---|
| 83 | static size_t g_cchSrcPath = 0;
|
---|
| 84 | /** The boot drive path, i.e. where Config.kmk & Startup.cmd lives. */
|
---|
| 85 | static CHAR g_szBootDrivePath[CCHMAXPATH] = "C:\\";
|
---|
| 86 | /** The size of the bootdrive path, including a trailing slash. */
|
---|
| 87 | static size_t g_cchBootDrivePath = sizeof("C:\\") - 1;
|
---|
| 88 | /** Where to install the guest additions files. */
|
---|
[93144] | 89 | static CHAR g_szDstPath[CCHMAXPATH] = "C:\\VBoxAdd\\";
|
---|
[93128] | 90 | /** The length of g_szDstPath, including a trailing slash. */
|
---|
[93144] | 91 | static size_t g_cchDstPath = sizeof("C:\\VBoxAdd\\") - 1;
|
---|
[93136] | 92 | /** Mask of SKIP_XXX flags of components/tasks to skip. */
|
---|
| 93 | static uint8_t g_fSkipMask = 0;
|
---|
| 94 | /** Verbose or quiet. */
|
---|
| 95 | static bool g_fVerbose = true;
|
---|
[93145] | 96 | /** Whether this is a real run (true) or just a trial. */
|
---|
| 97 | static bool g_fRealRun = false;
|
---|
[93128] | 98 |
|
---|
| 99 | /** The standard output handle. */
|
---|
[93136] | 100 | static HFILE const g_hStdOut = (HFILE)1;
|
---|
[93128] | 101 | /** The standard error handle. */
|
---|
[93136] | 102 | static HFILE const g_hStdErr = (HFILE)2;
|
---|
[93128] | 103 |
|
---|
| 104 |
|
---|
[93136] | 105 | /** File editor for Config.sys. */
|
---|
| 106 | static FILEEDITOR g_ConfigSys;
|
---|
| 107 | /** File editor for Startup.cmd. */
|
---|
| 108 | static FILEEDITOR g_StartupCmd;
|
---|
| 109 |
|
---|
| 110 |
|
---|
| 111 | /*********************************************************************************************************************************
|
---|
| 112 | * Messaging. *
|
---|
| 113 | *********************************************************************************************************************************/
|
---|
| 114 |
|
---|
[93128] | 115 | static void DoWriteNStr(HFILE hFile, const char *psz, size_t cch)
|
---|
| 116 | {
|
---|
| 117 | ULONG cbIgnore;
|
---|
| 118 | while (DosWrite(hFile, (void *)psz, cch, &cbIgnore) == ERROR_INTERRUPT)
|
---|
| 119 | ;
|
---|
| 120 | }
|
---|
| 121 |
|
---|
| 122 |
|
---|
| 123 | static void DoWriteStr(HFILE hFile, const char *psz)
|
---|
| 124 | {
|
---|
| 125 | DoWriteNStr(hFile, psz, strlen(psz));
|
---|
| 126 | }
|
---|
| 127 |
|
---|
| 128 |
|
---|
[93136] | 129 | /** Writes a variable number of strings to @a hFile, stopping at NULL. */
|
---|
| 130 | static void WriteStrings(HFILE hFile, ...)
|
---|
| 131 | {
|
---|
| 132 | va_list va;
|
---|
| 133 | va_start(va, hFile);
|
---|
| 134 | for (;;)
|
---|
| 135 | {
|
---|
| 136 | const char *psz = va_arg(va, const char *);
|
---|
| 137 | if (psz)
|
---|
| 138 | DoWriteStr(hFile, psz);
|
---|
| 139 | else
|
---|
| 140 | break;
|
---|
| 141 | }
|
---|
| 142 | va_end(va);
|
---|
| 143 | }
|
---|
| 144 |
|
---|
| 145 |
|
---|
[93138] | 146 | /** Writes a variable number of length/strings pairs to @a hFile, stopping at
|
---|
| 147 | * 0/NULL. */
|
---|
| 148 | static void WriteNStrings(HFILE hFile, ...)
|
---|
| 149 | {
|
---|
| 150 | va_list va;
|
---|
| 151 | va_start(va, hFile);
|
---|
| 152 | for (;;)
|
---|
| 153 | {
|
---|
| 154 | const char *psz = va_arg(va, const char *);
|
---|
| 155 | int cch = va_arg(va, int);
|
---|
| 156 | if (psz)
|
---|
| 157 | {
|
---|
| 158 | if (cch < 0)
|
---|
| 159 | DoWriteStr(hFile, psz);
|
---|
| 160 | else
|
---|
| 161 | DoWriteNStr(hFile, psz, cch);
|
---|
| 162 | }
|
---|
| 163 | else
|
---|
| 164 | break;
|
---|
| 165 | }
|
---|
| 166 | va_end(va);
|
---|
| 167 | }
|
---|
| 168 |
|
---|
| 169 |
|
---|
| 170 | static RTEXITCODE ErrorNStrings(const char *pszMsg, ssize_t cchMsg, ...)
|
---|
| 171 | {
|
---|
| 172 | DoWriteNStr(g_hStdErr, RT_STR_TUPLE("VBoxOs2AdditionsInstall: error: "));
|
---|
| 173 | va_list va;
|
---|
| 174 | va_start(va, cchMsg);
|
---|
| 175 | do
|
---|
| 176 | {
|
---|
| 177 | if (cchMsg < 0)
|
---|
| 178 | DoWriteStr(g_hStdErr, pszMsg);
|
---|
| 179 | else
|
---|
| 180 | DoWriteNStr(g_hStdErr, pszMsg, cchMsg);
|
---|
| 181 | pszMsg = va_arg(va, const char *);
|
---|
| 182 | cchMsg = va_arg(va, int);
|
---|
| 183 | } while (pszMsg != NULL);
|
---|
| 184 | va_end(va);
|
---|
| 185 | DoWriteNStr(g_hStdErr, RT_STR_TUPLE("\r\n"));
|
---|
| 186 | return RTEXITCODE_FAILURE;
|
---|
| 187 | }
|
---|
| 188 |
|
---|
| 189 |
|
---|
[93128] | 190 | static char *MyNumToString(char *pszBuf, unsigned uNum)
|
---|
| 191 | {
|
---|
[93144] | 192 | char *pszRet = pszBuf;
|
---|
| 193 |
|
---|
[93128] | 194 | /* Convert to decimal and inverted digit order: */
|
---|
| 195 | char szTmp[32];
|
---|
| 196 | unsigned off = 0;
|
---|
| 197 | do
|
---|
| 198 | {
|
---|
| 199 | szTmp[off++] = uNum % 10 + '0';
|
---|
| 200 | uNum /= 10;
|
---|
| 201 | } while (uNum);
|
---|
| 202 |
|
---|
| 203 | /* Copy it out to the destination buffer in the right order and add a terminator: */
|
---|
| 204 | while (off-- > 0)
|
---|
| 205 | *pszBuf++ = szTmp[off];
|
---|
| 206 | *pszBuf = '\0';
|
---|
[93144] | 207 |
|
---|
| 208 | return pszRet;
|
---|
[93128] | 209 | }
|
---|
| 210 |
|
---|
| 211 |
|
---|
| 212 | static void DoWriteNumber(HFILE hFile, unsigned uNum)
|
---|
| 213 | {
|
---|
| 214 | char szTmp[32];
|
---|
| 215 | MyNumToString(szTmp, uNum);
|
---|
| 216 | DoWriteStr(hFile, szTmp);
|
---|
| 217 | }
|
---|
| 218 |
|
---|
[93138] | 219 |
|
---|
[93136] | 220 | static RTEXITCODE ApiErrorN(APIRET rc, unsigned cMsgs, ...)
|
---|
[93128] | 221 | {
|
---|
| 222 | DoWriteNStr(g_hStdErr, RT_STR_TUPLE("VBoxOs2AdditionsInstall: error: "));
|
---|
[93136] | 223 | va_list va;
|
---|
| 224 | va_start(va, cMsgs);
|
---|
| 225 | while (cMsgs-- > 0)
|
---|
| 226 | {
|
---|
| 227 | const char *pszMsg = va_arg(va, const char *);
|
---|
| 228 | DoWriteStr(g_hStdErr, pszMsg);
|
---|
| 229 | }
|
---|
| 230 | va_end(va);
|
---|
[93128] | 231 | DoWriteNStr(g_hStdErr, RT_STR_TUPLE(": "));
|
---|
| 232 | DoWriteNumber(g_hStdErr, rc);
|
---|
| 233 | DoWriteNStr(g_hStdErr, RT_STR_TUPLE("\r\n"));
|
---|
[93136] | 234 | return RTEXITCODE_FAILURE;
|
---|
[93128] | 235 | }
|
---|
| 236 |
|
---|
| 237 |
|
---|
[93136] | 238 | DECLINLINE(RTEXITCODE) ApiError(const char *pszMsg, APIRET rc)
|
---|
| 239 | {
|
---|
| 240 | return ApiErrorN(rc, 1, pszMsg);
|
---|
| 241 | }
|
---|
[93128] | 242 |
|
---|
[93136] | 243 |
|
---|
[93128] | 244 | static RTEXITCODE SyntaxError(const char *pszMsg, const char *pszArg)
|
---|
| 245 | {
|
---|
| 246 | DoWriteNStr(g_hStdErr, RT_STR_TUPLE("VBoxOs2AdditionsInstall: syntax error: "));
|
---|
| 247 | DoWriteNStr(g_hStdErr, pszMsg, strlen(pszMsg));
|
---|
| 248 | DoWriteNStr(g_hStdErr, RT_STR_TUPLE("\r\n"));
|
---|
| 249 | return RTEXITCODE_SYNTAX;
|
---|
| 250 | }
|
---|
| 251 |
|
---|
| 252 |
|
---|
[93136] | 253 | /*********************************************************************************************************************************
|
---|
| 254 | * Editor. *
|
---|
| 255 | *********************************************************************************************************************************/
|
---|
[93128] | 256 |
|
---|
| 257 | /**
|
---|
[93136] | 258 | * Reads a file into the editor.
|
---|
| 259 | */
|
---|
| 260 | static RTEXITCODE EditorReadInFile(FILEEDITOR *pEditor, const char *pszFilename, size_t cbExtraEdit, bool fMustExist)
|
---|
| 261 | {
|
---|
[93144] | 262 | FILESTATUS3 FileSts;
|
---|
| 263 |
|
---|
[93136] | 264 | if (g_fVerbose)
|
---|
| 265 | WriteStrings(g_hStdOut, "info: Preparing \"", pszFilename, "\" modifications...\r\n", NULL);
|
---|
| 266 |
|
---|
| 267 | /*
|
---|
| 268 | * Open the file.
|
---|
| 269 | */
|
---|
| 270 | HFILE hFile = MY_NIL_HFILE;
|
---|
| 271 | ULONG uAction = ~0U;
|
---|
| 272 | APIRET rc = DosOpen(pszFilename, &hFile, &uAction, 0, FILE_NORMAL,
|
---|
| 273 | OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW,
|
---|
| 274 | OPEN_ACCESS_READONLY | OPEN_SHARE_DENYWRITE | OPEN_FLAGS_SEQUENTIAL | OPEN_FLAGS_NOINHERIT,
|
---|
| 275 | NULL /*pEaOp2*/);
|
---|
[93144] | 276 | if (rc == ERROR_OPEN_FAILED)
|
---|
| 277 | rc = DosQueryPathInfo(pszFilename, FIL_STANDARD, &FileSts, sizeof(FileSts));
|
---|
[93136] | 278 | if (rc == ERROR_FILE_NOT_FOUND)
|
---|
| 279 | hFile = MY_NIL_HFILE;
|
---|
| 280 | else if (rc != NO_ERROR)
|
---|
| 281 | return ApiErrorN(rc, 3, "DosOpen(\"", pszFilename, "\",READONLY)");
|
---|
| 282 |
|
---|
| 283 | /*
|
---|
| 284 | * Get it's size and check that it's sane.
|
---|
| 285 | */
|
---|
| 286 | if (hFile != MY_NIL_HFILE)
|
---|
| 287 | {
|
---|
| 288 | rc = DosQueryFileInfo(hFile, FIL_STANDARD, &FileSts, sizeof(FileSts));
|
---|
| 289 | if (rc != NO_ERROR)
|
---|
| 290 | return ApiErrorN(rc, 3, "DosQueryFileInfo(\"", pszFilename, "\",FIL_STANDARD,,)");
|
---|
| 291 |
|
---|
| 292 | if (FileSts.cbFile > _2M)
|
---|
| 293 | return ApiErrorN(rc, FileSts.cbFile, "File \"", pszFilename, "\" is too large");
|
---|
| 294 | }
|
---|
| 295 | else
|
---|
| 296 | FileSts.cbFile = 0;
|
---|
| 297 |
|
---|
| 298 | /*
|
---|
| 299 | * Allocate buffers.
|
---|
| 300 | */
|
---|
| 301 | PVOID pvAlloc = NULL;
|
---|
| 302 | size_t cbAlloc = FileSts.cbFile * 2 + cbExtraEdit + 16;
|
---|
| 303 | rc = DosAllocMem(&pvAlloc, cbAlloc, PAG_COMMIT | PAG_WRITE | PAG_READ);
|
---|
[93144] | 304 | if (rc != NO_ERROR)
|
---|
[93136] | 305 | return ApiError("DosAllocMem", rc);
|
---|
| 306 |
|
---|
| 307 | memset(pvAlloc, 0, cbAlloc);
|
---|
[93144] | 308 | pEditor->cbOrg = FileSts.cbFile;
|
---|
| 309 | pEditor->pszOrg = (char *)pvAlloc;
|
---|
| 310 | pEditor->pszNew = (char *)pvAlloc + FileSts.cbFile + 1;
|
---|
| 311 | pEditor->cbNew = 0;
|
---|
| 312 | pEditor->cbNewAlloc = cbAlloc - FileSts.cbFile - 2;
|
---|
| 313 | pEditor->fAppendEof = false;
|
---|
| 314 | pEditor->fOverflowed = false;
|
---|
| 315 | pEditor->cBogusChars = 0;
|
---|
[93136] | 316 |
|
---|
| 317 | /*
|
---|
| 318 | * Read in the file content.
|
---|
| 319 | */
|
---|
| 320 | if (hFile != MY_NIL_HFILE)
|
---|
| 321 | {
|
---|
| 322 | ULONG cbRead = 0;
|
---|
| 323 | rc = DosRead(hFile, pEditor->pszOrg, FileSts.cbFile, &cbRead);
|
---|
| 324 | if (rc != NO_ERROR)
|
---|
| 325 | return ApiErrorN(rc, 3, "DosRead(\"", pszFilename, "\")");
|
---|
| 326 | if (cbRead != FileSts.cbFile)
|
---|
| 327 | return ApiErrorN(cbRead < FileSts.cbFile ? ERROR_MORE_DATA : ERROR_BUFFER_OVERFLOW,
|
---|
| 328 | 3, "DosRead(\"", pszFilename, "\")");
|
---|
| 329 | DosClose(hFile);
|
---|
[93144] | 330 |
|
---|
| 331 | /*
|
---|
| 332 | * Check for EOF/SUB character.
|
---|
| 333 | */
|
---|
| 334 | char *pchEof = (char *)memchr(pEditor->pszOrg, 0x1a, FileSts.cbFile);
|
---|
| 335 | if (pchEof)
|
---|
| 336 | {
|
---|
| 337 | size_t offEof = pchEof - pEditor->pszOrg;
|
---|
| 338 | for (size_t off = offEof + 1; off < FileSts.cbFile; off++)
|
---|
| 339 | if (!RT_C_IS_SPACE(pEditor->pszOrg[off]))
|
---|
| 340 | return ErrorNStrings(RT_STR_TUPLE("Refusing to modify \""), pszFilename, -1,
|
---|
| 341 | RT_STR_TUPLE("\" because of EOF character followed by text!"));
|
---|
| 342 | pEditor->cbOrg = offEof;
|
---|
| 343 | pEditor->fAppendEof = true;
|
---|
| 344 | }
|
---|
[93136] | 345 | }
|
---|
| 346 |
|
---|
| 347 | return RTEXITCODE_SUCCESS;
|
---|
| 348 | }
|
---|
| 349 |
|
---|
| 350 |
|
---|
| 351 | /**
|
---|
| 352 | * Writes out a modified file, backing up the original.
|
---|
| 353 | */
|
---|
| 354 | static RTEXITCODE EditorWriteOutFile(FILEEDITOR *pEditor, const char *pszFilename)
|
---|
| 355 | {
|
---|
| 356 | if (g_fVerbose)
|
---|
| 357 | WriteStrings(g_hStdOut, "info: Writing out \"", pszFilename, "\" modifications...\r\n", NULL);
|
---|
| 358 |
|
---|
| 359 | /*
|
---|
| 360 | * Skip if no change was made.
|
---|
| 361 | */
|
---|
| 362 | if ( pEditor->cbNew == 0
|
---|
| 363 | || ( pEditor->cbNew == pEditor->cbOrg
|
---|
| 364 | && memcmp(pEditor->pszNew, pEditor->pszOrg, pEditor->cbNew) == 0))
|
---|
| 365 | {
|
---|
| 366 | WriteStrings(g_hStdOut, "info: No changes to \"", pszFilename, "\".\r\n", NULL);
|
---|
| 367 | return RTEXITCODE_SUCCESS;
|
---|
| 368 | }
|
---|
| 369 |
|
---|
| 370 | /*
|
---|
| 371 | * Back up the original.
|
---|
| 372 | * ASSUMES that the input is CCHMAXPATH or less.
|
---|
| 373 | */
|
---|
| 374 | if (pEditor->cbOrg != 0)
|
---|
| 375 | {
|
---|
| 376 | CHAR szBackup[CCHMAXPATH + 16];
|
---|
| 377 | size_t const cchFilename = strlen(pszFilename);
|
---|
| 378 | memcpy(szBackup, pszFilename, cchFilename + 1);
|
---|
| 379 | char *pszExt = (char *)memrchr(szBackup, '.', cchFilename);
|
---|
| 380 | if (!pszExt || strchr(pszExt, '\\') || strchr(pszExt, '/'))
|
---|
| 381 | pszExt = &szBackup[cchFilename];
|
---|
| 382 | strcpy(pszExt, ".BAK");
|
---|
| 383 | for (unsigned short i = 0; ; i++)
|
---|
| 384 | {
|
---|
| 385 | HFILE hFile = MY_NIL_HFILE;
|
---|
| 386 | ULONG uAction = ~0U;
|
---|
| 387 | APIRET rc = DosOpen(szBackup, &hFile, &uAction, 0, FILE_NORMAL,
|
---|
| 388 | OPEN_ACTION_FAIL_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW,
|
---|
| 389 | OPEN_ACCESS_WRITEONLY | OPEN_SHARE_DENYWRITE | OPEN_FLAGS_SEQUENTIAL | OPEN_FLAGS_NOINHERIT,
|
---|
| 390 | NULL /*pEaOp2*/);
|
---|
| 391 | if (rc == NO_ERROR)
|
---|
| 392 | {
|
---|
| 393 | ULONG cbWritten = 0;
|
---|
| 394 | do
|
---|
[93144] | 395 | rc = DosWrite(hFile, pEditor->pszOrg, pEditor->cbOrg + (pEditor->fAppendEof ? 1 : 0), &cbWritten);
|
---|
[93136] | 396 | while (rc == ERROR_INTERRUPT);
|
---|
| 397 | DosClose(hFile);
|
---|
| 398 | if (rc != NO_ERROR)
|
---|
| 399 | return ApiErrorN(rc, 5, "Failed backing up \"", pszFilename, "\" as \"", szBackup, "\"");
|
---|
| 400 | break;
|
---|
| 401 | }
|
---|
| 402 |
|
---|
| 403 | /* try next extension variation */
|
---|
| 404 | if (i >= 1000)
|
---|
| 405 | return ApiErrorN(rc, 5, "Failed backing up \"", pszFilename, "\" as \"", szBackup, "\"");
|
---|
| 406 | if (i >= 100)
|
---|
| 407 | pszExt[1] = '0' + (i / 100);
|
---|
| 408 | if (i >= 10)
|
---|
| 409 | pszExt[2] = '0' + (i / 100 % 10);
|
---|
| 410 | pszExt[3] = '0' + (i % 10);
|
---|
| 411 | }
|
---|
| 412 | }
|
---|
| 413 |
|
---|
| 414 | /*
|
---|
| 415 | * Write out the new copy.
|
---|
| 416 | */
|
---|
| 417 | HFILE hFile = MY_NIL_HFILE;
|
---|
| 418 | ULONG uAction = ~0U;
|
---|
| 419 | APIRET rc = DosOpen(pszFilename, &hFile, &uAction, 0, FILE_NORMAL,
|
---|
| 420 | OPEN_ACTION_REPLACE_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW,
|
---|
| 421 | OPEN_ACCESS_WRITEONLY | OPEN_SHARE_DENYWRITE | OPEN_FLAGS_SEQUENTIAL | OPEN_FLAGS_NOINHERIT,
|
---|
| 422 | NULL /*pEaOp2*/);
|
---|
| 423 | if (rc != NO_ERROR)
|
---|
| 424 | return ApiErrorN(rc, 3, "Opening \"", pszFilename, "\" for writing");
|
---|
| 425 |
|
---|
[93144] | 426 | ULONG cbToWrite = pEditor->cbNew;
|
---|
| 427 | if (pEditor->fAppendEof)
|
---|
| 428 | {
|
---|
| 429 | pEditor->pszNew[cbToWrite] = 0x1a; /* replacing terminator */
|
---|
| 430 | cbToWrite++;
|
---|
| 431 | }
|
---|
| 432 |
|
---|
[93136] | 433 | ULONG cbWritten = 0;
|
---|
| 434 | do
|
---|
[93144] | 435 | rc = DosWrite(hFile, pEditor->pszNew, cbToWrite, &cbWritten);
|
---|
[93136] | 436 | while (rc == ERROR_INTERRUPT);
|
---|
| 437 | RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
|
---|
| 438 | if (rc != NO_ERROR)
|
---|
| 439 | rcExit = ApiErrorN(rc, 3, "Failed writing \"", pszFilename, "\"");
|
---|
[93144] | 440 | else if (cbWritten != cbToWrite)
|
---|
| 441 | {
|
---|
| 442 | char szNum1[32], szNum2[32];
|
---|
| 443 | rcExit = ErrorNStrings(RT_STR_TUPLE("Failed writing \""), pszFilename, -1, RT_STR_TUPLE("\" - incomplete write: "),
|
---|
| 444 | MyNumToString(szNum1, cbWritten), -1, RT_STR_TUPLE(" written, requested "),
|
---|
| 445 | MyNumToString(szNum2, cbToWrite), NULL, 0);
|
---|
| 446 | }
|
---|
[93136] | 447 |
|
---|
| 448 | rc = DosClose(hFile);
|
---|
| 449 | if (rc != NO_ERROR)
|
---|
| 450 | rcExit = ApiErrorN(rc, 3, "Failed closing \"", pszFilename, "\"");
|
---|
| 451 |
|
---|
[93144] | 452 | pEditor->pszNew[pEditor->cbNew - 1] = '\0'; /* replacing EOF */
|
---|
| 453 |
|
---|
[93136] | 454 | return rcExit;
|
---|
| 455 | }
|
---|
| 456 |
|
---|
| 457 |
|
---|
| 458 | /**
|
---|
| 459 | * Gets the next line.
|
---|
| 460 | *
|
---|
| 461 | * @returns The offset to pass to the next EditorGetLine call.
|
---|
| 462 | * @retval 0 if no further lines in the input file.
|
---|
| 463 | *
|
---|
| 464 | * @param pEditor Pointer to the editor.
|
---|
| 465 | * @param offSrc The current source offset. Initialize to zero before
|
---|
| 466 | * first calls and pass return value for subsequent calls
|
---|
| 467 | * @param ppchLine Where to return the pointer to the start of the line.
|
---|
| 468 | * @param pcchLine Where to return the length of the line (sans EOL).
|
---|
| 469 | */
|
---|
| 470 | static size_t EditorGetLine(FILEEDITOR *pEditor, size_t offSrc, const char **ppchLine, size_t *pcchLine)
|
---|
| 471 | {
|
---|
| 472 | if (offSrc < pEditor->cbOrg)
|
---|
| 473 | {
|
---|
| 474 | const char *pchLine = &pEditor->pszOrg[offSrc];
|
---|
| 475 | *ppchLine = pchLine;
|
---|
| 476 |
|
---|
| 477 | size_t cchMax = pEditor->cbOrg - offSrc;
|
---|
| 478 | const char *pchCr = (const char *)memchr(pchLine, '\r', cchMax);
|
---|
| 479 | const char *pchNl = (const char *)memchr(pchLine, '\n', pchCr ? pchCr - pchLine : cchMax);
|
---|
| 480 | size_t cchLine;
|
---|
| 481 | size_t cchEol;
|
---|
| 482 | if (pchCr && !pchNl)
|
---|
| 483 | {
|
---|
| 484 | cchLine = pchCr - pchLine;
|
---|
| 485 | cchEol = 1 + (pchCr[1] == '\n');
|
---|
| 486 | }
|
---|
| 487 | else if (pchNl)
|
---|
| 488 | {
|
---|
| 489 | cchLine = pchNl - pchLine;
|
---|
| 490 | cchEol = 1;
|
---|
| 491 | }
|
---|
| 492 | else
|
---|
| 493 | {
|
---|
| 494 | cchLine = cchMax;
|
---|
| 495 | cchEol = 0;
|
---|
| 496 | }
|
---|
| 497 | *pcchLine = cchLine;
|
---|
| 498 | return offSrc + cchLine + cchEol;
|
---|
| 499 | }
|
---|
| 500 |
|
---|
| 501 | *ppchLine = "";
|
---|
| 502 | *pcchLine = 0;
|
---|
| 503 | return 0;
|
---|
| 504 | }
|
---|
| 505 |
|
---|
| 506 |
|
---|
| 507 | /**
|
---|
[93144] | 508 | * Checks that a string doesn't contain any funny control characters.
|
---|
| 509 | *
|
---|
| 510 | * These bogus characters are counted and EditorCheckState should be called to
|
---|
| 511 | * check these after editing has completed.
|
---|
| 512 | */
|
---|
| 513 | static void EditorCheckString(FILEEDITOR *pEditor, const char *pchString, size_t cchString, const char *pszCaller)
|
---|
| 514 | {
|
---|
| 515 | for (size_t off = 0; off < cchString; off++)
|
---|
| 516 | {
|
---|
| 517 | if ( RT_C_IS_CNTRL(pchString[off])
|
---|
| 518 | && pchString[off] != '\t')
|
---|
| 519 | {
|
---|
| 520 | static char s_szHex[] = "0123456789abcdef";
|
---|
| 521 | char szDigits[3] = { s_szHex[pchString[off] >> 4], s_szHex[pchString[off] & 0xf], '\0' };
|
---|
| 522 | ErrorNStrings(pszCaller, -1, RT_STR_TUPLE(": Bogus control character in "),
|
---|
| 523 | pEditor == &g_ConfigSys ? "Config.sys: " : "Startup.cmd: ", -1, szDigits, 2, NULL, 0);
|
---|
| 524 | pEditor->cBogusChars++;
|
---|
| 525 | }
|
---|
| 526 | }
|
---|
| 527 | }
|
---|
| 528 |
|
---|
| 529 |
|
---|
| 530 | /**
|
---|
[93136] | 531 | * Adds a line to the output buffer.
|
---|
| 532 | *
|
---|
| 533 | * A CRLF is appended automatically.
|
---|
| 534 | *
|
---|
| 535 | * @returns true on success, false on overflow (error displayed and sets
|
---|
| 536 | * fOverflowed on the editor).
|
---|
| 537 | *
|
---|
| 538 | * @param pEditor Pointer to the editor.
|
---|
| 539 | * @param pchLine Pointer to the line string.
|
---|
| 540 | * @param cchLine The length of the line (sans newline).
|
---|
| 541 | */
|
---|
| 542 | static bool EditorPutLine(FILEEDITOR *pEditor, const char *pchLine, size_t cchLine)
|
---|
| 543 | {
|
---|
[93144] | 544 | EditorCheckString(pEditor, pchLine, cchLine, "EditorPutLine");
|
---|
| 545 |
|
---|
[93136] | 546 | size_t offNew = pEditor->cbNew;
|
---|
| 547 | if (offNew + cchLine + 2 < pEditor->cbNewAlloc)
|
---|
| 548 | {
|
---|
| 549 | char *pszNew = pEditor->pszNew;
|
---|
| 550 | memcpy(&pszNew[offNew], pchLine, cchLine);
|
---|
| 551 | offNew += cchLine;
|
---|
| 552 | pszNew[offNew++] = '\r';
|
---|
| 553 | pszNew[offNew++] = '\n';
|
---|
| 554 | pszNew[offNew] = '\0';
|
---|
| 555 | pEditor->cbNew = offNew;
|
---|
| 556 | return true;
|
---|
| 557 | }
|
---|
| 558 | pEditor->fOverflowed = true;
|
---|
| 559 | return false;
|
---|
| 560 | }
|
---|
| 561 |
|
---|
| 562 |
|
---|
| 563 | /**
|
---|
| 564 | * Writes a string to the output buffer.
|
---|
| 565 | *
|
---|
| 566 | * @returns true on success, false on overflow (error displayed and sets
|
---|
| 567 | * fOverflowed on the editor).
|
---|
| 568 | *
|
---|
| 569 | * @param pEditor Pointer to the editor.
|
---|
| 570 | * @param pchString Pointer to the string.
|
---|
| 571 | * @param cchString The length of the string.
|
---|
| 572 | */
|
---|
| 573 | static bool EditorPutStringN(FILEEDITOR *pEditor, const char *pchString, size_t cchString)
|
---|
| 574 | {
|
---|
[93144] | 575 | EditorCheckString(pEditor, pchString, cchString, "EditorPutStringN");
|
---|
| 576 |
|
---|
[93136] | 577 | size_t offNew = pEditor->cbNew;
|
---|
| 578 | if (offNew + cchString < pEditor->cbNewAlloc)
|
---|
| 579 | {
|
---|
| 580 | char *pszNew = pEditor->pszNew;
|
---|
| 581 | memcpy(&pszNew[offNew], pchString, cchString);
|
---|
| 582 | offNew += cchString;
|
---|
| 583 | pszNew[offNew] = '\0';
|
---|
| 584 | pEditor->cbNew = offNew;
|
---|
| 585 | return true;
|
---|
| 586 | }
|
---|
| 587 | pEditor->fOverflowed = true;
|
---|
| 588 | return false;
|
---|
| 589 | }
|
---|
| 590 |
|
---|
| 591 |
|
---|
[93138] | 592 | /**
|
---|
[93144] | 593 | * Checks the editor state and makes the editing was successful.
|
---|
| 594 | */
|
---|
| 595 | static RTEXITCODE EditorCheckState(FILEEDITOR *pEditor, const char *pszFilename)
|
---|
| 596 | {
|
---|
| 597 | if (pEditor->fOverflowed)
|
---|
| 598 | return ErrorNStrings(RT_STR_TUPLE("Editor overflowed while modifying \""), pszFilename, -1, RT_STR_TUPLE("\""));
|
---|
| 599 | if (pEditor->cBogusChars > 0)
|
---|
| 600 | return ErrorNStrings(RT_STR_TUPLE("Editing failed because \""), pszFilename, -1,
|
---|
| 601 | RT_STR_TUPLE("\" contains bogus control characters (see above)"));
|
---|
| 602 | return RTEXITCODE_SUCCESS;
|
---|
| 603 | }
|
---|
| 604 |
|
---|
| 605 |
|
---|
| 606 | /**
|
---|
[93138] | 607 | * Simplistic case-insensitive memory compare function.
|
---|
| 608 | */
|
---|
| 609 | static int MyMemICmp(void const *pv1, void const *pv2, size_t cb)
|
---|
| 610 | {
|
---|
| 611 | char const *pch1 = (const char *)pv1;
|
---|
| 612 | char const *pch2 = (const char *)pv2;
|
---|
| 613 | while (cb-- > 0)
|
---|
| 614 | {
|
---|
| 615 | char ch1 = *pch1++;
|
---|
| 616 | char ch2 = *pch2++;
|
---|
| 617 | if ( ch1 != ch2
|
---|
| 618 | && RT_C_TO_UPPER(ch1) != RT_C_TO_UPPER(ch2))
|
---|
| 619 | return (int)ch1 - (int)ch2;
|
---|
| 620 | }
|
---|
| 621 | return 0;
|
---|
| 622 | }
|
---|
| 623 |
|
---|
| 624 |
|
---|
[93136] | 625 | /**
|
---|
[93143] | 626 | * Matches a word deliminated by space of @a chAltSep.
|
---|
| 627 | *
|
---|
| 628 | * @returns true if matched, false if not.
|
---|
| 629 | * @param pchLine The line we're working on.
|
---|
[93144] | 630 | * @param poff The current line offset. Updated on match.
|
---|
[93143] | 631 | * @param cchLine The current line length.
|
---|
| 632 | * @param pszWord The word to match with.
|
---|
| 633 | * @param cchWord The length of the word to match.
|
---|
| 634 | * @param chAltSep Alternative word separator, optional.
|
---|
[93128] | 635 | */
|
---|
[93144] | 636 | static bool MatchWord(const char *pchLine, size_t *poff, size_t cchLine, const char *pszWord, size_t cchWord, char chAltSep = ' ')
|
---|
[93128] | 637 | {
|
---|
[93144] | 638 | size_t off = *poff;
|
---|
[93143] | 639 | pchLine += off;
|
---|
| 640 | cchLine -= off;
|
---|
| 641 | if (cchWord <= cchLine)
|
---|
| 642 | if (MyMemICmp(pchLine, pszWord, cchWord) == 0)
|
---|
| 643 | if ( cchWord == cchLine
|
---|
| 644 | || RT_C_IS_BLANK(pchLine[cchWord])
|
---|
| 645 | || pchLine[cchWord] == chAltSep)
|
---|
[93144] | 646 | {
|
---|
| 647 | *poff += cchWord;
|
---|
[93143] | 648 | return true;
|
---|
[93144] | 649 | }
|
---|
[93143] | 650 | return false;
|
---|
[93128] | 651 | }
|
---|
| 652 |
|
---|
| 653 |
|
---|
| 654 | /**
|
---|
[93144] | 655 | * Checks if the path @a pchLine[@a off] ends with @a pszFilename, ignoring case.
|
---|
[93136] | 656 | *
|
---|
| 657 | * @returns true if filename found, false if not.
|
---|
[93144] | 658 | * @param pchLine The line we're working on.
|
---|
| 659 | * @param off The current line offset where the image path of
|
---|
| 660 | * a DEVICE or IFS statement starts.
|
---|
| 661 | * @param cchLine The current line length.
|
---|
[93136] | 662 | * @param pszFilename The filename (no path) to match with, all upper
|
---|
| 663 | * cased.
|
---|
| 664 | * @param cchFilename The length of the filename to match with.
|
---|
| 665 | */
|
---|
[93144] | 666 | static bool MatchOnlyFilename(const char *pchLine, size_t off, size_t cchLine, const char *pszFilename, size_t cchFilename)
|
---|
[93136] | 667 | {
|
---|
[93144] | 668 | pchLine += off;
|
---|
| 669 | cchLine -= off;
|
---|
| 670 |
|
---|
[93136] | 671 | /*
|
---|
| 672 | * Skip ahead in pchString till we get to the filename.
|
---|
| 673 | */
|
---|
| 674 | size_t offFilename = 0;
|
---|
| 675 | size_t offCur = 0;
|
---|
[93144] | 676 | if ( cchLine > 2
|
---|
| 677 | && pchLine[1] == ':'
|
---|
| 678 | && RT_C_IS_ALPHA(pchLine[0]))
|
---|
[93136] | 679 | offCur += 2;
|
---|
[93144] | 680 | while (offCur < cchLine)
|
---|
[93136] | 681 | {
|
---|
[93144] | 682 | char ch = pchLine[offCur];
|
---|
| 683 | if (RTPATH_IS_SLASH(pchLine[offCur]))
|
---|
[93136] | 684 | offFilename = offCur + 1;
|
---|
| 685 | else if (RT_C_IS_BLANK(ch))
|
---|
| 686 | break;
|
---|
| 687 | offCur++;
|
---|
| 688 | }
|
---|
| 689 | size_t const cchLeftFilename = offCur - offFilename;
|
---|
[93144] | 690 | #ifdef DEBUG_MATCHING
|
---|
| 691 | WriteNStrings(g_hStdOut, RT_STR_TUPLE("debug: MatchOnlyFilename: '"), &pchLine[offFilename], cchLeftFilename,
|
---|
| 692 | RT_STR_TUPLE("' vs '"), pszFilename, cchFilename, RT_STR_TUPLE("'\r\n"), NULL, 0);
|
---|
| 693 | #endif
|
---|
[93136] | 694 |
|
---|
| 695 | /*
|
---|
| 696 | * Check if the length matches.
|
---|
| 697 | */
|
---|
| 698 | if (cchLeftFilename != cchFilename)
|
---|
| 699 | return false;
|
---|
| 700 |
|
---|
| 701 | /*
|
---|
| 702 | * Check if the filenames matches (ASSUMES right side is uppercased).
|
---|
| 703 | */
|
---|
[93144] | 704 | pchLine += offFilename;
|
---|
[93136] | 705 | while (cchFilename-- > 0)
|
---|
| 706 | {
|
---|
[93144] | 707 | if (RT_C_TO_UPPER(*pchLine) != *pszFilename)
|
---|
[93136] | 708 | return false;
|
---|
[93144] | 709 | pchLine++;
|
---|
[93136] | 710 | pszFilename++;
|
---|
| 711 | }
|
---|
[93144] | 712 | #ifdef DEBUG_MATCHING
|
---|
| 713 | WriteStrings(g_hStdOut, "debug: MatchOnlyFilename: -> true\r\n", NULL);
|
---|
| 714 | #endif
|
---|
[93136] | 715 | return true;
|
---|
| 716 | }
|
---|
| 717 |
|
---|
| 718 |
|
---|
[93144] | 719 | static bool MatchPath(const char *pchPath1, size_t cchPath1, const char *pchPath2, size_t cchPath2)
|
---|
| 720 | {
|
---|
| 721 | #ifdef DEBUG_MATCHING
|
---|
| 722 | WriteNStrings(g_hStdOut, RT_STR_TUPLE("debug: MatchPath: '"), pchPath1, cchPath1,
|
---|
| 723 | RT_STR_TUPLE("' vs '"), pchPath2, cchPath2, RT_STR_TUPLE("'\r\n"), NULL, 0);
|
---|
| 724 | #endif
|
---|
| 725 |
|
---|
| 726 | while (cchPath1 > 0 && cchPath2 > 0)
|
---|
| 727 | {
|
---|
| 728 | char const ch1 = *pchPath1++;
|
---|
| 729 | cchPath1--;
|
---|
| 730 | char const ch2 = *pchPath2++;
|
---|
| 731 | cchPath2--;
|
---|
| 732 |
|
---|
| 733 | /* Slashes are special as it generally doesn't matter how many are in
|
---|
| 734 | a row, at least no on decent systems. */
|
---|
| 735 | if (RTPATH_IS_SLASH(ch1))
|
---|
| 736 | {
|
---|
| 737 | if (!RTPATH_IS_SLASH(ch2))
|
---|
| 738 | return false;
|
---|
| 739 | while (cchPath1 > 0 && RTPATH_IS_SLASH(*pchPath1))
|
---|
| 740 | pchPath1++, cchPath1--;
|
---|
| 741 | while (cchPath2 > 0 && RTPATH_IS_SLASH(*pchPath2))
|
---|
| 742 | pchPath2++, cchPath2--;
|
---|
| 743 | }
|
---|
| 744 | /* Just uppercase before comparing to save space. */
|
---|
| 745 | else if (RT_C_TO_UPPER(ch1) != RT_C_TO_UPPER(ch2))
|
---|
| 746 | return false;
|
---|
| 747 | }
|
---|
| 748 |
|
---|
| 749 | /* Ignore trailing slashes before reaching a conclusion. */
|
---|
| 750 | while (cchPath1 > 0 && RTPATH_IS_SLASH(*pchPath1))
|
---|
| 751 | pchPath1++, cchPath1--;
|
---|
| 752 | while (cchPath2 > 0 && RTPATH_IS_SLASH(*pchPath2))
|
---|
| 753 | pchPath2++, cchPath2--;
|
---|
| 754 |
|
---|
| 755 | #ifdef DEBUG_MATCHING
|
---|
| 756 | if (cchPath1 == 0 && cchPath2 == 0)
|
---|
| 757 | WriteStrings(g_hStdOut, "debug: MatchPath: -> true\r\n", NULL);
|
---|
| 758 | #endif
|
---|
| 759 | return cchPath1 == 0 && cchPath2 == 0;
|
---|
| 760 | }
|
---|
| 761 |
|
---|
| 762 |
|
---|
[93143] | 763 | /*********************************************************************************************************************************
|
---|
| 764 | * Installation Steps. *
|
---|
| 765 | *********************************************************************************************************************************/
|
---|
| 766 |
|
---|
| 767 | /**
|
---|
| 768 | * Checks that the necessary GRADD components are present.
|
---|
| 769 | */
|
---|
| 770 | static RTEXITCODE CheckForGradd(void)
|
---|
| 771 | {
|
---|
| 772 | strcpy(&g_szBootDrivePath[g_cchBootDrivePath], "OS2\\DLL\\GENGRADD.DLL");
|
---|
| 773 | FILESTATUS3 FileSts;
|
---|
| 774 | APIRET rc = DosQueryPathInfo(g_szBootDrivePath, FIL_STANDARD, &FileSts, sizeof(FileSts));
|
---|
| 775 | if (rc != NO_ERROR)
|
---|
[93144] | 776 | return ApiErrorN(rc, 3, "DosQueryPathInfo(\"", g_szBootDrivePath, "\",,,) [installed gengradd?] ");
|
---|
[93143] | 777 |
|
---|
| 778 | /* Note! GRADD precense in Config.sys is checked below while modifying it. */
|
---|
| 779 | return RTEXITCODE_SUCCESS;
|
---|
| 780 | }
|
---|
| 781 |
|
---|
| 782 |
|
---|
[93155] | 783 | /** Adds DEVICE=[path]\\VBoxGuest.sys to the modified Config.sys. */
|
---|
[93136] | 784 | static bool ConfigSysAddVBoxGuest(void)
|
---|
| 785 | {
|
---|
| 786 | EditorPutStringN(&g_ConfigSys, RT_STR_TUPLE("DEVICE="));
|
---|
| 787 | EditorPutStringN(&g_ConfigSys, g_szDstPath, g_cchDstPath);
|
---|
| 788 | EditorPutLine(&g_ConfigSys, RT_STR_TUPLE("VBoxGuest.sys"));
|
---|
| 789 | return true;
|
---|
| 790 | }
|
---|
| 791 |
|
---|
| 792 |
|
---|
[93155] | 793 | /** Adds IFS=[path]\\VBoxSF.IFS to the modified Config.sys. */
|
---|
[93136] | 794 | static bool ConfigSysAddVBoxSF(void)
|
---|
| 795 | {
|
---|
| 796 | EditorPutStringN(&g_ConfigSys, RT_STR_TUPLE("IFS="));
|
---|
| 797 | EditorPutStringN(&g_ConfigSys, g_szDstPath, g_cchDstPath);
|
---|
| 798 | EditorPutLine(&g_ConfigSys, RT_STR_TUPLE("VBoxSF.ifs"));
|
---|
| 799 | return true;
|
---|
| 800 | }
|
---|
| 801 |
|
---|
| 802 |
|
---|
[93155] | 803 | /** Adds DEVICE=[path]\\VBoxMouse.sys to the modified Config.sys. */
|
---|
[93136] | 804 | static bool ConfigSysAddVBoxMouse(void)
|
---|
| 805 | {
|
---|
| 806 | EditorPutStringN(&g_ConfigSys, RT_STR_TUPLE("DEVICE="));
|
---|
| 807 | EditorPutStringN(&g_ConfigSys, g_szDstPath, g_cchDstPath);
|
---|
| 808 | EditorPutLine(&g_ConfigSys, RT_STR_TUPLE("VBoxMouse.sys"));
|
---|
| 809 | return true;
|
---|
| 810 | }
|
---|
| 811 |
|
---|
| 812 |
|
---|
| 813 | /**
|
---|
[93138] | 814 | * Strips leading and trailing spaces and commas from the given substring.
|
---|
| 815 | *
|
---|
| 816 | * This is for GRADD_CHAINS and friends.
|
---|
| 817 | */
|
---|
| 818 | static size_t StripGraddList(const char **ppch, size_t cch)
|
---|
| 819 | {
|
---|
| 820 | const char *pch = *ppch;
|
---|
| 821 | while ( cch > 0
|
---|
| 822 | && ( RT_C_IS_BLANK(pch[0])
|
---|
| 823 | || pch[0] == ',') )
|
---|
| 824 | cch--, pch++;
|
---|
| 825 | *ppch = pch;
|
---|
| 826 |
|
---|
| 827 | while ( cch > 0
|
---|
| 828 | && ( RT_C_IS_BLANK(pch[cch - 1])
|
---|
| 829 | || pch[cch - 1] == ',') )
|
---|
| 830 | cch--;
|
---|
| 831 | return cch;
|
---|
| 832 | }
|
---|
| 833 |
|
---|
| 834 |
|
---|
| 835 | /**
|
---|
[93128] | 836 | * Prepares the config.sys modifications.
|
---|
| 837 | */
|
---|
| 838 | static RTEXITCODE PrepareConfigSys(void)
|
---|
| 839 | {
|
---|
[93136] | 840 | if (g_fSkipMask & SKIP_CONFIG_SYS)
|
---|
| 841 | return RTEXITCODE_SUCCESS;
|
---|
| 842 |
|
---|
| 843 | strcpy(&g_szBootDrivePath[g_cchBootDrivePath], "CONFIG.SYS");
|
---|
[93144] | 844 | RTEXITCODE rcExit = EditorReadInFile(&g_ConfigSys, g_szBootDrivePath, 4096, true /*fMustExist*/);
|
---|
[93136] | 845 | if (rcExit != RTEXITCODE_SUCCESS)
|
---|
| 846 | return rcExit;
|
---|
| 847 |
|
---|
| 848 | /*
|
---|
| 849 | * Figure out which IFS we should place ourselves after by examining the
|
---|
| 850 | * destination path's file system, assuming HPFS if we cannot figure it out.
|
---|
| 851 | */
|
---|
| 852 | const char *pszAfterIfs = "HPFS.IFS";
|
---|
| 853 | size_t cchAfterIfs = sizeof("HPFS.IFS") - 1;
|
---|
| 854 |
|
---|
| 855 | union
|
---|
| 856 | {
|
---|
| 857 | FSQBUFFER2 FsQBuf;
|
---|
| 858 | uint8_t abPadding[1024];
|
---|
| 859 | } u;
|
---|
| 860 | memset(&u, 0, sizeof(u));
|
---|
| 861 | ULONG cbBuf = sizeof(u) - 8 /* for adding .IFS */;
|
---|
| 862 |
|
---|
| 863 | char szDrv[4];
|
---|
| 864 | szDrv[0] = g_szDstPath[0];
|
---|
| 865 | szDrv[1] = g_szDstPath[1];
|
---|
| 866 | szDrv[2] = '\0';
|
---|
| 867 |
|
---|
| 868 | APIRET rc = DosQueryFSAttach(szDrv, 0 /*iOrdinal*/, FSAIL_QUERYNAME, &u.FsQBuf, &cbBuf);
|
---|
| 869 | if ( rc == NO_ERROR
|
---|
| 870 | || (rc == ERROR_BUFFER_OVERFLOW && u.FsQBuf.cbFSDName > 2 && u.FsQBuf.cbFSDName <= 7))
|
---|
| 871 | {
|
---|
| 872 | char *pszFsdName = (char *)&u.FsQBuf.szName[u.FsQBuf.cbName + 1];
|
---|
| 873 | if ( RT_C_IS_ALNUM(pszFsdName[0])
|
---|
| 874 | && RT_C_IS_ALNUM(pszFsdName[1])
|
---|
| 875 | && pszFsdName[u.FsQBuf.cbFSDName] == '\0')
|
---|
| 876 | {
|
---|
| 877 | /* MatchOnlyFilename requires it to be all uppercase (should be the case already). */
|
---|
| 878 | size_t off = u.FsQBuf.cbFSDName;
|
---|
| 879 | while (off-- > 0)
|
---|
| 880 | pszFsdName[off] = RT_C_TO_UPPER(pszFsdName[off]);
|
---|
| 881 |
|
---|
| 882 | /* Add the IFS suffix. */
|
---|
| 883 | strcpy(&pszFsdName[u.FsQBuf.cbFSDName], ".IFS");
|
---|
| 884 | pszAfterIfs = pszFsdName;
|
---|
| 885 | cchAfterIfs = u.FsQBuf.cbFSDName + sizeof(".IFS") - 1;
|
---|
| 886 |
|
---|
| 887 | if (g_fVerbose)
|
---|
| 888 | WriteStrings(g_hStdOut, "info: Found \"IFS=", pszFsdName, "\" for ", pszFsdName, "\r\n", NULL);
|
---|
| 889 | }
|
---|
| 890 | else
|
---|
| 891 | {
|
---|
| 892 | pszFsdName[10] = '\0';
|
---|
| 893 | ApiErrorN(ERROR_INVALID_NAME, 5, "Bogus FSD name \"", pszFsdName, "\" for ", szDrv, " - assuming HPFS");
|
---|
| 894 | }
|
---|
| 895 | }
|
---|
| 896 | else
|
---|
| 897 | ApiErrorN(rc, 3, "DosQueryFSAttach(", szDrv, ") - assuming HPFS");
|
---|
| 898 |
|
---|
| 899 | /*
|
---|
| 900 | * Do a scan to locate where to insert ourselves and such.
|
---|
| 901 | */
|
---|
| 902 | char szLineNo[32];
|
---|
[93144] | 903 | char szNumBuf[32];
|
---|
[93136] | 904 | bool fInsertedGuest = false;
|
---|
| 905 | bool fInsertedMouse = RT_BOOL(g_fSkipMask & SKIP_MOUSE);
|
---|
| 906 | bool fPendingMouse = false;
|
---|
| 907 | bool fInsertedIfs = RT_BOOL(g_fSkipMask & SKIP_SHARED_FOLDERS);
|
---|
| 908 | unsigned cPathsFound = 0;
|
---|
[93142] | 909 | const char *pchGraddChains = "C1";
|
---|
| 910 | size_t cchGraddChains = sizeof("C1") - 1;
|
---|
[93138] | 911 | const char *pchGraddChain1 = NULL;
|
---|
| 912 | size_t cchGraddChain1 = NULL;
|
---|
[93136] | 913 | unsigned iLine = 0;
|
---|
| 914 | size_t offSrc = 0;
|
---|
| 915 | const char *pchLine;
|
---|
| 916 | size_t cchLine;
|
---|
| 917 | while ((offSrc = EditorGetLine(&g_ConfigSys, offSrc, &pchLine, &cchLine)) != 0)
|
---|
| 918 | {
|
---|
| 919 | iLine++;
|
---|
| 920 |
|
---|
| 921 | size_t off = 0;
|
---|
| 922 | #define SKIP_BLANKS() \
|
---|
| 923 | while (off < cchLine && RT_C_IS_BLANK(pchLine[off])) \
|
---|
| 924 | off++
|
---|
| 925 |
|
---|
| 926 | bool fDone = false;
|
---|
| 927 | SKIP_BLANKS();
|
---|
| 928 |
|
---|
| 929 | /*
|
---|
| 930 | * Add the destination directory to the PATH.
|
---|
| 931 | * If there are multiple SET PATH statements, we add ourselves to all of them.
|
---|
| 932 | */
|
---|
[93144] | 933 | if (MatchWord(pchLine, &off, cchLine, RT_STR_TUPLE("SET")))
|
---|
[93136] | 934 | {
|
---|
| 935 | SKIP_BLANKS();
|
---|
[93144] | 936 | if (MatchWord(pchLine, &off, cchLine, RT_STR_TUPLE("PATH"), '='))
|
---|
[93136] | 937 | {
|
---|
| 938 | SKIP_BLANKS();
|
---|
| 939 | if (cchLine > off && pchLine[off] == '=')
|
---|
| 940 | {
|
---|
| 941 | off++;
|
---|
| 942 | SKIP_BLANKS();
|
---|
| 943 |
|
---|
| 944 | if (g_fVerbose)
|
---|
| 945 | WriteStrings(g_hStdOut, "info: Config.sys line ", MyNumToString(szLineNo, iLine), ": SET PATH\r\n", NULL);
|
---|
| 946 |
|
---|
[93144] | 947 | /* Strip trailing spaces and semicolons. */
|
---|
| 948 | while (cchLine > off && (RT_C_IS_BLANK(pchLine[cchLine - 1]) || pchLine[cchLine - 1] == ';'))
|
---|
| 949 | cchLine--;
|
---|
[93136] | 950 |
|
---|
[93144] | 951 | /* Remove any previous entries of the destination directory. */
|
---|
| 952 | unsigned iElement = 0;
|
---|
| 953 | char chLast = 0;
|
---|
| 954 | uint32_t cchWritten = 0;
|
---|
| 955 | while (off < cchLine)
|
---|
[93136] | 956 | {
|
---|
[93144] | 957 | iElement++;
|
---|
| 958 | const char *pszElement = &pchLine[off];
|
---|
| 959 | const char *pszSemiColon = (const char *)memchr(&pchLine[off], ';', cchLine - off);
|
---|
| 960 | size_t cchElement = (pszSemiColon ? pszSemiColon : &pchLine[cchLine]) - pszElement;
|
---|
| 961 | if (MatchPath(pszElement, cchElement, g_szDstPath, g_cchDstPath - (g_cchDstPath > 3 ? 1 : 0)))
|
---|
| 962 | {
|
---|
| 963 | if (g_fVerbose)
|
---|
| 964 | WriteNStrings(g_hStdOut, RT_STR_TUPLE("info: Config.sys line "),
|
---|
| 965 | MyNumToString(szLineNo, iLine), -1, RT_STR_TUPLE(": Removing PATH element #"),
|
---|
| 966 | MyNumToString(szNumBuf, iElement), -1, RT_STR_TUPLE(" \""), pszElement, cchElement,
|
---|
| 967 | RT_STR_TUPLE("\"\r\n"), NULL, 0);
|
---|
| 968 | EditorPutStringN(&g_ConfigSys, &pchLine[cchWritten], off - cchWritten);
|
---|
| 969 | chLast = pchLine[off - 1];
|
---|
| 970 | cchWritten = off + cchElement + (chLast == ';');
|
---|
| 971 | }
|
---|
| 972 | off += cchElement + 1;
|
---|
[93136] | 973 | }
|
---|
[93144] | 974 |
|
---|
| 975 | /* Write out the rest of the line and append the destination directory to it. */
|
---|
| 976 | if (cchLine > cchWritten)
|
---|
| 977 | {
|
---|
| 978 | EditorPutStringN(&g_ConfigSys, &pchLine[cchWritten], cchLine - cchWritten);
|
---|
| 979 | chLast = pchLine[cchLine - 1];
|
---|
| 980 | }
|
---|
| 981 | if (chLast != ';')
|
---|
| 982 | EditorPutStringN(&g_ConfigSys, RT_STR_TUPLE(";"));
|
---|
| 983 | EditorPutStringN(&g_ConfigSys, g_szDstPath, g_cchDstPath - (g_cchDstPath > 3 ? 1 : 0));
|
---|
| 984 | EditorPutLine(&g_ConfigSys, RT_STR_TUPLE(";"));
|
---|
| 985 | fDone = true;
|
---|
| 986 |
|
---|
[93136] | 987 | cPathsFound += 1;
|
---|
| 988 | }
|
---|
| 989 | }
|
---|
[93138] | 990 | /*
|
---|
| 991 | * Look for the GRADD_CHAINS variable.
|
---|
| 992 | *
|
---|
[93142] | 993 | * It is a comma separated list of chains (other env.vars.), however
|
---|
| 994 | * we can only deal with a single element. This shouldn't be an issue
|
---|
| 995 | * as GRADD_CHAINS is standardized by COMGRADD.DSP to the value C1, so
|
---|
| 996 | * other values can only be done by users or special drivers.
|
---|
[93138] | 997 | */
|
---|
[93144] | 998 | else if (MatchWord(pchLine, &off, cchLine, RT_STR_TUPLE("GRADD_CHAINS"), '='))
|
---|
[93138] | 999 | {
|
---|
| 1000 | SKIP_BLANKS();
|
---|
| 1001 | if (cchLine > off && pchLine[off] == '=')
|
---|
| 1002 | {
|
---|
| 1003 | off++;
|
---|
| 1004 |
|
---|
[93142] | 1005 | const char *pchNew = &pchLine[off];
|
---|
| 1006 | size_t cchNew = StripGraddList(&pchNew, cchLine - off);
|
---|
[93138] | 1007 |
|
---|
[93142] | 1008 | const char *pszComma = (const char *)memchr(pchNew, ',', cchNew);
|
---|
[93138] | 1009 | if (pszComma)
|
---|
| 1010 | {
|
---|
[93142] | 1011 | cchNew = StripGraddList(&pchNew, pchNew - pszComma);
|
---|
[93138] | 1012 | WriteStrings(g_hStdOut, "warning: Config.sys line ", MyNumToString(szLineNo, iLine),
|
---|
| 1013 | "GRADD_CHAINS contains more than one element. Ignoring all but the first.\r\n", NULL);
|
---|
| 1014 | }
|
---|
| 1015 |
|
---|
[93142] | 1016 | /* If it differs from the default "C1" / previous value, we must
|
---|
| 1017 | restart the search for the primary chain environment variable.
|
---|
| 1018 | This means that chains values other than "C1" must come after
|
---|
| 1019 | the GRADD_CHAINS statement, since we're not doing an extra pass. */
|
---|
| 1020 | if ( cchGraddChains != cchNew
|
---|
| 1021 | || MyMemICmp(pchNew, pchGraddChains, cchNew) == 0)
|
---|
| 1022 | {
|
---|
| 1023 | pchGraddChains = pchNew;
|
---|
| 1024 | cchGraddChains = cchNew;
|
---|
| 1025 | pchGraddChain1 = NULL;
|
---|
| 1026 | cchGraddChain1 = 0;
|
---|
| 1027 | }
|
---|
| 1028 |
|
---|
[93138] | 1029 | if (g_fVerbose)
|
---|
| 1030 | WriteNStrings(g_hStdOut, RT_STR_TUPLE("info: Config.sys line "), MyNumToString(szLineNo, iLine), - 1,
|
---|
| 1031 | RT_STR_TUPLE(": SET GRADD_CHAINS="), &pchLine[off], cchLine - off,
|
---|
| 1032 | RT_STR_TUPLE("\r\n"), NULL, 0);
|
---|
| 1033 | }
|
---|
| 1034 | }
|
---|
| 1035 | /*
|
---|
| 1036 | * Look for the chains listed by GRADD_CHAINS.
|
---|
| 1037 | */
|
---|
[93144] | 1038 | else if (MatchWord(pchLine, &off, cchLine, pchGraddChains, cchGraddChains, '='))
|
---|
[93138] | 1039 | {
|
---|
| 1040 | SKIP_BLANKS();
|
---|
| 1041 | if (cchLine > off && pchLine[off] == '=')
|
---|
| 1042 | {
|
---|
| 1043 | off++;
|
---|
| 1044 | SKIP_BLANKS();
|
---|
| 1045 |
|
---|
| 1046 | /* Just save it, we'll validate it after processing everything. */
|
---|
| 1047 | pchGraddChain1 = &pchLine[off];
|
---|
| 1048 | cchGraddChain1 = StripGraddList(&pchGraddChain1, cchLine - off);
|
---|
| 1049 |
|
---|
| 1050 | if (g_fVerbose)
|
---|
| 1051 | WriteNStrings(g_hStdOut, RT_STR_TUPLE("info: Config.sys line "), MyNumToString(szLineNo, iLine), - 1,
|
---|
| 1052 | RT_STR_TUPLE(": Found GRADD chain "), pchGraddChains, cchGraddChains,
|
---|
| 1053 | RT_STR_TUPLE(" with value: "), pchGraddChain1, cchGraddChain1,
|
---|
| 1054 | RT_STR_TUPLE("\r\n"), NULL, 0);
|
---|
| 1055 | }
|
---|
| 1056 | }
|
---|
[93136] | 1057 | }
|
---|
| 1058 | /*
|
---|
| 1059 | * Look for that IFS that should be loaded before we can load our drivers.
|
---|
| 1060 | */
|
---|
[93144] | 1061 | else if (MatchWord(pchLine, &off, cchLine, RT_STR_TUPLE("IFS"), '='))
|
---|
[93136] | 1062 | {
|
---|
| 1063 | SKIP_BLANKS();
|
---|
| 1064 | if (cchLine > off && pchLine[off] == '=')
|
---|
| 1065 | {
|
---|
| 1066 | off++;
|
---|
| 1067 | SKIP_BLANKS();
|
---|
[93144] | 1068 | if (MatchOnlyFilename(pchLine, off, cchLine, pszAfterIfs, cchAfterIfs))
|
---|
[93136] | 1069 | {
|
---|
| 1070 | if (g_fVerbose)
|
---|
| 1071 | WriteStrings(g_hStdOut, "info: Config.sys line ", MyNumToString(szLineNo, iLine),
|
---|
| 1072 | ": Found IFS=", pszAfterIfs, "\r\n", NULL);
|
---|
| 1073 | EditorPutLine(&g_ConfigSys, pchLine, cchLine);
|
---|
| 1074 | fDone = true;
|
---|
| 1075 |
|
---|
| 1076 | if (!fInsertedGuest)
|
---|
| 1077 | fInsertedGuest = ConfigSysAddVBoxGuest();
|
---|
| 1078 | if (!fInsertedIfs)
|
---|
| 1079 | fInsertedIfs = ConfigSysAddVBoxSF();
|
---|
| 1080 | if (fPendingMouse && !fInsertedMouse)
|
---|
| 1081 | fInsertedMouse = ConfigSysAddVBoxMouse();
|
---|
| 1082 | }
|
---|
| 1083 | /* Remove old VBoxSF.IFS lines */
|
---|
| 1084 | else if ( !(g_fSkipMask & SKIP_SHARED_FOLDERS)
|
---|
[93155] | 1085 | && ( MatchOnlyFilename(pchLine, off, cchLine, RT_STR_TUPLE("VBOXSF.IFS"))
|
---|
| 1086 | || MatchOnlyFilename(pchLine, off, cchLine, RT_STR_TUPLE("VBOXFS.IFS")) ) )
|
---|
[93136] | 1087 | {
|
---|
| 1088 | if (g_fVerbose)
|
---|
| 1089 | WriteStrings(g_hStdOut, "info: Config.sys line ", MyNumToString(szLineNo, iLine),
|
---|
| 1090 | ": Removing old VBoxSF.ifs statement\r\n", NULL);
|
---|
| 1091 | fDone = true;
|
---|
| 1092 | }
|
---|
| 1093 | }
|
---|
| 1094 | }
|
---|
| 1095 | /*
|
---|
| 1096 | * Look for the mouse driver we need to comment out / existing VBoxMouse.sys,
|
---|
| 1097 | * as well as older VBoxGuest.sys statements we should remove.
|
---|
| 1098 | */
|
---|
[93144] | 1099 | else if (MatchWord(pchLine, &off, cchLine, RT_STR_TUPLE("DEVICE"), '='))
|
---|
[93136] | 1100 | {
|
---|
| 1101 | SKIP_BLANKS();
|
---|
| 1102 | if (cchLine > off && pchLine[off] == '=')
|
---|
| 1103 | {
|
---|
| 1104 | off++;
|
---|
| 1105 | SKIP_BLANKS();
|
---|
| 1106 | if ( !(g_fSkipMask & SKIP_MOUSE)
|
---|
[93144] | 1107 | && MatchOnlyFilename(pchLine, off, cchLine, RT_STR_TUPLE("MOUSE.SYS")))
|
---|
[93136] | 1108 | {
|
---|
| 1109 | if (g_fVerbose)
|
---|
| 1110 | WriteStrings(g_hStdOut, "info: Config.sys line ", MyNumToString(szLineNo, iLine),
|
---|
| 1111 | ": Found DEVICE=<path>\\MOUSE.SYS\r\n", NULL);
|
---|
| 1112 | EditorPutStringN(&g_ConfigSys, RT_STR_TUPLE("REM "));
|
---|
| 1113 | EditorPutLine(&g_ConfigSys, pchLine, cchLine);
|
---|
| 1114 | fDone = true;
|
---|
| 1115 |
|
---|
| 1116 | if (!fInsertedMouse)
|
---|
| 1117 | {
|
---|
| 1118 | if (fInsertedGuest) /* means we've found the IFS and can access the destination dir */
|
---|
| 1119 | fInsertedMouse = ConfigSysAddVBoxMouse();
|
---|
| 1120 | else
|
---|
| 1121 | fPendingMouse = true;
|
---|
| 1122 | }
|
---|
| 1123 | }
|
---|
| 1124 | /* Remove or replace old VBoxMouse.IFS lines */
|
---|
| 1125 | else if ( !(g_fSkipMask & SKIP_MOUSE)
|
---|
[93144] | 1126 | && MatchOnlyFilename(pchLine, off, cchLine, RT_STR_TUPLE("VBOXMOUSE.SYS")))
|
---|
[93136] | 1127 | {
|
---|
| 1128 | if (g_fVerbose)
|
---|
| 1129 | WriteStrings(g_hStdOut, "info: Config.sys line ", MyNumToString(szLineNo, iLine), ": ",
|
---|
| 1130 | fInsertedMouse || !fInsertedGuest ? "Removing" : "Replacing",
|
---|
| 1131 | " old VBoxMouse.sys statement\r\n", NULL);
|
---|
| 1132 | if (!fInsertedMouse)
|
---|
| 1133 | {
|
---|
| 1134 | if (fInsertedGuest) /* means we've found the IFS and can access the destination dir */
|
---|
| 1135 | fInsertedMouse = ConfigSysAddVBoxMouse();
|
---|
| 1136 | else
|
---|
| 1137 | fPendingMouse = true;
|
---|
| 1138 | }
|
---|
| 1139 | fDone = true;
|
---|
| 1140 | }
|
---|
| 1141 | /* Remove old VBoxGuest.sys lines. */
|
---|
[93144] | 1142 | else if (MatchOnlyFilename(pchLine, off, cchLine, RT_STR_TUPLE("VBOXGUEST.SYS")))
|
---|
[93136] | 1143 | {
|
---|
| 1144 | if (g_fVerbose)
|
---|
| 1145 | WriteStrings(g_hStdOut, "info: Config.sys line ", MyNumToString(szLineNo, iLine),
|
---|
| 1146 | ": Removing old VBoxGuest.sys statement\r\n", NULL);
|
---|
| 1147 | fDone = true;
|
---|
| 1148 | }
|
---|
| 1149 | }
|
---|
| 1150 | }
|
---|
| 1151 | #undef SKIP_BLANKS
|
---|
| 1152 |
|
---|
| 1153 | /*
|
---|
| 1154 | * Output the current line if we didn't already do so above.
|
---|
| 1155 | */
|
---|
| 1156 | if (!fDone)
|
---|
| 1157 | EditorPutLine(&g_ConfigSys, pchLine, cchLine);
|
---|
| 1158 | }
|
---|
| 1159 |
|
---|
| 1160 | /*
|
---|
| 1161 | * If we've still got pending stuff, add it now at the end.
|
---|
| 1162 | */
|
---|
| 1163 | if (!fInsertedGuest)
|
---|
| 1164 | fInsertedGuest = ConfigSysAddVBoxGuest();
|
---|
| 1165 | if (!fInsertedIfs)
|
---|
| 1166 | fInsertedIfs = ConfigSysAddVBoxSF();
|
---|
| 1167 | if (!fInsertedMouse)
|
---|
| 1168 | fInsertedMouse = ConfigSysAddVBoxMouse();
|
---|
| 1169 |
|
---|
| 1170 | if (!cPathsFound)
|
---|
| 1171 | WriteStrings(g_hStdErr, "warning: Found no SET PATH statement in Config.sys.\r\n", NULL);
|
---|
| 1172 |
|
---|
[93138] | 1173 | /*
|
---|
| 1174 | * If we're installing the graphics driver, check that GENGRADD is in the
|
---|
| 1175 | * primary GRADD chain.
|
---|
| 1176 | */
|
---|
| 1177 | if (!(g_fSkipMask & SKIP_GRAPHICS))
|
---|
| 1178 | {
|
---|
[93142] | 1179 | if (cchGraddChain1 > 0 && cchGraddChains > 0)
|
---|
[93138] | 1180 | {
|
---|
| 1181 | int idxGenGradd = -1;
|
---|
| 1182 | for (size_t off = 0, idx = 0; off < cchGraddChain1;)
|
---|
| 1183 | {
|
---|
| 1184 | const char *psz = &pchGraddChain1[off];
|
---|
| 1185 | size_t cch = cchGraddChain1 - off;
|
---|
| 1186 | const char *pszComma = (const char *)memchr(psz, ',', cchGraddChain1 - off);
|
---|
| 1187 | if (!pszComma)
|
---|
| 1188 | off += cch;
|
---|
| 1189 | else
|
---|
| 1190 | {
|
---|
| 1191 | cch = pszComma - psz;
|
---|
| 1192 | off += cch + 1;
|
---|
| 1193 | }
|
---|
| 1194 | while (cch > 0 && RT_C_IS_BLANK(*psz))
|
---|
| 1195 | cch--, psz++;
|
---|
| 1196 | while (cch > 0 && RT_C_IS_BLANK(psz[cch - 1]))
|
---|
| 1197 | cch--;
|
---|
| 1198 | if ( cch == sizeof("GENGRADD") - 1
|
---|
| 1199 | && MyMemICmp(psz, RT_STR_TUPLE("GENGRADD")) == 0)
|
---|
| 1200 | {
|
---|
| 1201 | idxGenGradd = idx;
|
---|
| 1202 | break;
|
---|
| 1203 | }
|
---|
| 1204 | idx += cch != 0;
|
---|
| 1205 | }
|
---|
| 1206 | if (idxGenGradd < 0)
|
---|
| 1207 | return ErrorNStrings(RT_STR_TUPLE("Primary GRADD chain \""), pchGraddChains, cchGraddChains,
|
---|
| 1208 | RT_STR_TUPLE("="), pchGraddChain1, cchGraddChain1,
|
---|
| 1209 | RT_STR_TUPLE("\" does not contain a GENGRADD entry."), NULL, 0);
|
---|
| 1210 | if (idxGenGradd != 0)
|
---|
| 1211 | return ErrorNStrings(RT_STR_TUPLE("GENGRADD is not the first entry in the primary GRADD chain \""),
|
---|
| 1212 | pchGraddChains, cchGraddChains, RT_STR_TUPLE("="), pchGraddChain1, cchGraddChain1, NULL, 0);
|
---|
| 1213 | }
|
---|
[93142] | 1214 | else if (cchGraddChains > 0)
|
---|
[93138] | 1215 | return ErrorNStrings(RT_STR_TUPLE("Primary GRADD chain \""), pchGraddChains, cchGraddChains,
|
---|
| 1216 | RT_STR_TUPLE("\" not found (only searched after SET GRADD_CHAINS)."), NULL, 0);
|
---|
| 1217 | else
|
---|
| 1218 | return ErrorNStrings(RT_STR_TUPLE("No SET GRADD_CHAINS statement found in Config.sys"), NULL, 0);
|
---|
| 1219 | }
|
---|
| 1220 |
|
---|
[93144] | 1221 | return EditorCheckState(&g_ConfigSys, g_szBootDrivePath);
|
---|
[93128] | 1222 | }
|
---|
| 1223 |
|
---|
| 1224 |
|
---|
[93142] | 1225 | /** Puts the line starting VBoxService to Startup.cmd. */
|
---|
| 1226 | static void StartupCmdPutLine(const char *pszLineNo)
|
---|
| 1227 | {
|
---|
| 1228 | if (g_fVerbose)
|
---|
[93144] | 1229 | WriteStrings(g_hStdOut, "info: Starting VBoxService at line ", pszLineNo, " of Startup.cmd\r\n", NULL);
|
---|
[93142] | 1230 | EditorPutStringN(&g_StartupCmd, g_szDstPath, g_cchDstPath);
|
---|
| 1231 | EditorPutLine(&g_StartupCmd, RT_STR_TUPLE("VBoxService.exe"));
|
---|
| 1232 | }
|
---|
| 1233 |
|
---|
| 1234 |
|
---|
[93128] | 1235 | /**
|
---|
| 1236 | * Prepares the startup.cmd modifications.
|
---|
| 1237 | */
|
---|
| 1238 | static RTEXITCODE PrepareStartupCmd(void)
|
---|
| 1239 | {
|
---|
[93136] | 1240 | if (g_fSkipMask & SKIP_STARTUP_CMD)
|
---|
| 1241 | return RTEXITCODE_SUCCESS;
|
---|
| 1242 |
|
---|
| 1243 | strcpy(&g_szBootDrivePath[g_cchBootDrivePath], "STARTUP.CMD");
|
---|
| 1244 | RTEXITCODE rcExit = EditorReadInFile(&g_StartupCmd, g_szBootDrivePath, 1024, false /*fMustExist*/);
|
---|
| 1245 | if (rcExit != RTEXITCODE_SUCCESS)
|
---|
| 1246 | return rcExit;
|
---|
| 1247 |
|
---|
[93142] | 1248 | /*
|
---|
| 1249 | * Scan startup.cmd and see if there is an [@]ECHO OFF without anything other
|
---|
| 1250 | * than REM statements preceding it. If there is we'll insert ourselves after
|
---|
| 1251 | * that, otherwise we'll just jump in at the top.
|
---|
| 1252 | */
|
---|
| 1253 | unsigned iInsertBeforeLine = 0;
|
---|
| 1254 | unsigned iLine = 0;
|
---|
| 1255 | size_t offSrc = 0;
|
---|
| 1256 | const char *pchLine;
|
---|
| 1257 | size_t cchLine;
|
---|
| 1258 | while ((offSrc = EditorGetLine(&g_StartupCmd, offSrc, &pchLine, &cchLine)) != 0)
|
---|
| 1259 | {
|
---|
| 1260 | iLine++;
|
---|
| 1261 |
|
---|
| 1262 | size_t off = 0;
|
---|
| 1263 | #define SKIP_BLANKS() \
|
---|
| 1264 | while (off < cchLine && RT_C_IS_BLANK(pchLine[off])) \
|
---|
| 1265 | off++
|
---|
| 1266 | SKIP_BLANKS();
|
---|
| 1267 | if (off < cchLine && pchLine[off] == '@')
|
---|
| 1268 | {
|
---|
| 1269 | off++;
|
---|
| 1270 | SKIP_BLANKS();
|
---|
| 1271 | }
|
---|
[93144] | 1272 | if (MatchWord(pchLine, &off, cchLine, RT_STR_TUPLE("ECHO")))
|
---|
[93142] | 1273 | {
|
---|
| 1274 | SKIP_BLANKS();
|
---|
| 1275 |
|
---|
[93144] | 1276 | if (MatchWord(pchLine, &off, cchLine, RT_STR_TUPLE("OFF")))
|
---|
[93142] | 1277 | {
|
---|
| 1278 | iInsertBeforeLine = iLine + 1;
|
---|
| 1279 | break;
|
---|
| 1280 | }
|
---|
| 1281 | }
|
---|
[93144] | 1282 | else if (MatchWord(pchLine, &off, cchLine, RT_STR_TUPLE("REM")))
|
---|
[93142] | 1283 | { /* skip */ }
|
---|
| 1284 | else
|
---|
| 1285 | break;
|
---|
| 1286 | }
|
---|
| 1287 |
|
---|
| 1288 | /*
|
---|
| 1289 | * Make the modifications.
|
---|
| 1290 | */
|
---|
| 1291 | if (iInsertBeforeLine == 0) /* Necessary to do this outside the loop in case startup.cmd is empty or non-existing. */
|
---|
| 1292 | StartupCmdPutLine("1");
|
---|
| 1293 |
|
---|
| 1294 | offSrc = iLine = 0;
|
---|
| 1295 | while ((offSrc = EditorGetLine(&g_StartupCmd, offSrc, &pchLine, &cchLine)) != 0)
|
---|
| 1296 | {
|
---|
| 1297 | char szLineNo[32];
|
---|
| 1298 | iLine++;
|
---|
| 1299 | if (iLine == iInsertBeforeLine)
|
---|
| 1300 | StartupCmdPutLine(MyNumToString(szLineNo, iLine));
|
---|
| 1301 |
|
---|
| 1302 | /*
|
---|
| 1303 | * Filter out old VBoxService lines. To be on the safe side we skip
|
---|
| 1304 | * past DETACH, CALL, and START before checking for VBoxService.
|
---|
| 1305 | */
|
---|
| 1306 | size_t off = 0;
|
---|
| 1307 | SKIP_BLANKS();
|
---|
| 1308 | if (off < cchLine && pchLine[off] == '@')
|
---|
| 1309 | {
|
---|
| 1310 | off++;
|
---|
| 1311 | SKIP_BLANKS();
|
---|
| 1312 | }
|
---|
| 1313 |
|
---|
[93144] | 1314 | if (MatchWord(pchLine, &off, cchLine, RT_STR_TUPLE("DETACH")))
|
---|
[93142] | 1315 | SKIP_BLANKS();
|
---|
| 1316 |
|
---|
[93144] | 1317 | if (MatchWord(pchLine, &off, cchLine, RT_STR_TUPLE("CALL")))
|
---|
[93142] | 1318 | SKIP_BLANKS();
|
---|
| 1319 |
|
---|
[93144] | 1320 | if (MatchWord(pchLine, &off, cchLine, RT_STR_TUPLE("START")))
|
---|
[93142] | 1321 | SKIP_BLANKS();
|
---|
| 1322 |
|
---|
[93144] | 1323 | if ( MatchOnlyFilename(pchLine, off, cchLine, RT_STR_TUPLE("VBOXSERVICE.EXE"))
|
---|
| 1324 | || MatchOnlyFilename(pchLine, off, cchLine, RT_STR_TUPLE("VBOXSERVICE")) )
|
---|
[93142] | 1325 | {
|
---|
| 1326 | if (g_fVerbose)
|
---|
| 1327 | WriteStrings(g_hStdOut, "info: Removing old VBoxService statement on line ",
|
---|
| 1328 | MyNumToString(szLineNo, iLine), "\r\n", NULL);
|
---|
| 1329 | }
|
---|
| 1330 | else
|
---|
| 1331 | EditorPutLine(&g_StartupCmd, pchLine, cchLine);
|
---|
| 1332 |
|
---|
| 1333 | #undef SKIP_BLANKS
|
---|
| 1334 | }
|
---|
| 1335 |
|
---|
[93144] | 1336 | return EditorCheckState(&g_StartupCmd, g_szBootDrivePath);
|
---|
[93128] | 1337 | }
|
---|
| 1338 |
|
---|
| 1339 |
|
---|
| 1340 | /**
|
---|
[93145] | 1341 | * Tells the loader to cache all the pages in @a pszFile and close it, so that
|
---|
| 1342 | * we can modify or replace it.
|
---|
| 1343 | */
|
---|
| 1344 | static void CacheLdrFile(const char *pszFile)
|
---|
| 1345 | {
|
---|
| 1346 | if (g_fVerbose)
|
---|
| 1347 | DoWriteNStr(g_hStdOut, RT_STR_TUPLE("info: Sharing violation - applying DosReplaceModule...\r\n"));
|
---|
| 1348 |
|
---|
| 1349 | APIRET rc = DosReplaceModule(pszFile, NULL, NULL);
|
---|
| 1350 | if (rc != NO_ERROR)
|
---|
| 1351 | ApiErrorN(rc, 3, "DosReplaceModule(\"", pszFile, "\",,)");
|
---|
| 1352 | }
|
---|
| 1353 |
|
---|
| 1354 |
|
---|
| 1355 | /**
|
---|
[93136] | 1356 | * Worker for CopyFiles that handles one copying operation.
|
---|
| 1357 | */
|
---|
| 1358 | static RTEXITCODE CopyOneFile(const char *pszSrc, const char *pszDst)
|
---|
| 1359 | {
|
---|
[93145] | 1360 | FILESTATUS3 FileSts;
|
---|
[93136] | 1361 | if (g_fVerbose)
|
---|
| 1362 | WriteStrings(g_hStdOut, "info: Copying \"", pszSrc, "\" to \"", pszDst, "\"...\r\n", NULL);
|
---|
| 1363 |
|
---|
[93145] | 1364 | if (g_fRealRun)
|
---|
[93136] | 1365 | {
|
---|
[93145] | 1366 | /* Make sure the destination file isn't read-only before attempting to copying it. */
|
---|
| 1367 | APIRET rc = DosQueryPathInfo(pszDst, FIL_STANDARD, &FileSts, sizeof(FileSts));
|
---|
| 1368 | if (rc == NO_ERROR && (FileSts.attrFile & FILE_READONLY))
|
---|
| 1369 | {
|
---|
| 1370 | FileSts.attrFile &= ~FILE_READONLY;
|
---|
[93136] | 1371 |
|
---|
[93145] | 1372 | /* Don't update the timestamps: */
|
---|
| 1373 | *(USHORT *)&FileSts.fdateCreation = 0;
|
---|
| 1374 | *(USHORT *)&FileSts.ftimeCreation = 0;
|
---|
| 1375 | *(USHORT *)&FileSts.fdateLastAccess = 0;
|
---|
| 1376 | *(USHORT *)&FileSts.ftimeLastAccess = 0;
|
---|
| 1377 | *(USHORT *)&FileSts.fdateLastWrite = 0;
|
---|
| 1378 | *(USHORT *)&FileSts.ftimeLastWrite = 0;
|
---|
[93136] | 1379 |
|
---|
[93145] | 1380 | rc = DosSetPathInfo(pszDst, FIL_STANDARD, &FileSts, sizeof(FileSts), 0 /*fOptions*/);
|
---|
| 1381 | if (rc == ERROR_SHARING_VIOLATION)
|
---|
| 1382 | {
|
---|
| 1383 | CacheLdrFile(pszDst);
|
---|
| 1384 | rc = DosSetPathInfo(pszDst, FIL_STANDARD, &FileSts, sizeof(FileSts), 0 /*fOptions*/);
|
---|
| 1385 | }
|
---|
[93136] | 1386 |
|
---|
[93145] | 1387 | if (rc != NO_ERROR)
|
---|
| 1388 | ApiErrorN(rc, 3, "DosSetPathInfo(\"", pszDst, "\",~READONLY,)");
|
---|
| 1389 | }
|
---|
[93136] | 1390 |
|
---|
[93145] | 1391 | /* Do the copying. */
|
---|
| 1392 | rc = DosCopy(pszSrc, pszDst, DCPY_EXISTING);
|
---|
| 1393 | if (rc == NO_ERROR)
|
---|
| 1394 | return RTEXITCODE_SUCCESS;
|
---|
| 1395 | if (rc != ERROR_SHARING_VIOLATION)
|
---|
| 1396 | return ApiErrorN(rc, 3, "Failed copying to \"", pszDst, "\"");
|
---|
[93136] | 1397 |
|
---|
[93145] | 1398 | CacheLdrFile(pszDst);
|
---|
| 1399 | rc = DosCopy(pszSrc, pszDst, DCPY_EXISTING);
|
---|
| 1400 | if (rc == NO_ERROR)
|
---|
| 1401 | return RTEXITCODE_SUCCESS;
|
---|
| 1402 | return ApiErrorN(rc, 3, "Failed copying to \"", pszDst, "\"");
|
---|
| 1403 | }
|
---|
| 1404 | /*
|
---|
| 1405 | * Dry run: just check that the source file exists.
|
---|
| 1406 | */
|
---|
| 1407 | else
|
---|
| 1408 | {
|
---|
| 1409 | APIRET rc = DosQueryPathInfo(pszSrc, FIL_STANDARD, &FileSts, sizeof(FileSts));
|
---|
| 1410 | if (rc == NO_ERROR)
|
---|
| 1411 | return RTEXITCODE_SUCCESS;
|
---|
| 1412 | return ApiErrorN(rc, 3, "DosQueryPathInfo failed on \"", pszSrc, "\"");
|
---|
| 1413 | }
|
---|
[93136] | 1414 | }
|
---|
| 1415 |
|
---|
| 1416 |
|
---|
| 1417 | /**
|
---|
[93128] | 1418 | * Copies the GA files.
|
---|
| 1419 | */
|
---|
| 1420 | static RTEXITCODE CopyFiles(void)
|
---|
| 1421 | {
|
---|
[93145] | 1422 | if (g_fRealRun)
|
---|
| 1423 | {
|
---|
| 1424 | /*
|
---|
| 1425 | * Create the install directory. We do this from the root up as that is
|
---|
| 1426 | * a nice feature and saves us dealing with trailing slash troubles.
|
---|
| 1427 | */
|
---|
| 1428 | char *psz = g_szDstPath;
|
---|
| 1429 | if (psz[1] == ':' && RTPATH_IS_SLASH(psz[2]))
|
---|
| 1430 | psz += 3;
|
---|
| 1431 | else if (psz[1] == ':')
|
---|
| 1432 | psz += 2;
|
---|
| 1433 | else
|
---|
| 1434 | return ApiError("Unexpected condition", __LINE__);
|
---|
[93136] | 1435 |
|
---|
[93145] | 1436 | for (;;)
|
---|
| 1437 | {
|
---|
| 1438 | char ch;
|
---|
| 1439 | while ((ch = *psz) != '\0' && !RTPATH_IS_SLASH(ch))
|
---|
| 1440 | psz++;
|
---|
| 1441 | if (ch != '\0')
|
---|
| 1442 | *psz = '\0';
|
---|
| 1443 | APIRET rc = DosMkDir(g_szDstPath, 0);
|
---|
| 1444 | if (rc != NO_ERROR && rc != ERROR_ACCESS_DENIED /*HPFS*/ && rc != ERROR_ALREADY_EXISTS /*what one would expect*/)
|
---|
| 1445 | return ApiErrorN(rc, 3, "DosMkDir(\"", g_szDstPath, "\")");
|
---|
| 1446 | if (ch == '\0')
|
---|
| 1447 | break;
|
---|
| 1448 | *psz++ = ch;
|
---|
| 1449 | while ((ch = *psz) != '\0' && RTPATH_IS_SLASH(ch))
|
---|
| 1450 | psz++;
|
---|
| 1451 | if (ch == '\0')
|
---|
| 1452 | break;
|
---|
| 1453 | }
|
---|
[93136] | 1454 | }
|
---|
| 1455 |
|
---|
| 1456 | /*
|
---|
| 1457 | * Start copying files. We copy all files into the directory regardless
|
---|
| 1458 | * of whether they will be referenced by config.sys, startup.cmd or whatever.
|
---|
| 1459 | */
|
---|
| 1460 | static struct
|
---|
| 1461 | {
|
---|
| 1462 | const char *pszFile;
|
---|
| 1463 | const char *pszAltDst;
|
---|
| 1464 | uint8_t fSkipMask;
|
---|
| 1465 | } const s_aFiles[] =
|
---|
| 1466 | {
|
---|
| 1467 | { "VBoxService.exe", NULL, 0 }, /* first as likely to be running */
|
---|
| 1468 | { "VBoxControl.exe", NULL, 0 },
|
---|
| 1469 | { "VBoxReplaceDll.exe", NULL, 0 },
|
---|
[93144] | 1470 | { "gengradd.dll", "OS2\\DLL\\gengradd.dll", SKIP_GRAPHICS },
|
---|
| 1471 | { "libc06.dll", "OS2\\DLL\\libc06.dll", SKIP_LIBC_DLLS },
|
---|
| 1472 | { "libc061.dll", "OS2\\DLL\\libc061.dll", SKIP_LIBC_DLLS },
|
---|
| 1473 | { "libc062.dll", "OS2\\DLL\\libc062.dll", SKIP_LIBC_DLLS },
|
---|
| 1474 | { "libc063.dll", "OS2\\DLL\\libc063.dll", SKIP_LIBC_DLLS },
|
---|
| 1475 | { "libc064.dll", "OS2\\DLL\\libc064.dll", SKIP_LIBC_DLLS },
|
---|
| 1476 | { "libc065.dll", "OS2\\DLL\\libc065.dll", SKIP_LIBC_DLLS },
|
---|
| 1477 | { "libc066.dll", "OS2\\DLL\\libc066.dll", SKIP_LIBC_DLLS },
|
---|
[93136] | 1478 | { "VBoxGuest.sys", NULL, 0 },
|
---|
| 1479 | { "VBoxSF.ifs", NULL, 0 },
|
---|
| 1480 | { "vboxmouse.sys", NULL, 0 },
|
---|
| 1481 | { "readme.txt", NULL, 0 },
|
---|
| 1482 | };
|
---|
| 1483 |
|
---|
| 1484 | RTEXITCODE rcExit;
|
---|
| 1485 | for (size_t i = 0; i < RT_ELEMENTS(s_aFiles); i++)
|
---|
| 1486 | {
|
---|
| 1487 | /* Always copy files to the destination folder. */
|
---|
| 1488 | strcpy(&g_szSrcPath[g_cchSrcPath], s_aFiles[i].pszFile);
|
---|
| 1489 | strcpy(&g_szDstPath[g_cchDstPath], s_aFiles[i].pszFile);
|
---|
| 1490 | RTEXITCODE rcExit2 = CopyOneFile(g_szSrcPath, g_szDstPath);
|
---|
| 1491 | if (rcExit2 != RTEXITCODE_SUCCESS)
|
---|
| 1492 | rcExit = rcExit2;
|
---|
| 1493 |
|
---|
| 1494 | /* Additional install location and this not being skipped? */
|
---|
| 1495 | if ( s_aFiles[i].pszAltDst
|
---|
| 1496 | && !(s_aFiles[i].fSkipMask & g_fSkipMask) /* ASSUMES one skip bit per file */)
|
---|
| 1497 | {
|
---|
[93144] | 1498 | strcpy(&g_szBootDrivePath[g_cchBootDrivePath], s_aFiles[i].pszAltDst);
|
---|
[93136] | 1499 |
|
---|
| 1500 | rcExit2 = CopyOneFile(g_szSrcPath, g_szBootDrivePath);
|
---|
| 1501 | if (rcExit2 != RTEXITCODE_SUCCESS)
|
---|
| 1502 | rcExit = rcExit2;
|
---|
| 1503 | }
|
---|
| 1504 | }
|
---|
| 1505 |
|
---|
| 1506 | return rcExit;
|
---|
[93128] | 1507 | }
|
---|
| 1508 |
|
---|
| 1509 |
|
---|
| 1510 | /**
|
---|
| 1511 | * Writes out the modified config.sys.
|
---|
| 1512 | */
|
---|
| 1513 | static RTEXITCODE WriteConfigSys(void)
|
---|
| 1514 | {
|
---|
[93136] | 1515 | if (g_fSkipMask & SKIP_CONFIG_SYS)
|
---|
| 1516 | return RTEXITCODE_SUCCESS;
|
---|
| 1517 | strcpy(&g_szBootDrivePath[g_cchBootDrivePath], "CONFIG.SYS");
|
---|
| 1518 | return EditorWriteOutFile(&g_ConfigSys, g_szBootDrivePath);
|
---|
[93128] | 1519 | }
|
---|
| 1520 |
|
---|
| 1521 |
|
---|
| 1522 | /**
|
---|
| 1523 | * Writes out the modified startup.cmd.
|
---|
| 1524 | */
|
---|
| 1525 | static RTEXITCODE WriteStartupCmd(void)
|
---|
| 1526 | {
|
---|
[93136] | 1527 | if (g_fSkipMask & SKIP_CONFIG_SYS)
|
---|
| 1528 | return RTEXITCODE_SUCCESS;
|
---|
| 1529 | strcpy(&g_szBootDrivePath[g_cchBootDrivePath], "STARTUP.CMD");
|
---|
[93144] | 1530 | return EditorWriteOutFile(&g_StartupCmd, g_szBootDrivePath);
|
---|
[93128] | 1531 | }
|
---|
| 1532 |
|
---|
| 1533 |
|
---|
[93136] | 1534 | /*********************************************************************************************************************************
|
---|
| 1535 | * Option parsing and such. *
|
---|
| 1536 | *********************************************************************************************************************************/
|
---|
| 1537 |
|
---|
[93128] | 1538 | static RTEXITCODE ShowUsage(void)
|
---|
| 1539 | {
|
---|
[93136] | 1540 | static const char g_szUsage[] =
|
---|
| 1541 | VBOX_PRODUCT " OS/2 Additions Installer " VBOX_VERSION_STRING "\r\n"
|
---|
[96399] | 1542 | "Copyright (C) 2005-" VBOX_C_YEAR " " VBOX_VENDOR "\r\n"
|
---|
[93136] | 1543 | "\r\n"
|
---|
| 1544 | "This is a very barebone OS/2 guest additions installer which main purpose is\r\n"
|
---|
| 1545 | "to help with unattended installation. Do not expect it to handle complicated\r\n"
|
---|
| 1546 | "situations like upgrades and similar. It also does not understand arguments\r\n"
|
---|
| 1547 | "that are placed in double quotes.\r\n"
|
---|
| 1548 | "\r\n"
|
---|
| 1549 | "Usage: VBoxIs2AdditionsInstall.exe [options]\r\n"
|
---|
| 1550 | " or VBoxIs2AdditionsInstall.exe <-h|-?|--help>\r\n"
|
---|
| 1551 | " or VBoxIs2AdditionsInstall.exe <-v|--version>\r\n"
|
---|
| 1552 | "\r\n"
|
---|
[93144] | 1553 | "Options:\r\n"
|
---|
[93145] | 1554 | " -i, --do-install / -z, --dry-run\r\n"
|
---|
| 1555 | " Controls whether to do a real install or not. Default: --dry-run\r\n"
|
---|
[93136] | 1556 | " -s<path>, --source[=]<path>\r\n"
|
---|
| 1557 | " Specifies where the files to install are. Default: Same as installer\r\n"
|
---|
| 1558 | " -d<path>, --destination[=]<path>\r\n"
|
---|
| 1559 | " Specifies where to install all the VBox OS/2 additions files.\r\n"
|
---|
[93144] | 1560 | " Default: C:\VBoxAdd (C is replaced by actual boot drive)\r\n"
|
---|
[93136] | 1561 | " -b<path>, --boot-drive[=]<path>\r\n"
|
---|
| 1562 | " Specifies the boot drive. Default: C: (C is replaced by the actual one)\r\n"
|
---|
| 1563 | " -F, --no-shared-folders / -f, --shared-folders (default)\r\n"
|
---|
| 1564 | " Controls whether to put the shared folders IFS in Config.sys.\r\n"
|
---|
| 1565 | " -G, --no-graphics / -g, --graphics (default)\r\n"
|
---|
| 1566 | " Controls whether to replace OS2\\DLL\\GENGRADD.DLL with the VBox version.\r\n"
|
---|
| 1567 | " -M, --no-mouse / -m, --mouse (default)\r\n"
|
---|
| 1568 | " Controls whether to add the VBox mouse driver to Config.sys and disable\r\n"
|
---|
| 1569 | " the regular OS/2 one.\r\n"
|
---|
| 1570 | " -S, --no-service / -s, --service (default)\r\n"
|
---|
| 1571 | " Controls whether to add starting VBoxService from Startup.cmd.\r\n"
|
---|
| 1572 | " -T, --no-startup-cmd / -t, --startup-cmd (default)\r\n"
|
---|
| 1573 | " Controls whether to modify Startup.cmd.\r\n"
|
---|
| 1574 | " -C, --no-config-sys / -c, --config-sys (default)\r\n"
|
---|
| 1575 | " Controls whether to modify Config.sys.\r\n"
|
---|
| 1576 | " -L, --no-libc-dlls / -l, --libc-dlls (default)\r\n"
|
---|
| 1577 | " Controls whether copy the kLibC DLLs to OS2\\DLLS.\r\n"
|
---|
| 1578 | " -q, --quiet / -V, --verbose (default)\r\n"
|
---|
| 1579 | " Controls the installer noise level.\r\n"
|
---|
| 1580 | "\r\n"
|
---|
| 1581 | "Exit Codes:\r\n"
|
---|
| 1582 | " 0 - Success. Reboot required.\r\n"
|
---|
| 1583 | " 1 - Failure.\r\n"
|
---|
| 1584 | " 2 - Syntax error.\r\n"
|
---|
| 1585 | ;
|
---|
[93128] | 1586 | DoWriteNStr(g_hStdOut, RT_STR_TUPLE(g_szUsage));
|
---|
| 1587 | return RTEXITCODE_SUCCESS;
|
---|
| 1588 | }
|
---|
| 1589 |
|
---|
| 1590 |
|
---|
| 1591 | static RTEXITCODE ShowVersion(void)
|
---|
| 1592 | {
|
---|
[93136] | 1593 | DoWriteNStr(g_hStdOut, RT_STR_TUPLE(VBOX_VERSION_STRING " r"));
|
---|
| 1594 |
|
---|
| 1595 | const char *pszRev = "$Rev: 96407 $";
|
---|
| 1596 | while (!RT_C_IS_DIGIT(*pszRev))
|
---|
| 1597 | pszRev++;
|
---|
| 1598 | size_t cchRev = 1;
|
---|
| 1599 | while (RT_C_IS_DIGIT(pszRev[cchRev]))
|
---|
| 1600 | cchRev++;
|
---|
| 1601 | DoWriteNStr(g_hStdOut, pszRev, cchRev);
|
---|
| 1602 |
|
---|
| 1603 | DoWriteNStr(g_hStdOut, RT_STR_TUPLE("\r\n"));
|
---|
[93128] | 1604 | return RTEXITCODE_SUCCESS;
|
---|
| 1605 | }
|
---|
| 1606 |
|
---|
| 1607 |
|
---|
| 1608 | static bool MatchOptWord(PSZ *ppsz, const char *pszWord, size_t cchWord, bool fTakeValue = false)
|
---|
| 1609 | {
|
---|
| 1610 | PSZ psz = *ppsz;
|
---|
| 1611 | if (strncmp(psz, pszWord, cchWord) == 0)
|
---|
| 1612 | {
|
---|
| 1613 | psz += cchWord;
|
---|
| 1614 | CHAR ch = *psz;
|
---|
| 1615 | if (ch == '\0')
|
---|
| 1616 | {
|
---|
| 1617 | /* No extra complaining needed when fTakeValue is true, as values must be non-empty strings. */
|
---|
| 1618 | *ppsz = psz;
|
---|
| 1619 | return true;
|
---|
| 1620 | }
|
---|
| 1621 | if (RT_C_IS_SPACE(ch))
|
---|
| 1622 | {
|
---|
| 1623 | if (fTakeValue)
|
---|
| 1624 | do
|
---|
| 1625 | {
|
---|
| 1626 | ch = *++psz;
|
---|
| 1627 | } while (RT_C_IS_SPACE(ch));
|
---|
| 1628 | *ppsz = psz;
|
---|
| 1629 | return true;
|
---|
| 1630 | }
|
---|
| 1631 | if (fTakeValue && (ch == ':' || ch == '='))
|
---|
| 1632 | {
|
---|
| 1633 | *ppsz = psz + 1;
|
---|
| 1634 | return true;
|
---|
| 1635 | }
|
---|
| 1636 | }
|
---|
| 1637 | return false;
|
---|
| 1638 | }
|
---|
| 1639 |
|
---|
| 1640 |
|
---|
| 1641 | static PSZ GetOptValue(PSZ psz, const char *pszOption, char *pszValue, size_t cbValue)
|
---|
| 1642 | {
|
---|
| 1643 | PSZ const pszStart = psz;
|
---|
| 1644 | CHAR ch = *psz;
|
---|
| 1645 | if (ch != '\0' && RT_C_IS_SPACE(ch))
|
---|
| 1646 | {
|
---|
| 1647 | do
|
---|
| 1648 | ch = *++psz;
|
---|
| 1649 | while (ch != '\0' && !RT_C_IS_SPACE(ch));
|
---|
| 1650 |
|
---|
| 1651 | size_t const cchSrc = psz - pszStart;
|
---|
| 1652 | if (cchSrc < cbValue)
|
---|
| 1653 | {
|
---|
| 1654 | memcpy(pszValue, pszStart, cchSrc);
|
---|
| 1655 | pszValue[cchSrc] = '\0';
|
---|
| 1656 | return psz; /* Do not skip space or we won't get out of the inner option loop! */
|
---|
| 1657 | }
|
---|
| 1658 | SyntaxError("Argument value too long", pszOption);
|
---|
| 1659 | }
|
---|
| 1660 | else
|
---|
| 1661 | SyntaxError("Argument value cannot be empty", pszOption);
|
---|
| 1662 | return NULL;
|
---|
| 1663 | }
|
---|
| 1664 |
|
---|
| 1665 |
|
---|
| 1666 | static PSZ GetOptPath(PSZ psz, const char *pszOption, char *pszValue, size_t cbValue, size_t cchScratch, size_t *pcchValue)
|
---|
| 1667 | {
|
---|
| 1668 | psz = GetOptValue(psz, pszOption, pszValue, cbValue - cchScratch);
|
---|
| 1669 | if (psz)
|
---|
| 1670 | {
|
---|
| 1671 | /* Only accept drive letters for now. This could be a UNC path too for CID servers ;-) */
|
---|
| 1672 | if ( !RT_C_IS_ALPHA(pszValue[0])
|
---|
| 1673 | || pszValue[1] != ':'
|
---|
| 1674 | || (pszValue[2] != '\0' && pszValue[2] != '\\' && pszValue[2] != '/'))
|
---|
| 1675 | SyntaxError("The path must be absolute", pszOption);
|
---|
| 1676 |
|
---|
| 1677 | *pcchValue = RTPathEnsureTrailingSeparator(pszValue, cbValue);
|
---|
| 1678 | if (*pcchValue == 0)
|
---|
| 1679 | SyntaxError("RTPathEnsureTrailingSeparator overflowed", pszValue);
|
---|
| 1680 | }
|
---|
| 1681 | return psz;
|
---|
| 1682 | }
|
---|
| 1683 |
|
---|
| 1684 |
|
---|
| 1685 |
|
---|
| 1686 | /**
|
---|
| 1687 | * This is the main entrypoint of the executable (no CRT).
|
---|
| 1688 | *
|
---|
| 1689 | * @note Considered doing a main() wrapper by means of RTGetOptArgvFromString,
|
---|
| 1690 | * but the dependencies are bad and we definitely need a half working heap
|
---|
| 1691 | * for that. Maybe later.
|
---|
| 1692 | */
|
---|
| 1693 | extern "C" int __cdecl VBoxOs2AdditionsInstallMain(HMODULE hmodExe, ULONG ulReserved, PSZ pszzEnv, PSZ pszzCmdLine)
|
---|
| 1694 | {
|
---|
| 1695 | RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
|
---|
| 1696 |
|
---|
| 1697 | /*
|
---|
| 1698 | * Correct defaults.
|
---|
| 1699 | */
|
---|
| 1700 | ULONG ulBootDrv = 0x80;
|
---|
| 1701 | DosQuerySysInfo(QSV_BOOT_DRIVE, QSV_BOOT_DRIVE, &ulBootDrv, sizeof(ulBootDrv));
|
---|
[93144] | 1702 | g_szBootDrivePath[0] = g_szDstPath[0] = 'A' + ulBootDrv - 1;
|
---|
[93128] | 1703 |
|
---|
| 1704 | /*
|
---|
| 1705 | * Parse parameters, skipping the first argv[0] one.
|
---|
| 1706 | */
|
---|
| 1707 | PSZ pszArgs = &pszzCmdLine[strlen(pszzCmdLine) + 1];
|
---|
| 1708 | CHAR ch;
|
---|
| 1709 | while ((ch = *pszArgs++) != '\0')
|
---|
| 1710 | {
|
---|
| 1711 | if (RT_C_IS_SPACE(ch))
|
---|
| 1712 | continue;
|
---|
| 1713 | if (ch != '-')
|
---|
| 1714 | return SyntaxError("Non-option argument", pszArgs - 1);
|
---|
| 1715 | ch = *pszArgs++;
|
---|
| 1716 | if (ch == '-')
|
---|
| 1717 | {
|
---|
| 1718 | if (!pszArgs[0])
|
---|
| 1719 | break;
|
---|
| 1720 | if ( MatchOptWord(&pszArgs, RT_STR_TUPLE("boot"), true)
|
---|
| 1721 | || MatchOptWord(&pszArgs, RT_STR_TUPLE("boot-drive"), true))
|
---|
| 1722 | ch = 'b';
|
---|
| 1723 | else if ( MatchOptWord(&pszArgs, RT_STR_TUPLE("dst"), true)
|
---|
| 1724 | || MatchOptWord(&pszArgs, RT_STR_TUPLE("destination"), true) )
|
---|
| 1725 | ch = 'd';
|
---|
| 1726 | else if ( MatchOptWord(&pszArgs, RT_STR_TUPLE("src"), true)
|
---|
| 1727 | || MatchOptWord(&pszArgs, RT_STR_TUPLE("source"), true))
|
---|
| 1728 | ch = 's';
|
---|
[93145] | 1729 | else if (MatchOptWord(&pszArgs, RT_STR_TUPLE("do-install")))
|
---|
| 1730 | ch = 'i';
|
---|
| 1731 | else if (MatchOptWord(&pszArgs, RT_STR_TUPLE("dry-run")))
|
---|
| 1732 | ch = 'z';
|
---|
[93128] | 1733 | else if (MatchOptWord(&pszArgs, RT_STR_TUPLE("shared-folders")))
|
---|
| 1734 | ch = 'f';
|
---|
| 1735 | else if (MatchOptWord(&pszArgs, RT_STR_TUPLE("no-shared-folders")))
|
---|
| 1736 | ch = 'F';
|
---|
| 1737 | else if (MatchOptWord(&pszArgs, RT_STR_TUPLE("graphics")))
|
---|
| 1738 | ch = 'g';
|
---|
| 1739 | else if (MatchOptWord(&pszArgs, RT_STR_TUPLE("no-graphics")))
|
---|
| 1740 | ch = 'G';
|
---|
| 1741 | else if (MatchOptWord(&pszArgs, RT_STR_TUPLE("mouse")))
|
---|
| 1742 | ch = 'm';
|
---|
| 1743 | else if (MatchOptWord(&pszArgs, RT_STR_TUPLE("no-mouse")))
|
---|
| 1744 | ch = 'M';
|
---|
| 1745 | else if (MatchOptWord(&pszArgs, RT_STR_TUPLE("service")))
|
---|
| 1746 | ch = 's';
|
---|
| 1747 | else if (MatchOptWord(&pszArgs, RT_STR_TUPLE("no-service")))
|
---|
| 1748 | ch = 'S';
|
---|
[93136] | 1749 | else if (MatchOptWord(&pszArgs, RT_STR_TUPLE("startup-cmd")))
|
---|
[93128] | 1750 | ch = 't';
|
---|
[93136] | 1751 | else if (MatchOptWord(&pszArgs, RT_STR_TUPLE("no-startup-cmd")))
|
---|
[93128] | 1752 | ch = 'T';
|
---|
[93136] | 1753 | else if (MatchOptWord(&pszArgs, RT_STR_TUPLE("config-sys")))
|
---|
| 1754 | ch = 'c';
|
---|
| 1755 | else if (MatchOptWord(&pszArgs, RT_STR_TUPLE("no-config-sys")))
|
---|
| 1756 | ch = 'C';
|
---|
[93128] | 1757 | else if (MatchOptWord(&pszArgs, RT_STR_TUPLE("libc-dlls")))
|
---|
| 1758 | ch = 'l';
|
---|
| 1759 | else if (MatchOptWord(&pszArgs, RT_STR_TUPLE("no-libc-dlls")))
|
---|
| 1760 | ch = 'L';
|
---|
[93136] | 1761 | else if (MatchOptWord(&pszArgs, RT_STR_TUPLE("quiet")))
|
---|
| 1762 | ch = 'q';
|
---|
| 1763 | else if (MatchOptWord(&pszArgs, RT_STR_TUPLE("verbose")))
|
---|
| 1764 | ch = 'V';
|
---|
[93128] | 1765 | else if (MatchOptWord(&pszArgs, RT_STR_TUPLE("help")))
|
---|
| 1766 | ch = 'h';
|
---|
| 1767 | else if (MatchOptWord(&pszArgs, RT_STR_TUPLE("version")))
|
---|
| 1768 | ch = 'v';
|
---|
| 1769 | else
|
---|
| 1770 | return SyntaxError("Unknown option", pszArgs - 2);
|
---|
| 1771 | }
|
---|
| 1772 |
|
---|
| 1773 | for (;;)
|
---|
| 1774 | {
|
---|
| 1775 | switch (ch)
|
---|
| 1776 | {
|
---|
| 1777 | case '-':
|
---|
| 1778 | while ((ch = *pszArgs) != '\0' && RT_C_IS_SPACE(ch))
|
---|
| 1779 | pszArgs++;
|
---|
| 1780 | if (ch == '\0')
|
---|
| 1781 | break;
|
---|
| 1782 | return SyntaxError("Non-option argument", pszArgs);
|
---|
| 1783 |
|
---|
| 1784 | case 'b':
|
---|
| 1785 | pszArgs = GetOptPath(pszArgs, "--boot-drive / -b",
|
---|
| 1786 | g_szBootDrivePath, sizeof(g_szBootDrivePath), 64, &g_cchBootDrivePath);
|
---|
| 1787 | if (!pszArgs)
|
---|
| 1788 | return RTEXITCODE_SYNTAX;
|
---|
| 1789 | break;
|
---|
| 1790 |
|
---|
| 1791 | case 'd':
|
---|
| 1792 | pszArgs = GetOptPath(pszArgs, "--destination / -d", g_szDstPath, sizeof(g_szDstPath), 32, &g_cchDstPath);
|
---|
| 1793 | if (!pszArgs)
|
---|
| 1794 | return RTEXITCODE_SYNTAX;
|
---|
| 1795 | break;
|
---|
| 1796 |
|
---|
| 1797 | case 's':
|
---|
| 1798 | pszArgs = GetOptPath(pszArgs, "--source / -s", g_szSrcPath, sizeof(g_szSrcPath), 32, &g_cchSrcPath);
|
---|
| 1799 | if (!pszArgs)
|
---|
| 1800 | return RTEXITCODE_SYNTAX;
|
---|
| 1801 | break;
|
---|
| 1802 |
|
---|
[93145] | 1803 | case 'i':
|
---|
| 1804 | g_fRealRun = true;
|
---|
| 1805 | break;
|
---|
| 1806 |
|
---|
| 1807 | case 'z':
|
---|
| 1808 | g_fRealRun = false;
|
---|
| 1809 | break;
|
---|
| 1810 |
|
---|
[93136] | 1811 | #define SKIP_OPT_CASES(a_chSkip, a_chDontSkip, a_fFlag) \
|
---|
| 1812 | case a_chDontSkip: g_fSkipMask &= ~(a_fFlag); break; \
|
---|
| 1813 | case a_chSkip: g_fSkipMask |= (a_fFlag); break
|
---|
| 1814 | SKIP_OPT_CASES('F', 'f', SKIP_SHARED_FOLDERS);
|
---|
| 1815 | SKIP_OPT_CASES('G', 'g', SKIP_GRAPHICS);
|
---|
| 1816 | SKIP_OPT_CASES('M', 'm', SKIP_MOUSE);
|
---|
| 1817 | SKIP_OPT_CASES('E', 'e', SKIP_SERVICE);
|
---|
| 1818 | SKIP_OPT_CASES('U', 'u', SKIP_STARTUP_CMD);
|
---|
| 1819 | SKIP_OPT_CASES('C', 'c', SKIP_CONFIG_SYS);
|
---|
| 1820 | SKIP_OPT_CASES('L', 'l', SKIP_LIBC_DLLS);
|
---|
| 1821 | #undef SKIP_OPT_CASES
|
---|
[93128] | 1822 |
|
---|
[93136] | 1823 | case 'q':
|
---|
| 1824 | g_fVerbose = false;
|
---|
[93128] | 1825 | break;
|
---|
| 1826 |
|
---|
[93136] | 1827 | case 'V':
|
---|
| 1828 | g_fVerbose = true;
|
---|
[93128] | 1829 | break;
|
---|
| 1830 |
|
---|
| 1831 | case 'h':
|
---|
| 1832 | case '?':
|
---|
| 1833 | return ShowUsage();
|
---|
| 1834 | case 'v':
|
---|
| 1835 | return ShowVersion();
|
---|
| 1836 |
|
---|
| 1837 | default:
|
---|
| 1838 | return SyntaxError("Unknown option", pszArgs - 2);
|
---|
| 1839 | }
|
---|
| 1840 |
|
---|
| 1841 | ch = *pszArgs;
|
---|
| 1842 | if (RT_C_IS_SPACE(ch) || ch == '\0')
|
---|
| 1843 | break;
|
---|
| 1844 | pszArgs++;
|
---|
| 1845 | }
|
---|
| 1846 | }
|
---|
| 1847 |
|
---|
| 1848 | if (g_szSrcPath[0] == '\0')
|
---|
| 1849 | {
|
---|
| 1850 | APIRET rc = DosQueryModuleName(hmodExe, sizeof(g_szSrcPath), g_szSrcPath);
|
---|
| 1851 | if (rc != NO_ERROR)
|
---|
| 1852 | return ApiError("DosQueryModuleName", rc);
|
---|
| 1853 | RTPathStripFilename(g_szSrcPath);
|
---|
| 1854 | g_cchSrcPath = RTPathEnsureTrailingSeparator(g_szSrcPath, sizeof(g_szSrcPath));
|
---|
[93144] | 1855 | if (g_cchSrcPath == 0)
|
---|
[93128] | 1856 | return ApiError("RTPathEnsureTrailingSeparator", ERROR_BUFFER_OVERFLOW);
|
---|
| 1857 | }
|
---|
| 1858 |
|
---|
| 1859 | /*
|
---|
| 1860 | * Do the installation.
|
---|
| 1861 | */
|
---|
| 1862 | rcExit = CheckForGradd();
|
---|
| 1863 | if (rcExit == RTEXITCODE_SUCCESS)
|
---|
| 1864 | rcExit = PrepareConfigSys();
|
---|
| 1865 | if (rcExit == RTEXITCODE_SUCCESS)
|
---|
| 1866 | rcExit = PrepareStartupCmd();
|
---|
| 1867 | if (rcExit == RTEXITCODE_SUCCESS)
|
---|
| 1868 | rcExit = CopyFiles();
|
---|
[93145] | 1869 | if (g_fRealRun)
|
---|
| 1870 | {
|
---|
| 1871 | if (rcExit == RTEXITCODE_SUCCESS)
|
---|
| 1872 | rcExit = WriteConfigSys();
|
---|
| 1873 | if (rcExit == RTEXITCODE_SUCCESS)
|
---|
| 1874 | rcExit = WriteStartupCmd();
|
---|
[93128] | 1875 |
|
---|
[93145] | 1876 | /*
|
---|
| 1877 | * Status summary.
|
---|
| 1878 | */
|
---|
| 1879 | if (rcExit == RTEXITCODE_SUCCESS)
|
---|
| 1880 | WriteStrings(g_hStdOut, "info: Installation successful\r\n", NULL);
|
---|
| 1881 | else
|
---|
| 1882 | WriteStrings(g_hStdErr, "info: Installation failed!\r\n", NULL);
|
---|
| 1883 | }
|
---|
| 1884 | else if (rcExit == RTEXITCODE_SUCCESS)
|
---|
| 1885 | WriteStrings(g_hStdOut, "info: Trial run successful\r\n", NULL);
|
---|
| 1886 | else
|
---|
| 1887 | WriteStrings(g_hStdErr, "info: Trial run failed!\r\n", NULL);
|
---|
[93128] | 1888 | return rcExit;
|
---|
| 1889 | }
|
---|
| 1890 |
|
---|
| 1891 |
|
---|
| 1892 | #if 0 /* Better off with the assembly file here. */
|
---|
| 1893 | /*
|
---|
| 1894 | * Define the stack.
|
---|
| 1895 | *
|
---|
| 1896 | * This \#pragma data_seg(STACK,STACK) thing seems to work a little better for
|
---|
| 1897 | * 32-bit OS2 binaries than 16-bit. Wlink still thinks it needs to allocate
|
---|
| 1898 | * zero bytes in the file for the abStack variable, but it doesn't looks like
|
---|
| 1899 | * both the starting ESP and stack size fields in the LX header are correct.
|
---|
| 1900 | *
|
---|
| 1901 | * The problem seems to be that wlink will write anything backed by
|
---|
| 1902 | * LEDATA32/LIDATA32 even it's all zeros. The C compiler emits either of those
|
---|
| 1903 | * here, and boom the whole BSS is written to the file.
|
---|
| 1904 | *
|
---|
| 1905 | * For 16-bit (see os2_util.c) it would find the stack, but either put the
|
---|
| 1906 | * correct obj:SP or stack size fields in the NE header, never both and the
|
---|
| 1907 | * resulting EXE would either not start or crash immediately.
|
---|
| 1908 | */
|
---|
| 1909 | #pragma data_seg("STACK", "STACK")
|
---|
| 1910 | static uint64_t abStack[4096];
|
---|
| 1911 | #endif
|
---|
| 1912 |
|
---|