src/Global.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // MuldeR's Utilities for Qt
   3 // Copyright (C) 2004-2016 LoRd_MuldeR <MuldeR2@GMX.de>
   4 //
   5 // This library is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU Lesser General Public
   7 // License as published by the Free Software Foundation; either
   8 // version 2.1 of the License, or (at your option) any later version.
   9 //
  10 // This library is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 // Lesser General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU Lesser General Public
  16 // License along with this library; if not, write to the Free Software
  17 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  18 //
  19 // http://www.gnu.org/licenses/lgpl-2.1.txt
  20 //////////////////////////////////////////////////////////////////////////////////
  21
  22 #if _MSC_VER
  23 #define _CRT_RAND_S 1
  24 #endif
  25
  26 //MUtils
  27 #include <MUtils/Global.h>
  28 #include <MUtils/OSSupport.h>
  29
  30 //Internal
  31 #include "DirLocker.h"
  32 #include "3rd_party/strnatcmp/include/strnatcmp.h"
  33
  34 //Qt
  35 #include <QDir>
  36 #include <QReadWriteLock>
  37 #include <QProcess>
  38 #include <QTextCodec>
  39 #include <QPair>
  40 #include <QListIterator>
  41
  42 //CRT
  43 #include <cstdlib>
  44 #include <ctime>
  45 #include <process.h>
  46
  47 //VLD
  48 #ifdef _MSC_VER
  49 #include <vld.h>
  50 #endif
  51
  52 ///////////////////////////////////////////////////////////////////////////////
  53 // Random Support
  54 ///////////////////////////////////////////////////////////////////////////////
  55
  56 //Robert Jenkins' 96 bit Mix Function
  57 static unsigned int mix_function(const unsigned int x, const unsigned int y, const unsigned int z)
  58 {
  59         unsigned int a = x;
  60         unsigned int b = y;
  61         unsigned int c = z;
  62
  63         a=a-b;  a=a-c;  a=a^(c >> 13);
  64         b=b-c;  b=b-a;  b=b^(a << 8 );
  65         c=c-a;  c=c-b;  c=c^(b >> 13);
  66         a=a-b;  a=a-c;  a=a^(c >> 12);
  67         b=b-c;  b=b-a;  b=b^(a << 16);
  68         c=c-a;  c=c-b;  c=c^(b >> 5 );
  69         a=a-b;  a=a-c;  a=a^(c >> 3 );
  70         b=b-c;  b=b-a;  b=b^(a << 10);
  71         c=c-a;  c=c-b;  c=c^(b >> 15);
  72
  73         return a ^ b ^ c;
  74 }
  75
  76 void MUtils::seed_rand(void)
  77 {
  78         qsrand(mix_function(clock(), time(NULL), _getpid()));
  79 }
  80
  81 quint32 MUtils::next_rand32(void)
  82 {
  83         quint32 rnd = 0xDEADBEEF;
  84
  85 #ifdef _CRT_RAND_S
  86         if(rand_s(&rnd) == 0)
  87         {
  88                 return rnd;
  89         }
  90 #endif //_CRT_RAND_S
  91
  92         for(size_t i = 0; i < sizeof(quint32); i++)
  93         {
  94                 rnd = (rnd << 8) ^ qrand();
  95         }
  96
  97         return rnd;
  98 }
  99
 100 quint64 MUtils::next_rand64(void)
 101 {
 102         return (quint64(next_rand32()) << 32) | quint64(next_rand32());
 103 }
 104
 105 QString MUtils::rand_str(const bool &bLong)
 106 {
 107         if(!bLong)
 108         {
 109                 return QString::number(next_rand64(), 16).rightJustified(16, QLatin1Char('0'));
 110         }
 111         return QString("%1%2").arg(rand_str(false), rand_str(false));
 112 }
 113
 114 ///////////////////////////////////////////////////////////////////////////////
 115 // GENERATE FILE NAME
 116 ///////////////////////////////////////////////////////////////////////////////
 117
 118 QString MUtils::make_temp_file(const QString &basePath, const QString &extension, const bool placeholder)
 119 {
 120         for(int i = 0; i < 4096; i++)
 121         {
 122                 const QString tempFileName = QString("%1/%2.%3").arg(basePath, rand_str(), extension);
 123                 if(!QFileInfo(tempFileName).exists())
 124                 {
 125                         if(placeholder)
 126                         {
 127                                 QFile file(tempFileName);
 128                                 if(file.open(QFile::ReadWrite))
 129                                 {
 130                                         file.close();
 131                                         return tempFileName;
 132                                 }
 133                         }
 134                         else
 135                         {
 136                                 return tempFileName;
 137                         }
 138                 }
 139         }
 140
 141         qWarning("Failed to generate temp file name!");
 142         return QString();
 143 }
 144
 145 QString MUtils::make_unique_file(const QString &basePath, const QString &baseName, const QString &extension, const bool fancy)
 146 {
 147         quint32 n = fancy ? 2 : 0;
 148         QString fileName = fancy ? QString("%1/%2.%3").arg(basePath, baseName, extension) : QString();
 149         while (fileName.isEmpty() || QFileInfo(fileName).exists())
 150         {
 151                 if (n <= quint32(USHRT_MAX))
 152                 {
 153                         if (fancy)
 154                         {
 155                                 fileName = QString("%1/%2 (%3).%4").arg(basePath, baseName, QString::number(n++), extension);
 156                         }
 157                         else
 158                         {
 159                                 fileName = QString("%1/%2.%3.%4").arg(basePath, baseName, QString::number(n++, 16).rightJustified(4, QLatin1Char('0')), extension);
 160                         }
 161                 }
 162                 else
 163                 {
 164                         qWarning("Failed to generate unique file name!");
 165                         return QString();
 166                 }
 167         }
 168         return fileName;
 169 }
 170
 171 ///////////////////////////////////////////////////////////////////////////////
 172 // COMPUTE PARITY
 173 ///////////////////////////////////////////////////////////////////////////////
 174
 175 /*
 176  * Compute parity in parallel
 177  * http://www.graphics.stanford.edu/~seander/bithacks.html#ParityParallel
 178  */
 179 bool MUtils::parity(quint32 value)
 180 {
 181         value ^= value >> 16;
 182         value ^= value >> 8;
 183         value ^= value >> 4;
 184         value &= 0xf;
 185         return ((0x6996 >> value) & 1) != 0;
 186 }
 187
 188 ///////////////////////////////////////////////////////////////////////////////
 189 // TEMP FOLDER
 190 ///////////////////////////////////////////////////////////////////////////////
 191
 192 static QScopedPointer<MUtils::Internal::DirLock> g_temp_folder_file;
 193 static QReadWriteLock                            g_temp_folder_lock;
 194
 195 static QString try_create_subfolder(const QString &baseDir, const QString &postfix)
 196 {
 197         const QString baseDirPath = QDir(baseDir).absolutePath();
 198         for(int i = 0; i < 32; i++)
 199         {
 200                 QDir directory(baseDirPath);
 201                 if(directory.mkpath(postfix) && directory.cd(postfix))
 202                 {
 203                         return directory.canonicalPath();
 204                 }
 205         }
 206         return QString();
 207 }
 208
 209 static MUtils::Internal::DirLock *try_init_temp_folder(const QString &baseDir)
 210 {
 211         const QString tempPath = try_create_subfolder(baseDir, MUtils::rand_str());
 212         if(!tempPath.isEmpty())
 213         {
 214                 for(int i = 0; i < 32; i++)
 215                 {
 216                         MUtils::Internal::DirLock *lockFile = NULL;
 217                         try
 218                         {
 219                                 lockFile = new MUtils::Internal::DirLock(tempPath);
 220                                 return lockFile;
 221                         }
 222                         catch(MUtils::Internal::DirLockException&)
 223                         {
 224                                 /*ignore error and try again*/
 225                         }
 226                 }
 227         }
 228         return NULL;
 229 }
 230
 231 static bool temp_folder_cleanup_helper(const QString &tempPath)
 232 {
 233         size_t delay = 1;
 234         static const size_t MAX_DELAY = 8192;
 235         forever
 236         {
 237                 QDir::setCurrent(QDir::rootPath());
 238                 if(MUtils::remove_directory(tempPath, true))
 239                 {
 240                         return true;
 241                 }
 242                 else
 243                 {
 244                         if(delay > MAX_DELAY)
 245                         {
 246                                 return false;
 247                         }
 248                         MUtils::OS::sleep_ms(delay);
 249                         delay *= 2;
 250                 }
 251         }
 252 }
 253
 254 static void temp_folder_cleaup(void)
 255 {
 256         QWriteLocker writeLock(&g_temp_folder_lock);
 257
 258         //Clean the directory
 259         while(!g_temp_folder_file.isNull())
 260         {
 261                 const QString tempPath = g_temp_folder_file->getPath();
 262                 g_temp_folder_file.reset(NULL);
 263                 if(!temp_folder_cleanup_helper(tempPath))
 264                 {
 265                         MUtils::OS::system_message_wrn(L"Temp Cleaner", L"Warning: Not all temporary files could be removed!");
 266                 }
 267         }
 268 }
 269
 270 const QString &MUtils::temp_folder(void)
 271 {
 272         QReadLocker readLock(&g_temp_folder_lock);
 273
 274         //Already initialized?
 275         if(!g_temp_folder_file.isNull())
 276         {
 277                 return g_temp_folder_file->getPath();
 278         }
 279
 280         //Obtain the write lock to initilaize
 281         readLock.unlock();
 282         QWriteLocker writeLock(&g_temp_folder_lock);
 283
 284         //Still uninitilaized?
 285         if(!g_temp_folder_file.isNull())
 286         {
 287                 return g_temp_folder_file->getPath();
 288         }
 289
 290         //Try the %TMP% or %TEMP% directory first
 291         if(MUtils::Internal::DirLock *lockFile = try_init_temp_folder(QDir::tempPath()))
 292         {
 293                 g_temp_folder_file.reset(lockFile);
 294                 atexit(temp_folder_cleaup);
 295                 return lockFile->getPath();
 296         }
 297
 298         qWarning("%%TEMP%% directory not found -> trying fallback mode now!");
 299         static const OS::known_folder_t FOLDER_ID[2] = { OS::FOLDER_LOCALAPPDATA, OS::FOLDER_SYSTROOT_DIR };
 300         for(size_t id = 0; id < 2; id++)
 301         {
 302                 const QString &knownFolder = OS::known_folder(FOLDER_ID[id]);
 303                 if(!knownFolder.isEmpty())
 304                 {
 305                         const QString tempRoot = try_create_subfolder(knownFolder, QLatin1String("TEMP"));
 306                         if(!tempRoot.isEmpty())
 307                         {
 308                                 if(MUtils::Internal::DirLock *lockFile = try_init_temp_folder(tempRoot))
 309                                 {
 310                                         g_temp_folder_file.reset(lockFile);
 311                                         atexit(temp_folder_cleaup);
 312                                         return lockFile->getPath();
 313                                 }
 314                         }
 315                 }
 316         }
 317
 318         qFatal("Temporary directory could not be initialized !!!");
 319         return (*((QString*)NULL));
 320 }
 321
 322 ///////////////////////////////////////////////////////////////////////////////
 323 // REMOVE DIRECTORY / FILE
 324 ///////////////////////////////////////////////////////////////////////////////
 325
 326 static const QFile::Permissions FILE_PERMISSIONS_NONE = QFile::ReadOther | QFile::WriteOther;
 327
 328 bool MUtils::remove_file(const QString &fileName)
 329 {
 330         QFileInfo fileInfo(fileName);
 331         if(!(fileInfo.exists() && fileInfo.isFile()))
 332         {
 333                 return true;
 334         }
 335
 336         for(int i = 0; i < 32; i++)
 337         {
 338                 QFile file(fileName);
 339                 file.setPermissions(FILE_PERMISSIONS_NONE);
 340                 if((!(fileInfo.exists() && fileInfo.isFile())) || file.remove())
 341                 {
 342                         return true;
 343                 }
 344                 fileInfo.refresh();
 345         }
 346
 347         qWarning("Could not delete \"%s\"", MUTILS_UTF8(fileName));
 348         return false;
 349 }
 350
 351 static bool remove_directory_helper(const QDir &folder)
 352 {
 353         if(!folder.exists())
 354         {
 355                 return true;
 356         }
 357         const QString dirName = folder.dirName();
 358         if(!dirName.isEmpty())
 359         {
 360                 QDir parent(folder);
 361                 if(parent.cdUp())
 362                 {
 363                         QFile::setPermissions(folder.absolutePath(), FILE_PERMISSIONS_NONE);
 364                         if(parent.rmdir(dirName))
 365                         {
 366                                 return true;
 367                         }
 368                 }
 369         }
 370         return false;
 371 }
 372
 373 bool MUtils::remove_directory(const QString &folderPath, const bool &recursive)
 374 {
 375         QDir folder(folderPath);
 376         if(!folder.exists())
 377         {
 378                 return true;
 379         }
 380
 381         if(recursive)
 382         {
 383                 const QFileInfoList entryList = folder.entryInfoList(QDir::AllEntries | QDir::NoDotAndDotDot | QDir::Hidden);
 384                 for(QFileInfoList::ConstIterator iter = entryList.constBegin(); iter != entryList.constEnd(); iter++)
 385                 {
 386                         if(iter->isDir())
 387                         {
 388                                 remove_directory(iter->canonicalFilePath(), true);
 389                         }
 390                         else if(iter->isFile())
 391                         {
 392                                 remove_file(iter->canonicalFilePath());
 393                         }
 394                 }
 395         }
 396
 397         for(int i = 0; i < 32; i++)
 398         {
 399                 if(remove_directory_helper(folder))
 400                 {
 401                         return true;
 402                 }
 403                 folder.refresh();
 404         }
 405
 406         qWarning("Could not rmdir \"%s\"", MUTILS_UTF8(folderPath));
 407         return false;
 408 }
 409
 410 ///////////////////////////////////////////////////////////////////////////////
 411 // PROCESS UTILS
 412 ///////////////////////////////////////////////////////////////////////////////
 413
 414 static void prependToPath(QProcessEnvironment &env, const QString &value)
 415 {
 416         const QLatin1String PATH = QLatin1String("PATH");
 417         const QString path = env.value(PATH, QString()).trimmed();
 418         env.insert(PATH, path.isEmpty() ? value : QString("%1;%2").arg(value, path));
 419 }
 420
 421 void MUtils::init_process(QProcess &process, const QString &wokringDir, const bool bReplaceTempDir, const QStringList *const extraPaths)
 422 {
 423         //Environment variable names
 424         static const char *const s_envvar_names_temp[] =
 425         {
 426                 "TEMP", "TMP", "TMPDIR", "HOME", "USERPROFILE", "HOMEPATH", NULL
 427         };
 428         static const char *const s_envvar_names_remove[] =
 429         {
 430                 "WGETRC", "SYSTEM_WGETRC", "HTTP_PROXY", "FTP_PROXY", "NO_PROXY", "GNUPGHOME", "LC_ALL", "LC_COLLATE", "LC_CTYPE", "LC_MESSAGES", "LC_MONETARY", "LC_NUMERIC", "LC_TIME", "LANG", NULL
 431         };
 432
 433         //Initialize environment
 434         QProcessEnvironment env = process.processEnvironment();
 435         if(env.isEmpty()) env = QProcessEnvironment::systemEnvironment();
 436
 437         //Clean a number of enviroment variables that might affect our tools
 438         for(size_t i = 0; s_envvar_names_remove[i]; i++)
 439         {
 440                 env.remove(QString::fromLatin1(s_envvar_names_remove[i]));
 441                 env.remove(QString::fromLatin1(s_envvar_names_remove[i]).toLower());
 442         }
 443
 444         const QString tempDir = QDir::toNativeSeparators(temp_folder());
 445
 446         //Replace TEMP directory in environment
 447         if(bReplaceTempDir)
 448         {
 449                 for(size_t i = 0; s_envvar_names_temp[i]; i++)
 450                 {
 451                         env.insert(s_envvar_names_temp[i], tempDir);
 452                 }
 453         }
 454
 455         //Setup PATH variable
 456         prependToPath(env, tempDir);
 457         if (extraPaths && (!extraPaths->isEmpty()))
 458         {
 459                 QListIterator<QString> iter(*extraPaths);
 460                 iter.toBack();
 461                 while (iter.hasPrevious())
 462                 {
 463                         prependToPath(env, QDir::toNativeSeparators(iter.previous()));
 464                 }
 465         }
 466
 467         //Setup QPorcess object
 468         process.setWorkingDirectory(wokringDir);
 469         process.setProcessChannelMode(QProcess::MergedChannels);
 470         process.setReadChannel(QProcess::StandardOutput);
 471         process.setProcessEnvironment(env);
 472 }
 473
 474 ///////////////////////////////////////////////////////////////////////////////
 475 // NATURAL ORDER STRING COMPARISON
 476 ///////////////////////////////////////////////////////////////////////////////
 477
 478 static bool natural_string_sort_helper(const QString &str1, const QString &str2)
 479 {
 480         return (MUtils::Internal::NaturalSort::strnatcmp(MUTILS_WCHR(str1), MUTILS_WCHR(str2)) < 0);
 481 }
 482
 483 static bool natural_string_sort_helper_fold_case(const QString &str1, const QString &str2)
 484 {
 485         return (MUtils::Internal::NaturalSort::strnatcasecmp(MUTILS_WCHR(str1), MUTILS_WCHR(str2)) < 0);
 486 }
 487
 488 void MUtils::natural_string_sort(QStringList &list, const bool bIgnoreCase)
 489 {
 490         qSort(list.begin(), list.end(), bIgnoreCase ? natural_string_sort_helper_fold_case : natural_string_sort_helper);
 491 }
 492
 493 ///////////////////////////////////////////////////////////////////////////////
 494 // CLEAN FILE PATH
 495 ///////////////////////////////////////////////////////////////////////////////
 496
 497 static const char FILENAME_ILLEGAL_CHARS[] = "\\/:*?<>\"";
 498
 499 QString MUtils::clean_file_name(const QString &name)
 500 {
 501         QString result(name);
 502         if (result.contains(QLatin1Char('"')))
 503         {
 504                 QRegExp quoted("\"(.+)\"");
 505                 quoted.setMinimal(true);
 506                 result.replace(quoted, "``\\1´´");
 507         }
 508
 509         for(QString::Iterator iter = result.begin(); iter != result.end(); iter++)
 510         {
 511                 if (iter->category() == QChar::Other_Control)
 512                 {
 513                         *iter = QLatin1Char('_');
 514                 }
 515         }
 516
 517         for(size_t i = 0; FILENAME_ILLEGAL_CHARS[i]; i++)
 518         {
 519                 result.replace(QLatin1Char(FILENAME_ILLEGAL_CHARS[i]), QLatin1Char('_'));
 520         }
 521
 522         const QRegExp spaces("\\s+$");
 523         result.remove(spaces);
 524         while (result.endsWith(QLatin1Char('.')))
 525         {
 526                 result.chop(1);
 527                 result.remove(spaces);
 528         }
 529
 530         return result;
 531 }
 532
 533 static QPair<QString,QString> clean_file_path_get_prefix(const QString path)
 534 {
 535         static const char *const PREFIXES[] =
 536         {
 537                 "//?/", "//", "/", NULL
 538         };
 539         const QString posixPath = QDir::fromNativeSeparators(path.trimmed());
 540         for (int i = 0; PREFIXES[i]; i++)
 541         {
 542                 const QString prefix = QString::fromLatin1(PREFIXES[i]);
 543                 if (posixPath.startsWith(prefix))
 544                 {
 545                         return qMakePair(prefix, posixPath.mid(prefix.length()));
 546                 }
 547         }
 548         return qMakePair(QString(), posixPath);
 549 }
 550
 551 QString MUtils::clean_file_path(const QString &path)
 552 {
 553         const QPair<QString, QString> prefix = clean_file_path_get_prefix(path);
 554
 555         QStringList parts = prefix.second.split(QLatin1Char('/'), QString::SkipEmptyParts);
 556         for(int i = 0; i < parts.count(); i++)
 557         {
 558                 if((i == 0) && (parts[i].length() == 2) && parts[i][0].isLetter() && (parts[i][1] == QLatin1Char(':')))
 559                 {
 560                         continue; //handle case "c:\"
 561                 }
 562                 parts[i] = MUtils::clean_file_name(parts[i]);
 563         }
 564
 565         const QString cleanPath = parts.join(QLatin1String("/"));
 566         return prefix.first.isEmpty() ? cleanPath : prefix.first + cleanPath;
 567 }
 568
 569 ///////////////////////////////////////////////////////////////////////////////
 570 // REGULAR EXPESSION HELPER
 571 ///////////////////////////////////////////////////////////////////////////////
 572
 573 bool MUtils::regexp_parse_uint32(const QRegExp &regexp, quint32 &value)
 574 {
 575         return regexp_parse_uint32(regexp, &value, 1);
 576 }
 577
 578 bool MUtils::regexp_parse_uint32(const QRegExp &regexp, quint32 *values, const size_t &count)
 579 {
 580         const QStringList caps = regexp.capturedTexts();
 581
 582         if(caps.isEmpty() || (quint32(caps.count()) <= count))
 583         {
 584                 return false;
 585         }
 586
 587         for(size_t i = 0; i < count; i++)
 588         {
 589                 bool ok = false;
 590                 values[i] = caps[i+1].toUInt(&ok);
 591                 if(!ok)
 592                 {
 593                         return false;
 594                 }
 595         }
 596
 597         return true;
 598 }
 599
 600 ///////////////////////////////////////////////////////////////////////////////
 601 // AVAILABLE CODEPAGES
 602 ///////////////////////////////////////////////////////////////////////////////
 603
 604 QStringList MUtils::available_codepages(const bool &noAliases)
 605 {
 606         QStringList codecList;
 607         QList<QByteArray> availableCodecs = QTextCodec::availableCodecs();
 608
 609         while(!availableCodecs.isEmpty())
 610         {
 611                 const QByteArray current = availableCodecs.takeFirst();
 612                 if(!current.toLower().startsWith("system"))
 613                 {
 614                         codecList << QString::fromLatin1(current.constData(), current.size());
 615                         if(noAliases)
 616                         {
 617                                 if(QTextCodec *const currentCodec = QTextCodec::codecForName(current.constData()))
 618                                 {
 619                                         const QList<QByteArray> aliases = currentCodec->aliases();
 620                                         for(QList<QByteArray>::ConstIterator iter = aliases.constBegin(); iter != aliases.constEnd(); iter++)
 621                                         {
 622                                                 availableCodecs.removeAll(*iter);
 623                                         }
 624                                 }
 625                         }
 626                 }
 627         }
 628
 629         return codecList;
 630 }
 631
 632 ///////////////////////////////////////////////////////////////////////////////
 633 // SELF-TEST
 634 ///////////////////////////////////////////////////////////////////////////////
 635
 636 int MUtils::Internal::selfTest(const char *const buildKey, const bool debug)
 637 {
 638         static const bool MY_DEBUG_FLAG = MUTILS_DEBUG;
 639         static const char *const MY_BUILD_KEY = __DATE__ "@" __TIME__;
 640
 641         if(strncmp(buildKey, MY_BUILD_KEY, 13) || (MY_DEBUG_FLAG != debug))
 642         {
 643                 MUtils::OS::system_message_err(L"MUtils", L"FATAL ERROR: MUtils library version mismatch detected!");
 644                 MUtils::OS::system_message_wrn(L"MUtils", L"Perform a clean(!) re-install of the application to fix the problem!");
 645                 abort();
 646         }
 647         return 0;
 648 }