{

TokenReplacement(std::string_view longOption, std::string_view shortOption) : LongOption(longOption), ShortOption({ shortOption }) {}

TokenReplacement(std::string_view longOption, std::vector<std::string_view>&& shortOption) : LongOption(longOption), ShortOption(std::move(shortOption)) {}

std::string_view LongOption;

std::vector<std::string_view> ShortOption;

{

THROW_HR_IF(APPINSTALLER_CLI_ERROR_INTERNAL_ERROR, token.empty());

return token[0] == '-' || token[0] == '/';

{

if (Utility::IsEmptyOrWhitespace(logFile))

{

AICLI_LOG(Core, Error, << "MSI log file path cannot be empty");

THROW_HR(APPINSTALLER_CLI_ERROR_INVALID_MSIEXEC_ARGUMENT);

}

INSTALLLOGMODE logMode = {};

INSTALLLOGATTRIBUTES logAttributes = {};

// Note: These flags are mostly consecutive bits in the order given, except where indicated.

// Skipped flags are not mapped to a command line option.

std::map<char, INSTALLLOGMODE> ValidLogModes

{

{ 'm', INSTALLLOGMODE_FATALEXIT },

{ 'e', INSTALLLOGMODE_ERROR },

{ 'w', INSTALLLOGMODE_WARNING },

{ 'u', INSTALLLOGMODE_USER },

{ 'i', INSTALLLOGMODE_INFO },

// FILESINUSE

// RESOLVESOURCE

{ 'o', INSTALLLOGMODE_OUTOFDISKSPACE },

{ 'a', INSTALLLOGMODE_ACTIONSTART },

{ 'r', INSTALLLOGMODE_ACTIONDATA },

{ 'p', INSTALLLOGMODE_PROPERTYDUMP },

{ 'c', INSTALLLOGMODE_COMMONDATA },

{ 'v', INSTALLLOGMODE_VERBOSE },

{ 'x', INSTALLLOGMODE_EXTRADEBUG },

// LOGONLYONERROR

// LOGPERFORMANCE

};

std::map<char, INSTALLLOGATTRIBUTES> ValidLogAttributes

{

{ '+', INSTALLLOGATTRIBUTES_APPEND },

{ '!', INSTALLLOGATTRIBUTES_FLUSHEACHLINE },

};

bool isLogModeSet = false;

for (char c : logModeString)

{

// Log-all option

if (c == '*')

{

logMode |= AllLogMode;

isLogModeSet = true;

continue;

}

auto modeItr = ValidLogModes.find(c);

if (modeItr != ValidLogModes.end())

{

logMode |= modeItr->second;

isLogModeSet = true;

continue;

}

auto attributeItr = ValidLogAttributes.find(c);

if (attributeItr != ValidLogAttributes.end())

{

logAttributes |= attributeItr->second;

continue;

}

AICLI_LOG(Core, Error, << "Unknown msiexec log modifier: " << c);

THROW_HR(APPINSTALLER_CLI_ERROR_INVALID_MSIEXEC_ARGUMENT);

}

if (!isLogModeSet)

{

logMode = DefaultLogMode;

}

parsedArgs.LogMode = logMode;

parsedArgs.LogAttributes = logAttributes;

parsedArgs.LogFile = Utility::ConvertToUTF16(logFile);

{

if (modifier.empty())

{

// /q is treated as equivalent to /qn

modifier = "n"sv;

}

// Lower values in INSTALLUILEVEL work like a base enum (e.g. None=2, Basic=3)

// with higher values being modifying flags (e.g. HideCancel=0x20, ProgressOnly=0x40).

// Some steps depend on the base enum, so we keep it separate for easier checking.

INSTALLUILEVEL uiLevelBase = {};

INSTALLUILEVEL uiLevelModifiers = {};

// Parse the base level

switch (std::tolower(modifier[0]))

{

case 'f':

uiLevelBase = INSTALLUILEVEL_FULL;

break;

case 'r':

uiLevelBase = INSTALLUILEVEL_REDUCED;

break;

case 'b':

uiLevelBase = INSTALLUILEVEL_BASIC;

break;

case '+':

uiLevelBase = INSTALLUILEVEL_NONE;

uiLevelModifiers = INSTALLUILEVEL_ENDDIALOG;

break;

case 'n':

uiLevelBase = INSTALLUILEVEL_NONE;

break;

default:

AICLI_LOG(Core, Error, << "Invalid modifier for msiexec /q argument: " << modifier);

THROW_HR(APPINSTALLER_CLI_ERROR_INVALID_MSIEXEC_ARGUMENT);

};

// Parse the modifiers

for (size_t i = 1; i < modifier.size(); ++i)

{

const char c = modifier[i];

if (c == '+')

{

WI_SetFlag(uiLevelModifiers, INSTALLUILEVEL_ENDDIALOG);

}

else if (c == '-')

{

if (uiLevelBase == INSTALLUILEVEL_BASIC)

{

WI_SetFlag(uiLevelModifiers, INSTALLUILEVEL_PROGRESSONLY);

}

else

{

AICLI_LOG(Core, Error, << "msiexec UI option Progress Only (-) is only valid with UI level Basic (b)");

THROW_HR(APPINSTALLER_CLI_ERROR_INVALID_MSIEXEC_ARGUMENT);

}

}

else if (c == '!')

{

if (uiLevelBase == INSTALLUILEVEL_BASIC)

{

WI_SetFlag(uiLevelModifiers, INSTALLUILEVEL_HIDECANCEL);

}

else

{

AICLI_LOG(Core, Error, << "msiexec UI option Hide Cancel (!) is only valid with UI level Basic (b)");

THROW_HR(APPINSTALLER_CLI_ERROR_INVALID_MSIEXEC_ARGUMENT);

}

}

}

// Only deviation from msiexec:

// When using UI Level None, allow showing the UAC prompt.

WI_SetFlagIf(uiLevelModifiers, INSTALLUILEVEL_UACONLY, uiLevelBase == INSTALLUILEVEL_NONE);

parsedArgs.UILevel = uiLevelBase | uiLevelModifiers;

{

// Eat leading whitespace

while (start < arguments.size() && IsWhiteSpace(arguments[start]))

{

++start;

}

if (start >= arguments.size())

{

// We reached the end

return {};

}

size_t pos = start;

bool seekingSpaceSeparator = ('"' != arguments[pos]);

bool withinQuotes = false;

// Start looking from the next character

++pos;

// Advance until we hit the end or the next separator

while (pos < arguments.size())

{

bool isSpace = IsWhiteSpace(arguments[pos]);

bool isQuote = ('"' == arguments[pos]);

if (isSpace || isQuote)

{

// We've encountered one of the two separators we're interested in

if (seekingSpaceSeparator)

{

if (isQuote)

{

// We will ignore space characters enclosed between double quotes

withinQuotes = !withinQuotes;

}

else

{

// This is a space character. If it is between quotes we ignore it;

// otherwise it is a separator.

if (!withinQuotes)

{

break;

}

}

}

else

{

if (isQuote)

{

// we've got what we needed, it is OK to stop

break;

}

}

}

++pos;

}

if (!seekingSpaceSeparator)

{

// We were looking for a terminating " character.

if (pos < arguments.size())

{

// We move past the " character (it is OK for the end of the line

// to act as the matching " character in some cases)

++pos;

}

}

auto result = arguments.substr(start, pos - start);

start = pos;

return result;

{

size_t start = 0;

std::list<std::string> result;

auto token = GetNextToken(arguments, start);

while (!token.empty())

{

result.emplace_back(token);

token = GetNextToken(arguments, start);

}

return result;

{

if (valueToken.empty() || valueToken[0] != '"')

{

// Nothing to do for empty or unquoted tokens

return std::string{ valueToken };

}

// Copy the string ignoring the quotes and replacing escaped characters.

// In quoted tokens, the back quote represents double quotes (` means ")

// and can be escaped with back slash (\` means `).

// Note that we accept quoted values with a missing closing quote (the end

// of string signals the end).

std::string result;

for (size_t i = 1; i < valueToken.size(); ++i)

{

if (valueToken[i] == '"')

{

// The tokenizer can leave several pairs of quotes in the token

// but they are not accepted in this case. We only accept the final

// closing quotes.

if (i + 1 == valueToken.size())

{

break;

}

else

{

AICLI_LOG(Core, Error, << "Invalid msiexec argument: " << valueToken);

THROW_HR(APPINSTALLER_CLI_ERROR_INVALID_MSIEXEC_ARGUMENT);

}

}

if (i + 1 < valueToken.size() && valueToken[i] == '\\' && valueToken[i + 1] == '`')

{

result += '`';

++i;

}

else if (valueToken[i] == '`')

{

result += '"';

}

else

{

result += valueToken[i];

}

}

return result;

{

THROW_HR_IF(APPINSTALLER_CLI_ERROR_INTERNAL_ERROR, token.empty());

if (token[0] != '%' && !IsCharAlphaNumericA(token[0]))

{

AICLI_LOG(Core, Error, << "Bad property for msiexec: " << token);

return false;

}

// Find the = separator at the end of the property name

size_t pos = 0;

while (pos < token.size() && !IsWhiteSpace(token[pos]) && token[pos] != '=')

{

++pos;

}

if (pos == token.size() || token[pos] != '=')

{

AICLI_LOG(Core, Error, << "Expected property for call to msiexec, but couldn't find separator: " << token);

return false;

}

// Validate the property value.

// It should be completely enclosed in quotes, or not contain white space.

// If quoted, there can be pairs of consecutive quotes that work as escape sequences.

// We accept empty property values.

++pos;

if (pos == token.size())

{

// Empty value

return true;

}

// If quoted, we will only inspect the values between the quotes.

bool quoted = false;

size_t end = token.size();

if (token[pos] == '"')

{

++pos;

if (pos >= end || token.back() != '"')

{

AICLI_LOG(Core, Error, << "Badly quoted msiexec property: " << token);

THROW_HR(APPINSTALLER_CLI_ERROR_INVALID_MSIEXEC_ARGUMENT);

}

--end;

quoted = true;

}

while (pos < end)

{

if (quoted)

{

// For quoted values, any internal quote must be followed by another one.

if (token[pos] == '"')

{

if (pos + 1 < end && token[pos + 1] == '"')

{

// Skip the two quotes

++pos;

}

else

{

AICLI_LOG(Core, Error, << "Unexpected quotes in msiexec property arg: " << token);

THROW_HR(APPINSTALLER_CLI_ERROR_INVALID_MSIEXEC_ARGUMENT);

}

}

}

else

{

// For unquoted values, we only check that there is no whitespace

if (IsWhiteSpace(token[pos]))

{

AICLI_LOG(Core, Error, << "Unexpected space in msiexec property arg: " << token);

THROW_HR(APPINSTALLER_CLI_ERROR_INVALID_MSIEXEC_ARGUMENT);

}

}

++pos;

}

return true;

{

// We don't handle all possible options because we don't need to.

// Options not handled:

// /update

// /uninstall

// /package

// /help

const std::vector<TokenReplacement> Replacements

{

{ "quiet"sv, "/qn"sv },

{ "passive"sv, { "/qb!-"sv, "REBOOTPROMPT=S"sv } },

{ "norestart"sv, "REBOOT=ReallySuppress"sv },

{ "forcerestart"sv, "REBOOT=Force"sv },

{ "promptrestart"sv, "REBOOTPROMPT=\"\""sv },

{ "log"sv, "/l*"sv },

};

auto itr = tokens.begin();

while (itr != tokens.end())

{

if (!IsSwitch(*itr))

{

// We only need to replace switches.

++itr;

continue;

}

// Find if there is a replacement for this option.

// We ignore the leading / or - when comparing.

auto option = std::string_view(*itr).substr(1);

auto replacementItr = std::find_if(Replacements.begin(), Replacements.end(), [&](const TokenReplacement& replacement) { return Utility::CaseInsensitiveEquals(replacement.LongOption, option); });

if (replacementItr == Replacements.end())

{

// There is no replacement for this switch;

++itr;

continue;

}

// Add all the replacements tokens needed before this one, then delete the existing token.

tokens.insert(itr, replacementItr->ShortOption.begin(), replacementItr->ShortOption.end());

// Delete the current token an move to the next one.

// We don't need to do anything more to the newly added tokens.

itr = tokens.erase(itr);

}

{

THROW_HR_IF(APPINSTALLER_CLI_ERROR_INTERNAL_ERROR, tokens.empty());

auto token = std::move(tokens.front());

tokens.pop_front();

if (!IsSwitch(token))

{

// Token is a property, i.e. NAME=value. Add it to the parsed args.

THROW_HR_IF(APPINSTALLER_CLI_ERROR_INVALID_MSIEXEC_ARGUMENT, !IsValidPropertyToken(token));

parsedArgs.Properties += L" " + Utility::ConvertToUTF16(token);

return;

}

// Token is an option.

if (token.size() <= 1)

{

AICLI_LOG(Core, Error, << "Invalid command line argument for msiexec: " << token);

THROW_HR(APPINSTALLER_CLI_ERROR_INVALID_MSIEXEC_ARGUMENT);

}

char option = token[1];

auto optionModifier = ParseValue(std::string_view(token).substr(2));

// Options are case-insensitive

switch (std::tolower(option))

{

case MsiExecQuietOption:

{

ParseQuietOption(optionModifier, parsedArgs);

break;

}

case MsiExecLogOption:

{

if (tokens.empty())

{

// Log option must be followed by an option argument

AICLI_LOG(Core, Error, << "msiexec option " << token << " must be followed by a value");

THROW_HR(APPINSTALLER_CLI_ERROR_INVALID_MSIEXEC_ARGUMENT);

}

const auto optionValue = ParseValue(tokens.front());

tokens.pop_front();

ParseLogOption(optionModifier, optionValue, parsedArgs);

break;

}

default:

{

AICLI_LOG(Core, Error, << "Invalid option for msiexec: " << token);

THROW_HR(APPINSTALLER_CLI_ERROR_INVALID_MSIEXEC_ARGUMENT);

}

}

{

// Split the arguments into tokens, which we will process one by one.

auto argumentTokens = TokenizeMsiArguments(arguments);

// Replace long options so we can work only with short ones.

ReplaceLongOptions(argumentTokens);

// Process the arguments.

MsiParsedArguments result;

while (!argumentTokens.empty())

{

ConsumeNextToken(argumentTokens, result);

}

return result;