// 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()); }