// static
SecurityTokenPointer Sandbox::openSecurityToken(const QDir& dir, bool create) {
QDir walkDir = dir;
QString walkDirCanonicalPath = walkDir.canonicalPath();
if (sDebug) {
qDebug() << "openSecurityToken QDir" << walkDirCanonicalPath << create;
}
if (!enabled()) {
return SecurityTokenPointer();
}
QMutexLocker locker(&s_mutex);
if (s_pSandboxPermissions == NULL) {
return SecurityTokenPointer();
}
while (true) {
// Look for a valid token in the cache.
QHash<QString, SecurityTokenWeakPointer>::iterator it = s_activeTokens
.find(walkDirCanonicalPath);
if (it != s_activeTokens.end()) {
SecurityTokenPointer pToken(it.value());
if (pToken) {
if (sDebug) {
qDebug() << "openSecurityToken QDir" << walkDirCanonicalPath
<< "using cached token for" << pToken->m_path;
}
return pToken;
}
}
// Next, check if the key exists in the config.
ConfigKey key = keyForCanonicalPath(walkDirCanonicalPath);
if (s_pSandboxPermissions->exists(key)) {
SecurityTokenPointer pToken = openTokenFromBookmark(
dir.canonicalPath(),
s_pSandboxPermissions->getValueString(key));
if (pToken) {
return pToken;
}
}
// Go one step higher and repeat.
if (!walkDir.cdUp()) {
// There's nothing higher. Bail.
break;
}
walkDirCanonicalPath = walkDir.canonicalPath();
}
// Last chance: Try to create a token for this directory.
if (create && createSecurityToken(dir.canonicalPath(), true)) {
ConfigKey key = keyForCanonicalPath(dir.canonicalPath());
return openTokenFromBookmark(
dir.canonicalPath(),
s_pSandboxPermissions->getValueString(key));
}
return SecurityTokenPointer();
}
SecurityTokenPointer Sandbox::openTokenFromBookmark(const QString& canonicalPath,
const QString& bookmarkBase64) {
#ifdef Q_OS_MAC
#if __MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
QByteArray bookmarkBA = QByteArray::fromBase64(bookmarkBase64.toLatin1());
if (!bookmarkBA.isEmpty()) {
CFDataRef bookmarkData = CFDataCreate(
kCFAllocatorDefault, reinterpret_cast<const UInt8*>(bookmarkBA.constData()),
bookmarkBA.length());
Boolean stale;
CFErrorRef error = NULL;
CFURLRef url = CFURLCreateByResolvingBookmarkData(
kCFAllocatorDefault, bookmarkData,
kCFURLBookmarkResolutionWithSecurityScope, NULL, NULL,
&stale, &error);
if (error != NULL) {
if (sDebug) {
qDebug() << "Error creating URL from bookmark data:"
<< CFStringToQString(CFErrorCopyDescription(error));
}
}
CFRelease(bookmarkData);
if (url != NULL) {
if (!CFURLStartAccessingSecurityScopedResource(url)) {
if (sDebug) {
qDebug() << "CFURLStartAccessingSecurityScopedResource failed for"
<< canonicalPath;
}
} else {
SecurityTokenPointer pToken = SecurityTokenPointer(
new SandboxSecurityToken(canonicalPath, url));
s_activeTokens[canonicalPath] = pToken;
return pToken;
}
} else {
if (sDebug) {
qDebug() << "Cannot resolve security-scoped bookmark for" << canonicalPath;
}
}
}
#endif
#else
Q_UNUSED(canonicalPath);
Q_UNUSED(bookmarkBase64);
#endif
return SecurityTokenPointer();
}
//static
TrackPointer Track::newDummy(
const QFileInfo& fileInfo,
TrackId trackId) {
Track* pTrack =
new Track(
fileInfo,
SecurityTokenPointer(),
trackId);
return TrackPointer(pTrack);
}
//static
TrackPointer TrackInfoObject::newDummy(
const QFileInfo& fileInfo,
TrackId trackId) {
return TrackPointer(
new TrackInfoObject(
fileInfo,
SecurityTokenPointer(),
trackId),
&QObject::deleteLater);
}
// static
SecurityTokenPointer Sandbox::openSecurityToken(const QFileInfo& file, bool create) {
const QString& canonicalFilePath = file.canonicalFilePath();
if (sDebug) {
qDebug() << "openSecurityToken QFileInfo" << canonicalFilePath << create;
}
if (!enabled()) {
return SecurityTokenPointer();
}
QMutexLocker locker(&s_mutex);
if (s_pSandboxPermissions == NULL) {
return SecurityTokenPointer();
}
QHash<QString, SecurityTokenWeakPointer>::iterator it = s_activeTokens
.find(canonicalFilePath);
if (it != s_activeTokens.end()) {
SecurityTokenPointer pToken(it.value());
if (pToken) {
if (sDebug) {
qDebug() << "openSecurityToken QFileInfo" << canonicalFilePath
<< "using cached token for" << pToken->m_path;
}
return pToken;
}
}
if (file.isDir()) {
return openSecurityToken(QDir(canonicalFilePath), create);
}
// First, check for a bookmark of the key itself.
ConfigKey key = keyForCanonicalPath(canonicalFilePath);
if (s_pSandboxPermissions->exists(key)) {
return openTokenFromBookmark(
canonicalFilePath,
s_pSandboxPermissions->getValueString(key));
}
// Next, try to open a bookmark for an existing directory but don't create a
// bookmark.
SecurityTokenPointer pDirToken = openSecurityToken(file.dir(), false);
if (!pDirToken.isNull()) {
return pDirToken;
}
if (!create) {
return SecurityTokenPointer();
}
// Otherwise, try to create a token.
bool created = createSecurityToken(file);
if (created) {
return openTokenFromBookmark(
canonicalFilePath,
s_pSandboxPermissions->getValueString(key));
}
return SecurityTokenPointer();
}
TEST_F(CoverArtUtilTest, searchImage) {
// creating a temp track directory
QString trackdir(QDir::tempPath() % "/TrackDir");
ASSERT_FALSE(QDir().exists(trackdir)); // it must start empty
ASSERT_TRUE(QDir().mkpath(trackdir));
TrackPointer pTrack(new TrackInfoObject(kTrackLocationTest));
QLinkedList<QFileInfo> covers;
CoverArt res;
// looking for cover in an empty directory
res = CoverArtUtils::selectCoverArtForTrack(pTrack.data(), covers);
CoverArt expected;
expected.info.source = CoverInfo::GUESSED;
EXPECT_EQ(expected, res);
// Looking for a track with embedded cover.
pTrack = TrackPointer(new TrackInfoObject(kTrackLocationTest,
SecurityTokenPointer(),
true, true));
expected = CoverArt();
expected.image = pTrack->getCoverArt().image;
expected.info.type = CoverInfo::METADATA;
expected.info.source = CoverInfo::GUESSED;
expected.info.coverLocation = QString();
expected.info.hash = CoverArtUtils::calculateHash(expected.image);
EXPECT_EQ(expected, pTrack->getCoverArt());
const char* format("jpg");
const QString qFormat(format);
// Since we already parsed this image from the matadata in
// kTrackLocationTest, hang on to it since we use it as a template for
// stuff below.
const QImage img = expected.image;
QString trackBaseName = "cover-test";
QString trackAlbum = "album_name";
// Search Strategy
// 0. If we have just one file, we will get it.
// 1. %track-file-base%.jpg in the track directory for %track-file-base%.mp3
// 2. %album%.jpg
// 3. cover.jpg
// 4. front.jpg
// 5. album.jpg
// 6. folder.jpg
// 7. if just one file exists take that otherwise none.
// All the following expect the same image/hash to be selected.
expected.image = img;
expected.info.hash = CoverArtUtils::calculateHash(expected.image);
// All the following expect FILE and GUESSED.
expected.info.type = CoverInfo::FILE;
expected.info.source = CoverInfo::GUESSED;
// 0. saving just one cover in our temp track dir
QString cLoc_foo = QString(trackdir % "/" % "foo." % qFormat);
EXPECT_TRUE(img.save(cLoc_foo, format));
// looking for cover in an directory with one image will select that one.
expected.image = QImage(cLoc_foo);
expected.info.coverLocation = "foo.jpg";
expected.info.hash = CoverArtUtils::calculateHash(expected.image);
covers << QFileInfo(cLoc_foo);
res = CoverArtUtils::selectCoverArtForTrack(trackBaseName, trackAlbum,
covers);
EXPECT_EQ(expected, res);
QFile::remove(cLoc_foo);
QStringList extraCovers;
// adding some extra images (bigger) just to populate the track dir.
QString cLoc_big1 = QString(trackdir % "/" % "big1." % qFormat);
EXPECT_TRUE(img.scaled(1000,1000).save(cLoc_big1, format));
extraCovers << cLoc_big1;
QString cLoc_big2 = QString(trackdir % "/" % "big2." % qFormat);
EXPECT_TRUE(img.scaled(900,900).save(cLoc_big2, format));
extraCovers << cLoc_big2;
QString cLoc_big3 = QString(trackdir % "/" % "big3." % qFormat);
EXPECT_TRUE(img.scaled(800,800).save(cLoc_big3, format));
extraCovers << cLoc_big3;
// saving more covers using the preferred names in the right order
QLinkedList<QFileInfo> prefCovers;
// 1. track_filename.jpg
QString cLoc_filename = QString(trackdir % "/cover-test." % qFormat);
EXPECT_TRUE(img.scaled(500,500).save(cLoc_filename, format));
prefCovers << QFileInfo(cLoc_filename);
// 2. album_name.jpg
QString cLoc_albumName = QString(trackdir % "/album_name." % qFormat);
EXPECT_TRUE(img.scaled(500,500).save(cLoc_albumName, format));
prefCovers << QFileInfo(cLoc_albumName);
// 3. cover.jpg
QString cLoc_cover = QString(trackdir % "/" % "cover." % qFormat);
EXPECT_TRUE(img.scaled(400,400).save(cLoc_cover, format));
prefCovers << QFileInfo(cLoc_cover);
// 4. front.jpg
QString cLoc_front = QString(trackdir % "/" % "front." % qFormat);
EXPECT_TRUE(img.scaled(300,300).save(cLoc_front, format));
prefCovers << QFileInfo(cLoc_front);
// 5. album.jpg
QString cLoc_album = QString(trackdir % "/" % "album." % qFormat);
EXPECT_TRUE(img.scaled(100,100).save(cLoc_album, format));
prefCovers << QFileInfo(cLoc_album);
// 6. folder.jpg
QString cLoc_folder = QString(trackdir % "/" % "folder." % qFormat);
EXPECT_TRUE(img.scaled(100,100).save(cLoc_folder, format));
prefCovers << QFileInfo(cLoc_folder);
// 8. other1.jpg
QString cLoc_other1 = QString(trackdir % "/" % "other1." % qFormat);
EXPECT_TRUE(img.scaled(10,10).save(cLoc_other1, format));
prefCovers << QFileInfo(cLoc_other1);
// 7. other2.jpg
QString cLoc_other2 = QString(trackdir % "/" % "other2." % qFormat);
EXPECT_TRUE(img.scaled(10,10).save(cLoc_other2, format));
prefCovers << QFileInfo(cLoc_other2);
// we must find covers in the right order
EXPECT_EQ(8, prefCovers.size());
// Remove the covers one by one from the front, checking that each one is
// selected as we remove the previously-most-preferable cover.
while (!prefCovers.isEmpty()) {
QFileInfo cover = prefCovers.first();
// We expect no cover selected for other1 since there are 2 covers,
// neither of which match our preferred cover names. other2 will be
// selected once we get to it since it is the only cover available.
if (cover.baseName() == "other1") {
expected.image = QImage();
expected.info.type = CoverInfo::NONE;
expected.info.coverLocation = QString();
expected.info.hash = 0;
} else {
expected.image = QImage(cover.filePath());
expected.info.type = CoverInfo::FILE;
expected.info.coverLocation = cover.fileName();
expected.info.hash = CoverArtUtils::calculateHash(expected.image);
}
res = CoverArtUtils::selectCoverArtForTrack(trackBaseName, trackAlbum,
prefCovers);
EXPECT_QSTRING_EQ(expected.info.coverLocation, res.info.coverLocation);
EXPECT_QSTRING_EQ(expected.info.hash, res.info.hash);
EXPECT_EQ(expected, res);
QFile::remove(cover.filePath());
prefCovers.pop_front();
}
//
// Additional tests
//
// what is chosen when cover.jpg and cover.JPG exists?
// (it must always prefer the lighter cover)
QString cLoc_coverJPG = trackdir % "/" % "cover." % "JPG";
EXPECT_TRUE(img.scaled(200,200).save(cLoc_coverJPG, "JPG"));
prefCovers.append(QFileInfo(cLoc_coverJPG));
QString cLoc_coverjpg = trackdir % "/" % "cover." % "jpg";
EXPECT_TRUE(img.scaled(400,400).save(cLoc_coverjpg, "jpg"));
prefCovers.append(QFileInfo(cLoc_coverjpg));
extraCovers << cLoc_coverJPG << cLoc_coverjpg;
res = CoverArtUtils::selectCoverArtForTrack(trackBaseName, trackAlbum,
prefCovers);
expected.image = QImage(cLoc_coverJPG);
expected.info.hash = CoverArtUtils::calculateHash(expected.image);
expected.info.coverLocation = "cover.JPG";
EXPECT_EQ(expected, res);
// As we are looking for %album%.jpg and %base_track.jpg%,
// we need to check if everything works with UTF8 chars.
trackBaseName = QString::fromUtf8("track_ðÑöæäî");
trackAlbum = QString::fromUtf8("öæäîðÑ_album");
prefCovers.clear();
// 2. album_name.jpg
cLoc_albumName = QString(trackdir % "/" % trackAlbum % "." % qFormat);
EXPECT_TRUE(img.save(cLoc_albumName, format));
prefCovers.append(QFileInfo(cLoc_albumName));
res = CoverArtUtils::selectCoverArtForTrack(trackBaseName, trackAlbum,
prefCovers);
expected.image = QImage(cLoc_albumName);
expected.info.hash = CoverArtUtils::calculateHash(expected.image);
expected.info.coverLocation = trackAlbum % ".jpg";
EXPECT_EQ(expected, res);
// 1. track_filename.jpg
cLoc_filename = QString(trackdir % "/" % trackBaseName % "." % qFormat);
EXPECT_TRUE(img.save(cLoc_filename, format));
prefCovers.append(QFileInfo(cLoc_filename));
res = CoverArtUtils::selectCoverArtForTrack(trackBaseName, trackAlbum,
prefCovers);
expected.image = QImage(cLoc_filename);
expected.info.hash = CoverArtUtils::calculateHash(expected.image);
expected.info.coverLocation = trackBaseName % ".jpg";
EXPECT_EQ(expected, res);
QFile::remove(cLoc_filename);
QFile::remove(cLoc_albumName);
// cleaning temp dir
foreach (QString loc, extraCovers) {
QFile::remove(loc);
}
Mixxx::SoundSourcePointer loadProxy(const QString& track) {
m_pProxy.reset(new SoundSourceProxy(track, SecurityTokenPointer()));
return m_pProxy->getSoundSource();
}
TrackPointer createTestTrack() const {
const QString kTrackLocationTest = QDir::currentPath() + "/src/test/sine-30.wav";
return std::make_unique<Track>(kTrackLocationTest, SecurityTokenPointer());
}