BOOL VersionInRange(LARGE_INTEGER lVersion, LPCTSTR lpszLowerVersion, LPCTSTR lpszUpperVersion )
{
BOOL bResult = FALSE;
if( _tcslen(lpszLowerVersion)>0
&& !(CompareVersion(lVersion, ParseVersion(lpszLowerVersion), _T(">="), bResult ) && bResult) )
return FALSE;
if( _tcslen(lpszUpperVersion)>0
&& !(CompareVersion( lVersion, ParseVersion(lpszUpperVersion), _T("<"), bResult ) && bResult) )
return FALSE;
return TRUE;
}
void Updater::infoFinished()
{
QNetworkReply *reply = ( QNetworkReply * )sender();
if ( !reply->error() )
{
infoFile.write( reply->readAll() );
infoFile.close();
QSettings info( infoFile.fileName(), QSettings::IniFormat, this );
QString ThisVersion = QMPlay2Core.getSettings().getString( "Version" );
QString NewVersion = info.value( "Version" ).toString();
QDate NewVersionDate = ParseVersion( NewVersion );
if ( NewVersionDate.isValid() )
{
if ( NewVersionDate > ParseVersion( ThisVersion ) )
{
QString FileURL;
#if defined Q_OS_WIN && defined QMPLAY2_CPU_X86
if ( sizeof( void * ) == 8 )
FileURL = info.value( "Win64" ).toString();
if ( FileURL.isEmpty() ) //32bit or 64bit does not exists on server
FileURL = info.value( "Win32" ).toString();
#elif defined Q_OS_LINUX && defined QMPLAY2_CPU_X86
if ( sizeof( void * ) == 8 )
FileURL = info.value( "Linux64" ).toString();
if ( FileURL.isEmpty() ) //32bit or 64bit does not exists on server
FileURL = info.value( "Linux32" ).toString();
#endif
if ( FileURL.isEmpty() )
endWork( tr( "Brak dostępnej aktualizacji" ) );
else if ( updateFile.open( QFile::WriteOnly | QFile::Truncate ) )
getFile( QUrl( FileURL.replace( "$Version", NewVersion ) ) );
else
endWork( tr( "Błąd zapisu aktualizacji" ) );
}
else
endWork( tr( "Program jest aktualny" ) );
}
else
endWork( tr( "Błąd sprawdzania aktualizacji" ) );
}
else
endWork( tr( "Błąd sprawdzania aktualizacji" ) );
infoFile.remove();
reply->deleteLater();
}
void
nsHttpResponseHead::ParseStatusLine(const char *line)
{
//
// Parse Status-Line:: HTTP-Version SP Status-Code SP Reason-Phrase CRLF
//
// HTTP-Version
ParseVersion(line);
if ((mVersion == NS_HTTP_VERSION_0_9) || !(line = PL_strchr(line, ' '))) {
mStatus = 200;
AssignDefaultStatusText();
}
else {
// Status-Code
mStatus = (uint16_t) atoi(++line);
if (mStatus == 0) {
LOG(("mal-formed response status; assuming status = 200\n"));
mStatus = 200;
}
// Reason-Phrase is whatever is remaining of the line
if (!(line = PL_strchr(line, ' '))) {
AssignDefaultStatusText();
}
else
mStatusText = nsDependentCString(++line);
}
LOG(("Have status line [version=%u status=%u statusText=%s]\n",
unsigned(mVersion), unsigned(mStatus), mStatusText.get()));
}
void
nsHttpResponseHead::ParseStatusLine(const char *line)
{
//
// Parse Status-Line:: HTTP-Version SP Status-Code SP Reason-Phrase CRLF
//
// HTTP-Version
ParseVersion(line);
if ((mVersion == NS_HTTP_VERSION_0_9) || !(line = PL_strchr(line, ' '))) {
mStatus = 200;
mStatusText.AssignLiteral("OK");
}
else {
// Status-Code
mStatus = (PRUint16) atoi(++line);
if (mStatus == 0) {
LOG(("mal-formed response status; assuming status = 200\n"));
mStatus = 200;
}
// Reason-Phrase is whatever is remaining of the line
if (!(line = PL_strchr(line, ' '))) {
LOG(("mal-formed response status line; assuming statusText = 'OK'\n"));
mStatusText.AssignLiteral("OK");
}
else
mStatusText = ++line;
}
LOG(("Have status line [version=%u status=%u statusText=%s]\n",
PRUintn(mVersion), PRUintn(mStatus), mStatusText.get()));
}
BOOL CompareString( LPCTSTR lpLeft, LPCTSTR lpRight, LPCTSTR sOpt, BOOL& bResult )
{
INT nRet = 0;
if(IsVersionString(lpLeft) && IsVersionString(lpRight))
{
LARGE_INTEGER llLeft, llRight;
llLeft = ParseVersion(lpLeft);
llRight = ParseVersion(lpRight);
nRet = CompareLargeInts(llLeft, llRight);
}
else
{
nRet = _tcsicmp(lpLeft, lpRight);
}
return EvalCompareResult(nRet, sOpt, bResult);
}
int KDownloadUpdatePackage::DownloadPacks(
IDownloaderNotification* pNotify,
const TCHAR cpszRemotePath[],
const TCHAR cpszUpdatePath[],
const TCHAR cpszClientVersion[],
const TCHAR cpszCurrentVersion[]
)
{
int nRetCode = false;
int nResult = false;
int nStrLen = false;
KGLOG_PROCESS_ERROR(pNotify);
KGLOG_PROCESS_ERROR(cpszRemotePath);
KGLOG_PROCESS_ERROR(cpszUpdatePath);
KGLOG_PROCESS_ERROR(cpszClientVersion);
KGLOG_PROCESS_ERROR(cpszCurrentVersion);
m_pNotify = pNotify;
nStrLen = (int)_tcslen(cpszRemotePath);
_tcsncpy(m_szRemotePath, cpszRemotePath, nStrLen + 1);
m_szRemotePath[nStrLen] = _T('\0');
nStrLen = (int)_tcslen(cpszUpdatePath);
_tcsncpy(m_szUpdatePath, cpszUpdatePath, nStrLen + 1);
m_szUpdatePath[nStrLen] = _T('\0');
nStrLen = (int)_tcslen(cpszClientVersion);
_tcsncpy(m_szClientLang, cpszClientVersion, nStrLen + 1);
m_szClientLang[nStrLen] = _T('\0');
nStrLen = (int)_tcslen(cpszCurrentVersion);
_tcsncpy(m_szCurrentVersion, cpszCurrentVersion, nStrLen + 1);
m_szCurrentVersion[nStrLen] = _T('\0');
if (!m_nDownloadVersionFlag)
{
nRetCode = DownLoadVersion();
KGLOG_PROCESS_ERROR(nRetCode);
}
nRetCode = ParseVersion();
KGLOG_PROCESS_ERROR(nRetCode);
nRetCode = DownloadUpdatePackage();
KGLOG_PROCESS_ERROR(nRetCode);
nResult = true;
Exit0:
return nResult;
}
bool HttpRequest::ParseStartLine(const StringPiece& data, HttpMessage::ErrorCode* error) {
ErrorCode error_placeholder;
if (error == NULL)
error = &error_placeholder;
static const size_t kMinHttpMethodLength = 3;
size_t pos = data.find(' ', kMinHttpMethodLength);
if (pos == StringPiece::npos) {
*error = ERROR_START_LINE_NOT_COMPLETE;
return false;
}
StringPiece method = data.substr(0, pos);
StringTrim(&method);
m_method = GetMethodByName(method);
if (m_method == METHOD_UNKNOWN) {
*error = ERROR_METHOD_NOT_FOUND;
return false;
}
size_t prev_pos = pos + 1;
pos = data.find(' ', prev_pos);
StringPiece uri;
if (pos == StringPiece::npos) {
uri = data.substr(prev_pos);
} else {
uri = data.substr(prev_pos, pos - prev_pos);
}
StringTrim(&uri);
uri.copy_to_string(&m_uri);
if (pos != StringPiece::npos) {
StringPiece version = data.substr(pos);
StringTrim(&version);
if (!ParseVersion(version)) {
*error = ERROR_VERSION_UNSUPPORTED;
return false;
}
}
return true;
}
Update_Status UpdateChecker::IsUpdateAvailable(const Version& currentVersion)
{
Update_Status updateAvailable = UPDATER_LATEST_STABLE;
try {
CInternetSession internet;
OSVERSIONINFOEX osVersion = SysVersion::GetFullVersion();
CString osVersionStr;
osVersionStr.Format(_T("Windows %1u.%1u"), osVersion.dwMajorVersion, osVersion.dwMinorVersion);
if (SysVersion::Is64Bit()) {
osVersionStr += _T(" x64");
}
CString headersFmt = _T("User-Agent: MPC-HC");
if (VersionInfo::Is64Bit()) {
headersFmt += _T(" (64-bit)");
}
#ifdef MPCHC_LITE
headersFmt += _T(" Lite");
#endif
headersFmt += _T(" (%s)/");
headersFmt += VersionInfo::GetFullVersionString();
headersFmt += _T("\r\n");
CString headers;
headers.Format(headersFmt, osVersionStr);
CHttpFile* versionFile = (CHttpFile*) internet.OpenURL(versionFileURL,
1,
INTERNET_FLAG_TRANSFER_ASCII | INTERNET_FLAG_DONT_CACHE | INTERNET_FLAG_RELOAD,
headers,
DWORD(-1));
if (versionFile) {
CString latestVersionStr;
char buffer[101];
UINT br = 0;
while ((br = versionFile->Read(buffer, 50)) > 0) {
buffer[br] = '\0';
latestVersionStr += buffer;
}
if (!ParseVersion(latestVersionStr, latestVersion)) {
updateAvailable = UPDATER_ERROR;
} else {
time_t lastCheck = time(nullptr);
AfxGetApp()->WriteProfileBinary(IDS_R_SETTINGS, IDS_RS_UPDATER_LAST_CHECK, (LPBYTE)&lastCheck, sizeof(time_t));
int comp = CompareVersion(currentVersion, latestVersion);
if (comp < 0) {
CString ignoredVersionStr = AfxGetApp()->GetProfileString(IDS_R_SETTINGS, IDS_RS_UPDATER_IGNORE_VERSION, _T("0.0.0.0"));
Version ignoredVersion;
bool ignored = false;
if (ParseVersion(ignoredVersionStr, ignoredVersion)) {
ignored = (CompareVersion(ignoredVersion, latestVersion) >= 0);
}
updateAvailable = ignored ? UPDATER_UPDATE_AVAILABLE_IGNORED : UPDATER_UPDATE_AVAILABLE;
} else if (comp > 0) {
updateAvailable = UPDATER_NEWER_VERSION;
}
}
versionFile->Close(); // Close() isn't called by the destructor
delete versionFile;
} else {
updateAvailable = UPDATER_ERROR;
}
} catch (CInternetException* pEx) {
updateAvailable = UPDATER_ERROR;
pEx->Delete();
}
return updateAvailable;
}
inline bool IsFirstNewer(const std::string& v1, const std::string& v2, bool check_prerelease)
{
return IsFirstNewer(ParseVersion(v1), ParseVersion(v2), check_prerelease);
}
int main(int argc, char* argv[])
{
if (argc > 1 && (IsArg(argv[1], "h") ||
IsArg(argv[1], "help") ||
IsArg(argv[1], "?")))
{
Usage();
return 0;
}
if (argc == 2 && (IsArg(argv[1], "v") || IsArg(argv[1], "version")))
{
Output(PR_FALSE, "Mozilla XULRunner %s\n", GRE_BUILD_ID);
return 0;
}
if (argc > 1) {
PRBool registerGlobal = IsArg(argv[1], "register-global");
PRBool registerUser = IsArg(argv[1], "register-user");
if (registerGlobal || registerUser) {
if (argc != 2) {
Usage();
return 1;
}
nsCOMPtr<nsIFile> regDir;
nsresult rv = GetXULRunnerDir(argv[0], getter_AddRefs(regDir));
if (NS_FAILED(rv))
return 2;
return RegisterXULRunner(registerGlobal, regDir,
kGREProperties,
NS_ARRAY_LENGTH(kGREProperties)) ? 0 : 2;
}
registerGlobal = IsArg(argv[1], "unregister-global");
registerUser = IsArg(argv[1], "unregister-user");
if (registerGlobal || registerUser) {
if (argc != 2) {
Usage();
return 1;
}
nsCOMPtr<nsIFile> regDir;
nsresult rv = GetXULRunnerDir(argv[0], getter_AddRefs(regDir));
if (NS_FAILED(rv))
return 2;
UnregisterXULRunner(registerGlobal, regDir);
return 0;
}
if (IsArg(argv[1], "find-gre")) {
if (argc != 3) {
Usage();
return 1;
}
char path[MAXPATHLEN];
static const GREVersionRange vr = {
argv[2], PR_TRUE,
argv[2], PR_TRUE
};
static const GREProperty kProperties[] = {
{ "xulrunner", "true" }
};
nsresult rv = GRE_GetGREPathWithProperties(&vr, 1, kProperties,
NS_ARRAY_LENGTH(kProperties),
path, sizeof(path));
if (NS_FAILED(rv))
return 1;
printf("%s\n", path);
return 0;
}
if (IsArg(argv[1], "gre-version")) {
if (argc != 2) {
Usage();
return 1;
}
printf("%s\n", GRE_BUILD_ID);
return 0;
}
if (IsArg(argv[1], "install-app")) {
if (argc < 3 || argc > 5) {
Usage();
return 1;
}
char *appLocation = argv[2];
char *installTo = nsnull;
if (argc > 3) {
installTo = argv[3];
if (!*installTo) // left blank?
installTo = nsnull;
}
char *leafName = nsnull;
if (argc > 4) {
leafName = argv[4];
if (!*leafName)
leafName = nsnull;
}
nsCOMPtr<nsIFile> regDir;
nsresult rv = GetXULRunnerDir(argv[0], getter_AddRefs(regDir));
if (NS_FAILED(rv))
return 2;
return InstallXULApp(regDir, appLocation, installTo, leafName);
}
}
geckoVersion = ParseVersion(GRE_BUILD_ID);
const char *appDataFile = PR_GetEnv("XUL_APP_FILE");
if (!(appDataFile && *appDataFile)) {
if (argc < 2) {
Usage();
return 1;
}
if (IsArg(argv[1], "app")) {
if (argc == 2) {
Usage();
return 1;
}
argv[1] = argv[0];
++argv;
--argc;
}
appDataFile = argv[1];
argv[1] = argv[0];
++argv;
--argc;
static char kAppEnv[MAXPATHLEN];
PR_snprintf(kAppEnv, MAXPATHLEN, "XUL_APP_FILE=%s", appDataFile);
PR_SetEnv(kAppEnv);
}
nsCAutoString vendor, name, version, buildID, appID, copyright;
nsXREAppData appData = { sizeof(nsXREAppData), 0 };
int rv = LoadAppData(appDataFile, &appData,
vendor, name, version, buildID, appID, copyright);
if (!rv)
rv = XRE_main(argc, argv, &appData);
NS_IF_RELEASE(appData.directory);
return rv;
}
static PRBool CheckMaxVersion(const char *versionStr)
{
PRUint32 v = ParseVersion(versionStr);
return geckoVersion <= v;
}
