public static bool UpdateVersionWindows(string path, Version version)
{
var args = string.Format(
"- '{0}' {1} {2} {3} {4}",
path, version.major, version.minor, version.patch, version.build
);
string output, error;
var exitcode = OptionHelper.RunScript("python", args, PythonUpdateWindows, out output, out error);
if (exitcode != 0)
{
Debug.LogError("OptionVersion: Failed to run python to update version: " + output);
return(false);
}
return(true);
}
override public void SetPassword(string service, string name, string password)
{
// We use the interactive mode of security here that allows us to
// pipe the command to stdin and thus avoid having the password
// exposed in the process table.
var command = string.Format(
"add-generic-password -U -a '{0}' -s '{1}' -w '{2}'\n",
name, service, password
);
string output, error;
var code = OptionHelper.RunScript("security", "-i", command, out output, out error);
if (code != 0)
{
Debug.LogError("Failed to store password in Keychain: " + error);
}
}
override public string GetPassword(string service, string name)
{
var command = string.Format(
"find-generic-password -a '{0}' -s '{1}' -w",
name, service
);
string output, error;
var code = OptionHelper.RunScript("security", command, out output, out error);
if (code != 0)
{
return(null);
}
else
{
return(output.TrimEnd('\n'));
}
}
/// <summary>
/// Get aliases defined in a keystore using `keytool`.
/// </summary>
Error GetKeyAliases(string path, string password, List <string> aliases)
{
var result = FindKeytool();
if (result != Error.None)
{
return(result);
}
var arguments = string.Format(
"-list -v -keystore '{0}'",
path
);
string output, error;
var code = OptionHelper.RunScript(keytoolPath, arguments, password, out output, out error);
if (code != 0)
{
if (output.Contains("password was incorrect"))
{
return(Error.InvalidKeystorePassword);
}
else
{
return(Error.KeytoolFailed);
}
}
aliases.Clear();
var lines = output.Split(Newlines, StringSplitOptions.None);
foreach (var line in lines)
{
if (line.StartsWith("Alias name: "))
{
aliases.Add(line.Substring(12));
}
}
return(Error.None);
}
/// <summary>
/// Check the alias password.
/// </summary>
/// <remarks>
/// There isn't really a nice way to check the key password from the command line,
/// so we have to abuse `keytool` a bit.
///
/// The main issue is that the tools will try the store password on the key and
/// therefore if the two match, the key password will never be checked. Unity, on
/// the other hand, will not try the store password on the key and requires the
/// proper key password to be set.
///
/// We use the `-keypaswd` command of keytool, which usually changes a key's password,
/// but we don't supply it with a new password and only use it to check its error
/// output. In case the store password is wrong 'password was incorrect' will be
/// printed. In case the key password is wrong 'Cannot recover key' will be printed.
/// In case both store and key passwords match, we check if the keytool prompted
/// for the key password (if not, the passwords must match) and check if they match
/// ourself.
/// </remarks>
Error CheckAliasPassword(string keystore, string alias, string keystorePass, string aliasPass)
{
var result = FindKeytool();
if (result != Error.None)
{
return(result);
}
var arguments = string.Format(
"-keypasswd -keystore '{0}' -alias '{1}'",
keystore, alias
);
var input = keystorePass + "\n" + aliasPass;
string output, error;
OptionHelper.RunScript(keytoolPath, arguments, input, out output, out error);
if (output.Contains("password was incorrect"))
{
return(Error.InvalidKeystorePassword);
}
if (output.Contains("Cannot recover key"))
{
return(Error.InvalidAliasPassword);
}
// keytool first tries the store password on the key, so if they
// match, the key password is never actually checked.
// In this case we didn't get a key password prompt. Therefore
// make sure keystore and alias passwords match.
if (!error.Contains("Enter key password") && keystorePass != aliasPass)
{
return(Error.InvalidAliasPassword);
}
return(Error.None);
}
Version DetermineProjectVersion(BuildTarget target)
{
// Get version string from either the override or PlayerSettings.bundleVersion
string versionString;
var overrideVersion = GetChild <OptionOverrideVersion>().Value;
if (!string.IsNullOrEmpty(overrideVersion))
{
versionString = overrideVersion;
}
else
{
versionString = PlayerSettings.bundleVersion;
if (string.IsNullOrEmpty(versionString))
{
Debug.LogError("OptionVersion: Please configure the version in the player settings.");
return(default(Version));
}
}
// -- Parse version
string error;
var version = Version.Parse(versionString, out error);
if (error != null)
{
Debug.LogError(error);
return(default(Version));
}
if (!version.IsDefined)
{
Debug.LogWarning("OptionVersion: No valid version defined (" + version.MajorMinorPatch + ")");
}
// -- Parse build
var sharing = GetChild <OptionShareBuildNumber>().Value;
var overrideBuild = GetChild <OptionOverrideBuild>().Value;
if (overrideBuild >= 0)
{
// Build number has been overridden
version.build = overrideBuild;
}
else if (sharing != BuildNumberSharing.None)
{
// Look for highest build number across build target groups, increment it
// and then apply it back to all groups
if (!LoadBuildNumberMethods())
{
Debug.LogError("OptionVersion: Could not find internal GetBuildNumber method on PlayerSettings.");
return(default(Version));
}
var buildNumbers = new List <int>();
foreach (var targetGroup in GetSharedTargets(sharing))
{
var numberString = GetBuildNumber(targetGroup);
int number;
if (!int.TryParse(numberString, out number) || number < 0)
{
Debug.LogError("OptionVersion: " + targetGroup + " build number should be a positive integer (" + numberString + ")");
}
else
{
buildNumbers.Add(number);
}
}
var android = PlayerSettings.Android.bundleVersionCode;
if (android < 0)
{
Debug.LogError("OptionVersion: Android bundle version code should be a positive integer.");
}
else
{
buildNumbers.Add(android);
}
// Use the highest defined build number
version.build = buildNumbers.Max();
}
else
{
// Only increment the number for the current build target group
var targetGroup = BuildPipeline.GetBuildTargetGroup(target);
if (targetGroup == BuildTargetGroup.Android)
{
version.build = PlayerSettings.Android.bundleVersionCode;
}
else
{
if (!LoadBuildNumberMethods())
{
Debug.LogError("OptionVersion: Could not find internal GetBuildNumber method on PlayerSettings.");
return(default(Version));
}
var numberString = GetBuildNumber(targetGroup);
var number = 0;
if (!int.TryParse(numberString, out number) || number < 0)
{
Debug.LogError("OptionVersion: " + targetGroup + " build number should be a positive integer (" + numberString + ")");
}
version.build = number;
}
}
// -- Version Control
if (GetChild <OptionVersionControl>().Value)
{
// -- Git
if (System.IO.Directory.Exists(".git"))
{
OptionHelper.RunScript("git", "rev-parse --verify HEAD", out version.commit);
if (version.commit != null)
{
version.commit = version.commit.Trim();
if (version.commit.Length == 0)
{
version.commit = null;
}
}
OptionHelper.RunScript("git", "rev-parse --abbrev-ref --verify HEAD", out version.branch);
if (version.branch != null)
{
version.branch = version.branch.Trim();
if (version.branch.Length == 0)
{
version.branch = null;
}
}
}
}
return(version);
}