2004-02-24 00:41:20 +01:00
|
|
|
/* the Music Player Daemon (MPD)
|
2006-07-14 21:37:45 +02:00
|
|
|
* (c)2003-2006 by Warren Dukes (warren.dukes@gmail.com)
|
2004-02-24 00:41:20 +01:00
|
|
|
* This project's homepage is: http://www.musicpd.org
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "directory.h"
|
|
|
|
|
|
|
|
#include "ls.h"
|
|
|
|
#include "command.h"
|
|
|
|
#include "utils.h"
|
|
|
|
#include "path.h"
|
|
|
|
#include "log.h"
|
|
|
|
#include "conf.h"
|
|
|
|
#include "stats.h"
|
2004-03-10 10:55:54 +01:00
|
|
|
#include "playlist.h"
|
2004-04-11 03:53:25 +02:00
|
|
|
#include "listen.h"
|
|
|
|
#include "interface.h"
|
|
|
|
#include "volume.h"
|
2004-04-11 05:12:00 +02:00
|
|
|
#include "mpd_types.h"
|
2004-04-11 06:15:14 +02:00
|
|
|
#include "sig_handlers.h"
|
2004-11-10 22:58:27 +01:00
|
|
|
#include "list.h"
|
|
|
|
#include "dbUtils.h"
|
2005-12-31 04:23:46 +01:00
|
|
|
#include "tagTracker.h"
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-04-11 03:53:25 +02:00
|
|
|
#include <sys/wait.h>
|
2004-02-24 00:41:20 +01:00
|
|
|
#include <dirent.h>
|
|
|
|
#include <errno.h>
|
2005-03-06 20:00:58 +01:00
|
|
|
#include <assert.h>
|
2006-06-07 23:00:36 +02:00
|
|
|
#include <libgen.h>
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
#define DIRECTORY_DIR "directory: "
|
|
|
|
#define DIRECTORY_MTIME "mtime: "
|
|
|
|
#define DIRECTORY_BEGIN "begin: "
|
|
|
|
#define DIRECTORY_END "end: "
|
|
|
|
#define DIRECTORY_INFO_BEGIN "info_begin"
|
|
|
|
#define DIRECTORY_INFO_END "info_end"
|
|
|
|
#define DIRECTORY_MPD_VERSION "mpd_version: "
|
|
|
|
#define DIRECTORY_FS_CHARSET "fs_charset: "
|
|
|
|
|
2004-04-16 02:41:56 +02:00
|
|
|
#define DIRECTORY_UPDATE_EXIT_NOUPDATE 0
|
|
|
|
#define DIRECTORY_UPDATE_EXIT_UPDATE 1
|
|
|
|
#define DIRECTORY_UPDATE_EXIT_ERROR 2
|
|
|
|
|
2004-04-16 02:48:47 +02:00
|
|
|
#define DIRECTORY_RETURN_NOUPDATE 0
|
|
|
|
#define DIRECTORY_RETURN_UPDATE 1
|
|
|
|
#define DIRECTORY_RETURN_ERROR -1
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
Directory *mp3rootDirectory = NULL;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2005-03-06 21:04:50 +01:00
|
|
|
time_t directory_dbModTime = 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-04-12 20:51:16 +02:00
|
|
|
volatile int directory_updatePid = 0;
|
2004-04-11 03:53:25 +02:00
|
|
|
|
2004-04-12 20:51:16 +02:00
|
|
|
volatile int directory_reReadDB = 0;
|
2004-04-12 01:07:43 +02:00
|
|
|
|
2004-04-12 20:51:16 +02:00
|
|
|
volatile mpd_uint16 directory_updateJobId = 0;
|
2004-04-11 05:12:00 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static DirectoryList *newDirectoryList();
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static int addToDirectory(Directory * directory, char *shortname, char *name);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-14 21:11:11 +02:00
|
|
|
static void freeDirectoryList(DirectoryList * list);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-14 21:11:11 +02:00
|
|
|
static void freeDirectory(Directory * directory);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-14 21:11:11 +02:00
|
|
|
static int exploreDirectory(Directory * directory);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-14 21:11:11 +02:00
|
|
|
static int updateDirectory(Directory * directory);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-14 21:11:11 +02:00
|
|
|
static void deleteEmptyDirectoriesInDirectory(Directory * directory);
|
2004-03-09 23:48:35 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static void removeSongFromDirectory(Directory * directory, char *shortname);
|
2004-04-11 19:37:47 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static int addSubDirectoryToDirectory(Directory * directory, char *shortname,
|
|
|
|
char *name, struct stat *st);
|
2004-04-14 04:35:29 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static Directory *getDirectoryDetails(char *name, char **shortname);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static Directory *getDirectory(char *name);
|
2004-04-11 19:37:47 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static Song *getSongDetails(char *file, char **shortnameRet,
|
|
|
|
Directory ** directoryRet);
|
2004-04-11 19:37:47 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static int updatePath(char *utf8path);
|
2004-04-14 04:35:29 +02:00
|
|
|
|
2006-07-14 21:11:11 +02:00
|
|
|
static void sortDirectory(Directory * directory);
|
2004-04-14 07:26:32 +02:00
|
|
|
|
2006-07-14 21:11:11 +02:00
|
|
|
static int inodeFoundInParent(Directory * parent, ino_t inode, dev_t device);
|
2004-06-23 05:33:35 +02:00
|
|
|
|
2006-07-14 21:11:11 +02:00
|
|
|
static int statDirectory(Directory * dir);
|
2004-06-23 06:20:35 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static char *getDbFile()
|
|
|
|
{
|
|
|
|
ConfigParam *param = parseConfigFilePath(CONF_DB_FILE, 1);
|
2005-03-06 20:00:58 +01:00
|
|
|
|
|
|
|
assert(param);
|
|
|
|
assert(param->value);
|
|
|
|
|
|
|
|
return param->value;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static void clearUpdatePid()
|
|
|
|
{
|
2004-04-13 18:46:11 +02:00
|
|
|
directory_updatePid = 0;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
int isUpdatingDB()
|
|
|
|
{
|
|
|
|
if (directory_updatePid > 0 || directory_reReadDB) {
|
2004-04-12 02:41:53 +02:00
|
|
|
return directory_updateJobId;
|
|
|
|
}
|
2004-04-11 04:34:26 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
void directory_sigChldHandler(int pid, int status)
|
|
|
|
{
|
|
|
|
if (directory_updatePid == pid) {
|
|
|
|
if (WIFSIGNALED(status) && WTERMSIG(status) != SIGTERM) {
|
|
|
|
ERROR("update process died from a "
|
|
|
|
"non-TERM signal: %i\n", WTERMSIG(status));
|
|
|
|
} else if (!WIFSIGNALED(status)) {
|
|
|
|
switch (WEXITSTATUS(status)) {
|
|
|
|
case DIRECTORY_UPDATE_EXIT_UPDATE:
|
|
|
|
directory_reReadDB = 1;
|
|
|
|
DEBUG("directory_sigChldHandler: "
|
|
|
|
"updated db\n");
|
|
|
|
case DIRECTORY_UPDATE_EXIT_NOUPDATE:
|
|
|
|
DEBUG("directory_sigChldHandler: "
|
|
|
|
"update exited succesffully\n");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ERROR("error updating db\n");
|
|
|
|
}
|
2004-04-11 03:53:25 +02:00
|
|
|
}
|
2004-04-13 18:46:11 +02:00
|
|
|
clearUpdatePid();
|
2004-04-11 03:53:25 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
void readDirectoryDBIfUpdateIsFinished()
|
|
|
|
{
|
|
|
|
if (directory_reReadDB && 0 == directory_updatePid) {
|
2004-04-12 01:07:43 +02:00
|
|
|
DEBUG("readDirectoryDB since update finished successfully\n");
|
|
|
|
readDirectoryDB();
|
2004-06-05 03:14:37 +02:00
|
|
|
playlistVersionChange();
|
2004-04-12 01:07:43 +02:00
|
|
|
directory_reReadDB = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
int updateInit(int fd, List * pathList)
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
|
|
|
if (directory_updatePid > 0) {
|
2006-07-30 10:47:50 +02:00
|
|
|
commandError(fd, ACK_ERROR_UPDATE_ALREADY, "already updating");
|
2004-04-11 03:53:25 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2004-04-11 20:27:12 +02:00
|
|
|
/* need to block CHLD signal, cause it can exit before we
|
2006-07-20 18:02:40 +02:00
|
|
|
even get a chance to assign directory_updatePID */
|
|
|
|
blockSignals();
|
2004-04-11 03:53:25 +02:00
|
|
|
directory_updatePid = fork();
|
2006-07-20 18:02:40 +02:00
|
|
|
if (directory_updatePid == 0) {
|
2006-07-14 21:11:11 +02:00
|
|
|
/* child */
|
|
|
|
int dbUpdated = 0;
|
|
|
|
|
2004-04-13 18:46:11 +02:00
|
|
|
unblockSignals();
|
2004-04-11 03:53:25 +02:00
|
|
|
|
2004-04-11 06:15:14 +02:00
|
|
|
finishSigHandlers();
|
2006-07-14 21:11:11 +02:00
|
|
|
closeAllListenSockets();
|
|
|
|
freeAllInterfaces();
|
|
|
|
finishPlaylist();
|
2004-04-11 03:53:25 +02:00
|
|
|
finishVolume();
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (pathList) {
|
|
|
|
ListNode *node = pathList->firstNode;
|
2004-04-11 19:37:47 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
while (node) {
|
|
|
|
switch (updatePath(node->key)) {
|
2006-07-14 21:11:11 +02:00
|
|
|
case 1:
|
2006-07-20 18:02:40 +02:00
|
|
|
dbUpdated = 1;
|
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
exit(DIRECTORY_UPDATE_EXIT_ERROR);
|
|
|
|
}
|
2004-04-11 19:37:47 +02:00
|
|
|
node = node->nextNode;
|
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
} else {
|
|
|
|
if ((dbUpdated = updateDirectory(mp3rootDirectory)) < 0) {
|
|
|
|
exit(DIRECTORY_UPDATE_EXIT_ERROR);
|
|
|
|
}
|
2004-04-11 19:37:47 +02:00
|
|
|
}
|
2004-04-16 02:41:56 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (!dbUpdated)
|
|
|
|
exit(DIRECTORY_UPDATE_EXIT_NOUPDATE);
|
2004-04-16 02:41:56 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
/* ignore signals since we don't want them to corrupt the db */
|
2004-04-13 21:24:05 +02:00
|
|
|
ignoreSignals();
|
2006-07-20 18:02:40 +02:00
|
|
|
if (writeDirectoryDB() < 0) {
|
2004-04-16 02:41:56 +02:00
|
|
|
exit(DIRECTORY_UPDATE_EXIT_ERROR);
|
2004-04-11 19:37:47 +02:00
|
|
|
}
|
2004-04-16 02:41:56 +02:00
|
|
|
exit(DIRECTORY_UPDATE_EXIT_UPDATE);
|
2006-07-20 18:02:40 +02:00
|
|
|
} else if (directory_updatePid < 0) {
|
2004-04-11 20:27:12 +02:00
|
|
|
unblockSignals();
|
2004-04-11 03:53:25 +02:00
|
|
|
ERROR("updateInit: Problems forking()'ing\n");
|
2006-07-30 05:43:38 +02:00
|
|
|
commandError(fd, ACK_ERROR_SYSTEM,
|
2006-07-30 10:47:50 +02:00
|
|
|
"problems trying to update");
|
2004-04-11 03:53:25 +02:00
|
|
|
directory_updatePid = 0;
|
|
|
|
return -1;
|
|
|
|
}
|
2004-04-11 20:27:12 +02:00
|
|
|
unblockSignals();
|
2004-04-11 03:53:25 +02:00
|
|
|
|
2004-04-11 05:12:00 +02:00
|
|
|
directory_updateJobId++;
|
2006-07-20 18:02:40 +02:00
|
|
|
if (directory_updateJobId > 1 << 15)
|
|
|
|
directory_updateJobId = 1;
|
2004-04-11 05:12:00 +02:00
|
|
|
DEBUG("updateInit: fork()'d update child for update job id %i\n",
|
2006-07-20 18:02:40 +02:00
|
|
|
(int)directory_updateJobId);
|
2006-07-30 05:43:38 +02:00
|
|
|
fdprintf(fd, "updating_db: %i\n", (int)directory_updateJobId);
|
2004-04-11 03:53:25 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static DirectoryStat *newDirectoryStat(struct stat *st)
|
|
|
|
{
|
|
|
|
DirectoryStat *ret = malloc(sizeof(DirectoryStat));
|
2004-06-23 05:33:35 +02:00
|
|
|
ret->inode = st->st_ino;
|
|
|
|
ret->device = st->st_dev;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static void freeDirectoryStatFromDirectory(Directory * dir)
|
|
|
|
{
|
|
|
|
if (dir->stat)
|
|
|
|
free(dir->stat);
|
2004-06-23 05:33:35 +02:00
|
|
|
dir->stat = NULL;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static Directory *newDirectory(char *dirname, Directory * parent)
|
|
|
|
{
|
|
|
|
Directory *directory;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
directory = malloc(sizeof(Directory));
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (dirname && strlen(dirname))
|
|
|
|
directory->path = strdup(dirname);
|
|
|
|
else
|
|
|
|
directory->path = NULL;
|
2004-02-24 00:41:20 +01:00
|
|
|
directory->subDirectories = newDirectoryList();
|
|
|
|
directory->songs = newSongList();
|
2004-06-23 05:33:35 +02:00
|
|
|
directory->stat = NULL;
|
|
|
|
directory->parent = parent;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
return directory;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static void freeDirectory(Directory * directory)
|
|
|
|
{
|
2004-02-24 00:41:20 +01:00
|
|
|
freeDirectoryList(directory->subDirectories);
|
|
|
|
freeSongList(directory->songs);
|
2006-07-20 18:02:40 +02:00
|
|
|
if (directory->path)
|
|
|
|
free(directory->path);
|
2004-06-23 05:33:35 +02:00
|
|
|
freeDirectoryStatFromDirectory(directory);
|
2004-02-24 00:41:20 +01:00
|
|
|
free(directory);
|
2004-11-12 18:38:52 +01:00
|
|
|
/* this resets last dir returned */
|
2006-07-20 18:02:40 +02:00
|
|
|
/*getDirectoryPath(NULL); */
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static DirectoryList *newDirectoryList()
|
|
|
|
{
|
|
|
|
return makeList((ListFreeDataFunc *) freeDirectory, 1);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static void freeDirectoryList(DirectoryList * directoryList)
|
|
|
|
{
|
2004-02-24 00:41:20 +01:00
|
|
|
freeList(directoryList);
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static void removeSongFromDirectory(Directory * directory, char *shortname)
|
|
|
|
{
|
|
|
|
void *song;
|
|
|
|
|
|
|
|
if (findInList(directory->songs, shortname, &song)) {
|
|
|
|
LOG("removing: %s\n", getSongUrl((Song *) song));
|
2004-11-11 03:36:25 +01:00
|
|
|
deleteFromList(directory->songs, shortname);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static void deleteEmptyDirectoriesInDirectory(Directory * directory)
|
|
|
|
{
|
|
|
|
ListNode *node = directory->subDirectories->firstNode;
|
|
|
|
ListNode *nextNode;
|
|
|
|
Directory *subDir;
|
2004-03-09 23:48:35 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
while (node) {
|
|
|
|
subDir = (Directory *) node->data;
|
2004-03-09 23:48:35 +01:00
|
|
|
deleteEmptyDirectoriesInDirectory(subDir);
|
|
|
|
nextNode = node->nextNode;
|
2006-07-20 18:02:40 +02:00
|
|
|
if (subDir->subDirectories->numberOfNodes == 0 &&
|
|
|
|
subDir->songs->numberOfNodes == 0) {
|
|
|
|
deleteNodeFromList(directory->subDirectories, node);
|
2004-03-09 23:48:35 +01:00
|
|
|
}
|
|
|
|
node = nextNode;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-04-16 02:41:56 +02:00
|
|
|
/* return values:
|
|
|
|
-1 -> error
|
|
|
|
0 -> no error, but nothing updated
|
|
|
|
1 -> no error, and stuff updated
|
|
|
|
*/
|
2006-07-20 18:02:40 +02:00
|
|
|
static int updateInDirectory(Directory * directory, char *shortname, char *name)
|
|
|
|
{
|
|
|
|
void *song;
|
|
|
|
void *subDir;
|
2004-06-22 02:55:23 +02:00
|
|
|
struct stat st;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (myStat(name, &st))
|
|
|
|
return -1;
|
2004-06-22 02:55:23 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (S_ISREG(st.st_mode) && hasMusicSuffix(name, 0)) {
|
|
|
|
if (0 == findInList(directory->songs, shortname, &song)) {
|
2004-11-11 03:36:25 +01:00
|
|
|
addToDirectory(directory, shortname, name);
|
2006-07-20 18:02:40 +02:00
|
|
|
return DIRECTORY_RETURN_UPDATE;
|
|
|
|
} else if (st.st_mtime != ((Song *) song)->mtime) {
|
|
|
|
LOG("updating %s\n", name);
|
|
|
|
if (updateSongInfo((Song *) song) < 0) {
|
|
|
|
removeSongFromDirectory(directory, shortname);
|
2004-03-10 10:55:54 +01:00
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
return 1;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
} else if (S_ISDIR(st.st_mode)) {
|
|
|
|
if (findInList
|
|
|
|
(directory->subDirectories, shortname, (void **)&subDir)) {
|
2004-06-23 06:20:35 +02:00
|
|
|
freeDirectoryStatFromDirectory(subDir);
|
2006-07-20 18:02:40 +02:00
|
|
|
((Directory *) subDir)->stat = newDirectoryStat(&st);
|
|
|
|
return updateDirectory((Directory *) subDir);
|
|
|
|
} else {
|
|
|
|
return addSubDirectoryToDirectory(directory, shortname,
|
|
|
|
name, &st);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-04-16 02:50:33 +02:00
|
|
|
/* return values:
|
|
|
|
-1 -> error
|
|
|
|
0 -> no error, but nothing removed
|
|
|
|
1 -> no error, and stuff removed
|
|
|
|
*/
|
2006-07-20 18:02:40 +02:00
|
|
|
static int removeDeletedFromDirectory(Directory * directory, DIR * dir)
|
|
|
|
{
|
2004-02-24 00:41:20 +01:00
|
|
|
char cwd[2];
|
2006-07-20 18:02:40 +02:00
|
|
|
struct dirent *ent;
|
|
|
|
char *dirname = getDirectoryPath(directory);
|
|
|
|
List *entList = makeList(free, 1);
|
|
|
|
void *name;
|
|
|
|
char *s;
|
|
|
|
char *utf8;
|
|
|
|
ListNode *node;
|
|
|
|
ListNode *tmpNode;
|
|
|
|
int ret = 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
cwd[0] = '.';
|
|
|
|
cwd[1] = '\0';
|
2006-07-20 18:02:40 +02:00
|
|
|
if (dirname == NULL)
|
|
|
|
dirname = cwd;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
while ((ent = readdir(dir))) {
|
|
|
|
if (ent->d_name[0] == '.')
|
|
|
|
continue; /* hide hidden stuff */
|
|
|
|
if (strchr(ent->d_name, '\n'))
|
|
|
|
continue;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-04-13 06:59:57 +02:00
|
|
|
utf8 = fsCharsetToUtf8(ent->d_name);
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (!utf8)
|
|
|
|
continue;
|
2004-04-13 06:59:57 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (directory->path) {
|
2004-11-11 05:34:26 +01:00
|
|
|
s = malloc(strlen(getDirectoryPath(directory))
|
2006-07-20 18:02:40 +02:00
|
|
|
+ strlen(utf8) + 2);
|
|
|
|
sprintf(s, "%s/%s", getDirectoryPath(directory), utf8);
|
|
|
|
} else
|
|
|
|
s = strdup(utf8);
|
2004-11-12 18:38:52 +01:00
|
|
|
insertInList(entList, utf8, s);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
node = directory->subDirectories->firstNode;
|
2006-07-20 18:02:40 +02:00
|
|
|
while (node) {
|
2004-02-24 00:41:20 +01:00
|
|
|
tmpNode = node->nextNode;
|
2006-07-20 18:02:40 +02:00
|
|
|
if (findInList(entList, node->key, &name)) {
|
|
|
|
if (!isDir((char *)name)) {
|
|
|
|
LOG("removing directory: %s\n", (char *)name);
|
2004-04-14 07:26:32 +02:00
|
|
|
deleteFromList(directory->subDirectories,
|
2006-07-20 18:02:40 +02:00
|
|
|
node->key);
|
|
|
|
ret = 1;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
} else {
|
2006-05-15 17:10:11 +02:00
|
|
|
LOG("removing directory: %s/%s\n",
|
2006-07-20 18:02:40 +02:00
|
|
|
getDirectoryPath(directory), node->key);
|
2004-11-11 05:34:26 +01:00
|
|
|
deleteFromList(directory->subDirectories, node->key);
|
2006-07-20 18:02:40 +02:00
|
|
|
ret = 1;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
node = tmpNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
node = directory->songs->firstNode;
|
2006-07-20 18:02:40 +02:00
|
|
|
while (node) {
|
2004-02-24 00:41:20 +01:00
|
|
|
tmpNode = node->nextNode;
|
2006-07-20 18:02:40 +02:00
|
|
|
if (findInList(entList, node->key, (void **)&name)) {
|
|
|
|
if (!isMusic(name, NULL, 0)) {
|
|
|
|
removeSongFromDirectory(directory, node->key);
|
|
|
|
ret = 1;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
} else {
|
|
|
|
removeSongFromDirectory(directory, node->key);
|
|
|
|
ret = 1;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
node = tmpNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
freeList(entList);
|
|
|
|
|
2004-04-16 02:41:56 +02:00
|
|
|
return ret;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static Directory *addDirectoryPathToDB(char *utf8path, char **shortname)
|
|
|
|
{
|
|
|
|
char *parent;
|
|
|
|
Directory *parentDirectory;
|
|
|
|
void *directory;
|
2004-04-14 07:26:32 +02:00
|
|
|
|
|
|
|
parent = strdup(parentPath(utf8path));
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (strlen(parent) == 0)
|
|
|
|
parentDirectory = (void *)mp3rootDirectory;
|
|
|
|
else
|
|
|
|
parentDirectory = addDirectoryPathToDB(parent, shortname);
|
2004-04-14 07:26:32 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (!parentDirectory) {
|
2004-06-23 07:08:01 +02:00
|
|
|
free(parent);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
*shortname = utf8path + strlen(parent);
|
|
|
|
while (*(*shortname) && *(*shortname) == '/')
|
|
|
|
(*shortname)++;
|
2004-04-14 07:26:32 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (!findInList
|
|
|
|
(parentDirectory->subDirectories, *shortname, &directory)) {
|
2004-06-23 07:08:01 +02:00
|
|
|
struct stat st;
|
2006-07-20 18:02:40 +02:00
|
|
|
if (myStat(utf8path, &st) < 0 ||
|
|
|
|
inodeFoundInParent(parentDirectory, st.st_ino, st.st_dev)) {
|
2004-06-23 07:08:01 +02:00
|
|
|
free(parent);
|
|
|
|
return NULL;
|
2006-07-20 18:02:40 +02:00
|
|
|
} else {
|
|
|
|
directory = newDirectory(utf8path, parentDirectory);
|
|
|
|
insertInList(parentDirectory->subDirectories,
|
|
|
|
*shortname, directory);
|
2004-06-23 07:08:01 +02:00
|
|
|
}
|
2004-04-14 07:26:32 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* if we're adding directory paths, make sure to delete filenames
|
2006-07-20 18:02:40 +02:00
|
|
|
with potentially the same name */
|
|
|
|
removeSongFromDirectory(parentDirectory, *shortname);
|
2004-04-14 07:26:32 +02:00
|
|
|
|
|
|
|
free(parent);
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
return (Directory *) directory;
|
2004-04-14 07:26:32 +02:00
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static Directory *addParentPathToDB(char *utf8path, char **shortname)
|
|
|
|
{
|
|
|
|
char *parent;
|
|
|
|
Directory *parentDirectory;
|
2004-04-14 07:26:32 +02:00
|
|
|
|
|
|
|
parent = strdup(parentPath(utf8path));
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (strlen(parent) == 0)
|
|
|
|
parentDirectory = (void *)mp3rootDirectory;
|
|
|
|
else
|
|
|
|
parentDirectory = addDirectoryPathToDB(parent, shortname);
|
2004-04-14 07:26:32 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (!parentDirectory) {
|
2004-06-23 07:08:01 +02:00
|
|
|
free(parent);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
*shortname = utf8path + strlen(parent);
|
|
|
|
while (*(*shortname) && *(*shortname) == '/')
|
|
|
|
(*shortname)++;
|
2004-04-14 07:26:32 +02:00
|
|
|
|
|
|
|
free(parent);
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
return (Directory *) parentDirectory;
|
2004-04-14 07:26:32 +02:00
|
|
|
}
|
|
|
|
|
2004-04-16 02:41:56 +02:00
|
|
|
/* return values:
|
|
|
|
-1 -> error
|
|
|
|
0 -> no error, but nothing updated
|
|
|
|
1 -> no error, and stuff updated
|
|
|
|
*/
|
2006-07-20 18:02:40 +02:00
|
|
|
static int updatePath(char *utf8path)
|
|
|
|
{
|
|
|
|
Directory *directory;
|
|
|
|
Directory *parentDirectory;
|
|
|
|
Song *song;
|
|
|
|
char *shortname;
|
|
|
|
char *path = sanitizePathDup(utf8path);
|
|
|
|
time_t mtime;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (NULL == path)
|
|
|
|
return -1;
|
2004-04-14 04:35:29 +02:00
|
|
|
|
2004-04-14 04:55:19 +02:00
|
|
|
/* if path is in the DB try to update it, or else delete it */
|
2006-07-20 18:02:40 +02:00
|
|
|
if ((directory = getDirectoryDetails(path, &shortname))) {
|
2004-06-23 05:33:35 +02:00
|
|
|
parentDirectory = directory->parent;
|
|
|
|
|
2004-04-14 07:26:32 +02:00
|
|
|
/* if this update directory is successfull, we are done */
|
2006-07-20 18:02:40 +02:00
|
|
|
if ((ret = updateDirectory(directory)) >= 0) {
|
2004-04-14 07:26:32 +02:00
|
|
|
free(path);
|
|
|
|
sortDirectory(directory);
|
2004-04-16 02:41:56 +02:00
|
|
|
return ret;
|
2004-04-14 07:26:32 +02:00
|
|
|
}
|
|
|
|
/* we don't want to delete the root directory */
|
2006-07-20 18:02:40 +02:00
|
|
|
else if (directory == mp3rootDirectory) {
|
2004-04-14 07:26:32 +02:00
|
|
|
free(path);
|
2004-04-16 02:41:56 +02:00
|
|
|
return 0;
|
2004-04-14 07:26:32 +02:00
|
|
|
}
|
|
|
|
/* if updateDirectory fials, means we should delete it */
|
|
|
|
else {
|
2006-07-20 18:02:40 +02:00
|
|
|
LOG("removing directory: %s\n", path);
|
2004-04-14 04:35:29 +02:00
|
|
|
deleteFromList(parentDirectory->subDirectories,
|
2006-07-20 18:02:40 +02:00
|
|
|
shortname);
|
|
|
|
ret = 1;
|
|
|
|
/* don't return, path maybe a song now */
|
2004-04-14 04:35:29 +02:00
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
} else if ((song = getSongDetails(path, &shortname, &parentDirectory))) {
|
|
|
|
if (!parentDirectory->stat
|
|
|
|
&& statDirectory(parentDirectory) < 0) {
|
2004-06-23 06:20:35 +02:00
|
|
|
free(path);
|
|
|
|
return 0;
|
|
|
|
}
|
2004-04-14 07:26:32 +02:00
|
|
|
/* if this song update is successfull, we are done */
|
2006-07-20 18:02:40 +02:00
|
|
|
else if (0 == inodeFoundInParent(parentDirectory->parent,
|
|
|
|
parentDirectory->stat->inode,
|
|
|
|
parentDirectory->stat->device)
|
|
|
|
&& song && isMusic(getSongUrl(song), &mtime, 0)) {
|
2004-04-14 07:26:32 +02:00
|
|
|
free(path);
|
2006-07-20 18:02:40 +02:00
|
|
|
if (song->mtime == mtime)
|
|
|
|
return 0;
|
|
|
|
else if (updateSongInfo(song) == 0)
|
|
|
|
return 1;
|
|
|
|
else {
|
|
|
|
removeSongFromDirectory(parentDirectory,
|
|
|
|
shortname);
|
|
|
|
return 1;
|
|
|
|
}
|
2004-04-14 04:55:19 +02:00
|
|
|
}
|
2004-04-14 07:26:32 +02:00
|
|
|
/* if updateDirectory fials, means we should delete it */
|
2004-04-16 02:41:56 +02:00
|
|
|
else {
|
2006-07-20 18:02:40 +02:00
|
|
|
removeSongFromDirectory(parentDirectory, shortname);
|
|
|
|
ret = 1;
|
|
|
|
/* don't return, path maybe a directory now */
|
|
|
|
}
|
2004-04-14 04:55:19 +02:00
|
|
|
}
|
2004-04-14 07:26:32 +02:00
|
|
|
|
|
|
|
/* path not found in the db, see if it actually exists on the fs.
|
|
|
|
* Also, if by chance a directory was replaced by a file of the same
|
2006-07-20 18:02:40 +02:00
|
|
|
* name or vice versa, we need to add it to the db
|
|
|
|
*/
|
|
|
|
if (isDir(path) || isMusic(path, NULL, 0)) {
|
|
|
|
parentDirectory = addParentPathToDB(path, &shortname);
|
|
|
|
if (!parentDirectory || (!parentDirectory->stat &&
|
|
|
|
statDirectory(parentDirectory) < 0)) {
|
|
|
|
} else if (0 == inodeFoundInParent(parentDirectory->parent,
|
|
|
|
parentDirectory->stat->inode,
|
|
|
|
parentDirectory->stat->
|
|
|
|
device)
|
|
|
|
&& addToDirectory(parentDirectory, shortname, path)
|
|
|
|
> 0) {
|
2004-06-23 06:20:35 +02:00
|
|
|
ret = 1;
|
|
|
|
}
|
2004-04-14 04:55:19 +02:00
|
|
|
}
|
2004-04-14 07:26:32 +02:00
|
|
|
|
|
|
|
free(path);
|
2004-04-16 02:41:56 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
return ret;
|
2004-04-14 04:35:29 +02:00
|
|
|
}
|
|
|
|
|
2004-04-16 02:41:56 +02:00
|
|
|
/* return values:
|
|
|
|
-1 -> error
|
|
|
|
0 -> no error, but nothing updated
|
|
|
|
1 -> no error, and stuff updated
|
|
|
|
*/
|
2006-07-20 18:02:40 +02:00
|
|
|
static int updateDirectory(Directory * directory)
|
|
|
|
{
|
|
|
|
DIR *dir;
|
2004-02-24 00:41:20 +01:00
|
|
|
char cwd[2];
|
2006-07-20 18:02:40 +02:00
|
|
|
struct dirent *ent;
|
|
|
|
char *s;
|
|
|
|
char *utf8;
|
|
|
|
char *dirname = getDirectoryPath(directory);
|
|
|
|
int ret = 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-06-23 06:20:35 +02:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
if (!directory->stat && statDirectory(directory) < 0) {
|
2004-06-23 06:20:35 +02:00
|
|
|
return -1;
|
2006-07-20 18:02:40 +02:00
|
|
|
} else if (inodeFoundInParent(directory->parent,
|
|
|
|
directory->stat->inode,
|
|
|
|
directory->stat->device)) {
|
2004-06-23 06:20:35 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
cwd[0] = '.';
|
|
|
|
cwd[1] = '\0';
|
2006-07-20 18:02:40 +02:00
|
|
|
if (dirname == NULL)
|
|
|
|
dirname = cwd;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if ((dir = opendir(rmp2amp(utf8ToFsCharset(dirname)))) == NULL)
|
|
|
|
return -1;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (removeDeletedFromDirectory(directory, dir) > 0)
|
|
|
|
ret = 1;
|
2004-06-22 03:04:13 +02:00
|
|
|
|
|
|
|
rewinddir(dir);
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
while ((ent = readdir(dir))) {
|
|
|
|
if (ent->d_name[0] == '.')
|
|
|
|
continue; /* hide hidden stuff */
|
|
|
|
if (strchr(ent->d_name, '\n'))
|
|
|
|
continue;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-04-13 06:59:57 +02:00
|
|
|
utf8 = fsCharsetToUtf8(ent->d_name);
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (!utf8)
|
|
|
|
continue;
|
2004-04-13 06:59:57 +02:00
|
|
|
|
|
|
|
utf8 = strdup(utf8);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (directory->path) {
|
|
|
|
s = malloc(strlen(getDirectoryPath(directory)) +
|
|
|
|
strlen(utf8) + 2);
|
|
|
|
sprintf(s, "%s/%s", getDirectoryPath(directory), utf8);
|
|
|
|
} else
|
|
|
|
s = strdup(utf8);
|
|
|
|
if (updateInDirectory(directory, utf8, s) > 0)
|
|
|
|
ret = 1;
|
2004-02-24 00:41:20 +01:00
|
|
|
free(utf8);
|
|
|
|
free(s);
|
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
closedir(dir);
|
|
|
|
|
2004-04-16 02:41:56 +02:00
|
|
|
return ret;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2004-04-17 01:49:48 +02:00
|
|
|
/* return values:
|
|
|
|
-1 -> error
|
|
|
|
0 -> no error, but nothing found
|
|
|
|
1 -> no error, and stuff found
|
|
|
|
*/
|
2006-07-20 18:02:40 +02:00
|
|
|
static int exploreDirectory(Directory * directory)
|
|
|
|
{
|
|
|
|
DIR *dir;
|
2004-02-24 00:41:20 +01:00
|
|
|
char cwd[2];
|
2006-07-20 18:02:40 +02:00
|
|
|
struct dirent *ent;
|
|
|
|
char *s;
|
|
|
|
char *utf8;
|
|
|
|
char *dirname = getDirectoryPath(directory);
|
|
|
|
int ret = 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
cwd[0] = '.';
|
|
|
|
cwd[1] = '\0';
|
2006-07-20 18:02:40 +02:00
|
|
|
if (dirname == NULL)
|
|
|
|
dirname = cwd;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
DEBUG("explore: attempting to opendir: %s\n", dirname);
|
|
|
|
if ((dir = opendir(rmp2amp(utf8ToFsCharset(dirname)))) == NULL)
|
|
|
|
return -1;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
DEBUG("explore: %s\n", dirname);
|
|
|
|
while ((ent = readdir(dir))) {
|
|
|
|
if (ent->d_name[0] == '.')
|
|
|
|
continue; /* hide hidden stuff */
|
|
|
|
if (strchr(ent->d_name, '\n'))
|
|
|
|
continue;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-04-13 06:59:57 +02:00
|
|
|
utf8 = fsCharsetToUtf8(ent->d_name);
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (!utf8)
|
|
|
|
continue;
|
2004-04-13 06:59:57 +02:00
|
|
|
|
|
|
|
utf8 = strdup(utf8);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
DEBUG("explore: found: %s (%s)\n", ent->d_name, utf8);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (directory->path) {
|
|
|
|
s = malloc(strlen(getDirectoryPath(directory)) +
|
|
|
|
strlen(utf8) + 2);
|
|
|
|
sprintf(s, "%s/%s", getDirectoryPath(directory), utf8);
|
|
|
|
} else
|
|
|
|
s = strdup(utf8);
|
|
|
|
if (addToDirectory(directory, utf8, s) > 0)
|
|
|
|
ret = 1;
|
2004-02-24 00:41:20 +01:00
|
|
|
free(utf8);
|
|
|
|
free(s);
|
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
closedir(dir);
|
|
|
|
|
2004-04-17 01:49:48 +02:00
|
|
|
return ret;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static int statDirectory(Directory * dir)
|
|
|
|
{
|
2004-06-23 05:33:35 +02:00
|
|
|
struct stat st;
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (myStat(getDirectoryPath(dir) ? getDirectoryPath(dir) : "", &st) < 0) {
|
2004-11-11 05:34:26 +01:00
|
|
|
return -1;
|
|
|
|
}
|
2004-06-23 05:33:35 +02:00
|
|
|
|
|
|
|
dir->stat = newDirectoryStat(&st);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static int inodeFoundInParent(Directory * parent, ino_t inode, dev_t device)
|
|
|
|
{
|
|
|
|
while (parent) {
|
|
|
|
if (!parent->stat) {
|
|
|
|
if (statDirectory(parent) < 0)
|
|
|
|
return -1;
|
2004-06-23 05:33:35 +02:00
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
if (parent->stat->inode == inode &&
|
|
|
|
parent->stat->device == device) {
|
2004-06-23 06:20:35 +02:00
|
|
|
DEBUG("recursive directory found\n");
|
2004-06-23 05:33:35 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
parent = parent->parent;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static int addSubDirectoryToDirectory(Directory * directory, char *shortname,
|
|
|
|
char *name, struct stat *st)
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
Directory *subDirectory;
|
2004-06-23 05:33:35 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (inodeFoundInParent(directory, st->st_ino, st->st_dev))
|
|
|
|
return 0;
|
2004-06-23 05:33:35 +02:00
|
|
|
|
2004-11-12 18:38:52 +01:00
|
|
|
subDirectory = newDirectory(name, directory);
|
2004-06-23 05:33:35 +02:00
|
|
|
subDirectory->stat = newDirectoryStat(st);
|
2004-04-17 01:49:48 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (exploreDirectory(subDirectory) < 1) {
|
|
|
|
freeDirectory(subDirectory);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
insertInList(directory->subDirectories, shortname, subDirectory);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-04-17 01:49:48 +02:00
|
|
|
return 1;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static int addToDirectory(Directory * directory, char *shortname, char *name)
|
|
|
|
{
|
2004-06-22 02:55:23 +02:00
|
|
|
struct stat st;
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (myStat(name, &st)) {
|
2005-03-06 20:00:58 +01:00
|
|
|
DEBUG("failed to stat %s: %s\n", name, strerror(errno));
|
|
|
|
return -1;
|
|
|
|
}
|
2004-06-22 02:55:23 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (S_ISREG(st.st_mode) && hasMusicSuffix(name, 0)) {
|
|
|
|
Song *song;
|
2004-11-11 03:36:25 +01:00
|
|
|
song = addSongToList(directory->songs, shortname, name,
|
2006-07-20 18:02:40 +02:00
|
|
|
SONG_TYPE_FILE, directory);
|
|
|
|
if (!song)
|
|
|
|
return -1;
|
2004-11-11 03:36:25 +01:00
|
|
|
LOG("added %s\n", name);
|
2004-04-17 01:49:48 +02:00
|
|
|
return 1;
|
2006-07-20 18:02:40 +02:00
|
|
|
} else if (S_ISDIR(st.st_mode)) {
|
2004-06-23 05:33:35 +02:00
|
|
|
return addSubDirectoryToDirectory(directory, shortname, name,
|
2006-07-20 18:02:40 +02:00
|
|
|
&st);
|
2004-06-22 02:55:23 +02:00
|
|
|
}
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
DEBUG("addToDirectory: %s is not a directory or music\n", name);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
void closeMp3Directory()
|
|
|
|
{
|
2004-02-24 00:41:20 +01:00
|
|
|
freeDirectory(mp3rootDirectory);
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static Directory *findSubDirectory(Directory * directory, char *name)
|
|
|
|
{
|
|
|
|
void *subDirectory;
|
|
|
|
char *dup = strdup(name);
|
|
|
|
char *key;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
key = strtok(dup, "/");
|
|
|
|
if (!key) {
|
2004-02-24 00:41:20 +01:00
|
|
|
free(dup);
|
|
|
|
return NULL;
|
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
|
|
|
|
if (findInList(directory->subDirectories, key, &subDirectory)) {
|
2004-02-24 00:41:20 +01:00
|
|
|
free(dup);
|
2006-07-20 18:02:40 +02:00
|
|
|
return (Directory *) subDirectory;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
free(dup);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static Directory *getSubDirectory(Directory * directory, char *name,
|
|
|
|
char **shortname)
|
2004-04-14 04:35:29 +02:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
Directory *subDirectory;
|
2004-02-24 00:41:20 +01:00
|
|
|
int len;
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (name == NULL || name[0] == '\0' || strcmp(name, "/") == 0) {
|
2004-02-24 00:41:20 +01:00
|
|
|
return directory;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if ((subDirectory = findSubDirectory(directory, name)) == NULL)
|
|
|
|
return NULL;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-04-14 04:35:29 +02:00
|
|
|
*shortname = name;
|
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
len = 0;
|
2006-07-20 18:02:40 +02:00
|
|
|
while (name[len] != '/' && name[len] != '\0')
|
|
|
|
len++;
|
|
|
|
while (name[len] == '/')
|
|
|
|
len++;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
return getSubDirectory(subDirectory, &(name[len]), shortname);
|
2004-04-14 04:35:29 +02:00
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static Directory *getDirectoryDetails(char *name, char **shortname)
|
|
|
|
{
|
2004-04-14 04:35:29 +02:00
|
|
|
*shortname = NULL;
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
return getSubDirectory(mp3rootDirectory, name, shortname);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static Directory *getDirectory(char *name)
|
|
|
|
{
|
|
|
|
char *shortname;
|
2004-04-14 04:35:29 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
return getSubDirectory(mp3rootDirectory, name, &shortname);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
static int printDirectoryList(int fd, DirectoryList * directoryList)
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
|
|
|
ListNode *node = directoryList->firstNode;
|
|
|
|
Directory *directory;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
while (node != NULL) {
|
|
|
|
directory = (Directory *) node->data;
|
2006-07-30 05:43:38 +02:00
|
|
|
fdprintf(fd, "%s%s\n", DIRECTORY_DIR,
|
|
|
|
getDirectoryPath(directory));
|
2004-02-24 00:41:20 +01:00
|
|
|
node = node->nextNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
int printDirectoryInfo(int fd, char *name)
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
|
|
|
Directory *directory;
|
|
|
|
|
|
|
|
if ((directory = getDirectory(name)) == NULL) {
|
2006-07-30 10:47:50 +02:00
|
|
|
commandError(fd, ACK_ERROR_NO_EXIST, "directory not found");
|
2004-02-24 00:41:20 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
printDirectoryList(fd, directory->subDirectories);
|
|
|
|
printSongInfoFromList(fd, directory->songs);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static void writeDirectoryInfo(FILE * fp, Directory * directory)
|
|
|
|
{
|
|
|
|
ListNode *node = (directory->subDirectories)->firstNode;
|
|
|
|
Directory *subDirectory;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (directory->path) {
|
2006-07-31 01:32:39 +02:00
|
|
|
fprintf(fp, "%s%s\n", DIRECTORY_BEGIN,
|
2006-07-20 18:02:40 +02:00
|
|
|
getDirectoryPath(directory));
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
|
|
|
|
while (node != NULL) {
|
|
|
|
subDirectory = (Directory *) node->data;
|
2006-07-31 01:32:39 +02:00
|
|
|
fprintf(fp, "%s%s\n", DIRECTORY_DIR, node->key);
|
2006-07-20 18:02:40 +02:00
|
|
|
writeDirectoryInfo(fp, subDirectory);
|
2004-02-24 00:41:20 +01:00
|
|
|
node = node->nextNode;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
writeSongInfoFromList(fp, directory->songs);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (directory->path) {
|
2006-07-31 01:32:39 +02:00
|
|
|
fprintf(fp, "%s%s\n", DIRECTORY_END,
|
2006-07-20 18:02:40 +02:00
|
|
|
getDirectoryPath(directory));
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static void readDirectoryInfo(FILE * fp, Directory * directory)
|
|
|
|
{
|
|
|
|
char buffer[MAXPATHLEN * 2];
|
|
|
|
int bufferSize = MAXPATHLEN * 2;
|
|
|
|
char *key;
|
|
|
|
Directory *subDirectory;
|
2004-04-10 19:56:01 +02:00
|
|
|
int strcmpRet;
|
2006-07-20 18:02:40 +02:00
|
|
|
char *name;
|
|
|
|
ListNode *nextDirNode = directory->subDirectories->firstNode;
|
|
|
|
ListNode *nodeTemp;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
while (myFgets(buffer, bufferSize, fp)
|
|
|
|
&& 0 != strncmp(DIRECTORY_END, buffer, strlen(DIRECTORY_END))) {
|
|
|
|
if (0 == strncmp(DIRECTORY_DIR, buffer, strlen(DIRECTORY_DIR))) {
|
2004-02-24 00:41:20 +01:00
|
|
|
key = strdup(&(buffer[strlen(DIRECTORY_DIR)]));
|
2006-08-01 06:18:41 +02:00
|
|
|
if (!myFgets(buffer, bufferSize, fp)) {
|
2006-07-20 18:02:40 +02:00
|
|
|
ERROR("Error reading db, fgets\n");
|
2004-04-03 01:34:16 +02:00
|
|
|
exit(EXIT_FAILURE);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
/* for compatibility with db's prior to 0.11 */
|
|
|
|
if (0 == strncmp(DIRECTORY_MTIME, buffer,
|
|
|
|
strlen(DIRECTORY_MTIME))) {
|
2006-08-01 06:18:41 +02:00
|
|
|
if (!myFgets(buffer, bufferSize, fp)) {
|
2006-07-20 18:02:40 +02:00
|
|
|
ERROR("Error reading db, fgets\n");
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (strncmp
|
|
|
|
(DIRECTORY_BEGIN, buffer,
|
|
|
|
strlen(DIRECTORY_BEGIN))) {
|
|
|
|
ERROR("Error reading db at line: %s\n", buffer);
|
2004-04-03 01:34:16 +02:00
|
|
|
exit(EXIT_FAILURE);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2004-11-12 18:38:52 +01:00
|
|
|
name = strdup(&(buffer[strlen(DIRECTORY_BEGIN)]));
|
2004-04-10 19:56:01 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
while (nextDirNode && (strcmpRet =
|
|
|
|
strcmp(key,
|
|
|
|
nextDirNode->key)) > 0) {
|
2004-04-10 19:56:01 +02:00
|
|
|
nodeTemp = nextDirNode->nextNode;
|
|
|
|
deleteNodeFromList(directory->subDirectories,
|
2006-07-20 18:02:40 +02:00
|
|
|
nextDirNode);
|
2004-04-10 19:56:01 +02:00
|
|
|
nextDirNode = nodeTemp;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (NULL == nextDirNode) {
|
2004-11-12 18:38:52 +01:00
|
|
|
subDirectory = newDirectory(name, directory);
|
2004-11-11 05:34:26 +01:00
|
|
|
insertInList(directory->subDirectories,
|
2006-07-20 18:02:40 +02:00
|
|
|
key, (void *)subDirectory);
|
|
|
|
} else if (strcmpRet == 0) {
|
|
|
|
subDirectory = (Directory *) nextDirNode->data;
|
2004-04-10 19:56:01 +02:00
|
|
|
nextDirNode = nextDirNode->nextNode;
|
2006-07-20 18:02:40 +02:00
|
|
|
} else {
|
2004-11-12 18:38:52 +01:00
|
|
|
subDirectory = newDirectory(name, directory);
|
2006-07-20 18:02:40 +02:00
|
|
|
insertInListBeforeNode(directory->
|
|
|
|
subDirectories,
|
|
|
|
nextDirNode, -1, key,
|
|
|
|
(void *)subDirectory);
|
2004-04-10 19:56:01 +02:00
|
|
|
}
|
|
|
|
|
2005-01-29 23:30:18 +01:00
|
|
|
free(name);
|
2004-02-24 00:41:20 +01:00
|
|
|
free(key);
|
2006-07-20 18:02:40 +02:00
|
|
|
readDirectoryInfo(fp, subDirectory);
|
|
|
|
} else if (0 == strncmp(SONG_BEGIN, buffer, strlen(SONG_BEGIN))) {
|
2004-11-11 03:36:25 +01:00
|
|
|
readSongInfoIntoList(fp, directory->songs, directory);
|
2006-07-20 18:02:40 +02:00
|
|
|
} else {
|
|
|
|
ERROR("Unknown line in db: %s\n", buffer);
|
2004-04-03 01:34:16 +02:00
|
|
|
exit(EXIT_FAILURE);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
}
|
2004-04-10 19:56:01 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
while (nextDirNode) {
|
2004-04-10 19:56:01 +02:00
|
|
|
nodeTemp = nextDirNode->nextNode;
|
2006-07-20 18:02:40 +02:00
|
|
|
deleteNodeFromList(directory->subDirectories, nextDirNode);
|
2004-04-10 19:56:01 +02:00
|
|
|
nextDirNode = nodeTemp;
|
|
|
|
}
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static void sortDirectory(Directory * directory)
|
|
|
|
{
|
|
|
|
ListNode *node = directory->subDirectories->firstNode;
|
|
|
|
Directory *subDir;
|
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
sortList(directory->subDirectories);
|
|
|
|
sortList(directory->songs);
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
while (node != NULL) {
|
|
|
|
subDir = (Directory *) node->data;
|
2004-02-24 00:41:20 +01:00
|
|
|
sortDirectory(subDir);
|
|
|
|
node = node->nextNode;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
int checkDirectoryDB()
|
|
|
|
{
|
2006-07-24 01:35:35 +02:00
|
|
|
struct stat st;
|
2006-07-24 01:10:31 +02:00
|
|
|
char *dbFile;
|
|
|
|
char *dirPath;
|
|
|
|
char *dbPath;
|
|
|
|
|
|
|
|
dbFile = getDbFile();
|
|
|
|
|
|
|
|
/* Check if the file exists */
|
2006-07-20 18:02:40 +02:00
|
|
|
if (access(dbFile, F_OK)) {
|
2006-07-24 01:10:31 +02:00
|
|
|
/* If the file doesn't exist, we can't check if we can write
|
|
|
|
* it, so we are going to try to get the directory path, and
|
|
|
|
* see if we can write a file in that */
|
2006-07-24 01:35:35 +02:00
|
|
|
dbPath = strdup(dbFile);
|
2006-06-07 23:00:36 +02:00
|
|
|
dirPath = dirname(dbPath);
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2006-07-24 01:42:16 +02:00
|
|
|
/* Check that the parent part of the path is a directory */
|
|
|
|
if (stat(dirPath, &st) < 0) {
|
|
|
|
ERROR("Couldn't stat parent directory of db file "
|
|
|
|
"\"%s\": %s\n", dbFile, strerror(errno));
|
|
|
|
free(dbPath);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!S_ISDIR(st.st_mode)) {
|
|
|
|
ERROR("Couldn't create db file \"%s\" because the "
|
|
|
|
"parent path is not a directory\n", dbFile);
|
|
|
|
free(dbPath);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2006-07-24 01:10:31 +02:00
|
|
|
/* Check if we can write to the directory */
|
2006-07-20 18:02:40 +02:00
|
|
|
if (access(dirPath, R_OK | W_OK)) {
|
2006-07-24 01:10:31 +02:00
|
|
|
ERROR("Can't create db file in \"%s\": %s\n", dirPath,
|
2006-07-20 18:02:40 +02:00
|
|
|
strerror(errno));
|
2006-06-07 23:00:36 +02:00
|
|
|
free(dbPath);
|
|
|
|
return -1;
|
2006-05-08 23:03:47 +02:00
|
|
|
|
2006-06-07 23:00:36 +02:00
|
|
|
}
|
2006-07-24 01:10:31 +02:00
|
|
|
|
2006-06-07 23:00:36 +02:00
|
|
|
free(dbPath);
|
|
|
|
return 0;
|
|
|
|
}
|
2006-07-24 01:10:31 +02:00
|
|
|
|
2006-07-24 01:35:35 +02:00
|
|
|
/* Path exists, now check if it's a regular file */
|
|
|
|
if (stat(dbFile, &st) < 0) {
|
2006-07-24 01:42:16 +02:00
|
|
|
ERROR("Couldn't stat db file \"%s\": %s\n", dbFile,
|
2006-07-24 01:35:35 +02:00
|
|
|
strerror(errno));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!S_ISREG(st.st_mode)) {
|
|
|
|
ERROR("db file \"%s\" is not a regular file\n", dbFile);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* And check that we can write to it */
|
2006-07-20 18:02:40 +02:00
|
|
|
if (access(dbFile, R_OK | W_OK)) {
|
2006-07-24 01:10:31 +02:00
|
|
|
ERROR("Can't open db file \"%s\" for reading/writing: %s\n",
|
2006-07-20 18:02:40 +02:00
|
|
|
dbFile, strerror(errno));
|
2006-05-08 23:03:47 +02:00
|
|
|
return -1;
|
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2006-05-08 23:03:47 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
int writeDirectoryDB()
|
|
|
|
{
|
|
|
|
FILE *fp;
|
|
|
|
char *dbFile = getDbFile();
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-11-14 00:22:22 +01:00
|
|
|
DEBUG("removing empty directories from DB\n");
|
2004-03-09 23:48:35 +01:00
|
|
|
deleteEmptyDirectoriesInDirectory(mp3rootDirectory);
|
2004-11-14 00:22:22 +01:00
|
|
|
|
|
|
|
DEBUG("sorting DB\n");
|
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
sortDirectory(mp3rootDirectory);
|
|
|
|
|
2004-11-14 00:22:22 +01:00
|
|
|
DEBUG("writing DB\n");
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
while (!(fp = fopen(dbFile, "w")) && errno == EINTR) ;
|
|
|
|
if (!fp) {
|
2005-03-06 20:00:58 +01:00
|
|
|
ERROR("unable to write to db file \"%s\": %s\n",
|
2006-07-20 18:02:40 +02:00
|
|
|
dbFile, strerror(errno));
|
2005-03-06 20:00:58 +01:00
|
|
|
return -1;
|
|
|
|
}
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
/* block signals when writing the db so we don't get a corrupted db */
|
2006-07-31 01:32:39 +02:00
|
|
|
fprintf(fp, "%s\n", DIRECTORY_INFO_BEGIN);
|
|
|
|
fprintf(fp, "%s%s\n", DIRECTORY_MPD_VERSION, VERSION);
|
|
|
|
fprintf(fp, "%s%s\n", DIRECTORY_FS_CHARSET, getFsCharset());
|
|
|
|
fprintf(fp, "%s\n", DIRECTORY_INFO_END);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
writeDirectoryInfo(fp, mp3rootDirectory);
|
2004-04-13 19:08:31 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
while (fclose(fp) && errno == EINTR) ;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
int readDirectoryDB()
|
|
|
|
{
|
|
|
|
FILE *fp = NULL;
|
|
|
|
char *dbFile = getDbFile();
|
|
|
|
struct stat st;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (!mp3rootDirectory)
|
|
|
|
mp3rootDirectory = newDirectory(NULL, NULL);
|
|
|
|
while (!(fp = fopen(dbFile, "r")) && errno == EINTR) ;
|
|
|
|
if (fp == NULL) {
|
|
|
|
ERROR("unable open db file \"%s\": %s\n",
|
|
|
|
dbFile, strerror(errno));
|
2005-03-06 20:00:58 +01:00
|
|
|
return -1;
|
|
|
|
}
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
/* get initial info */
|
|
|
|
{
|
|
|
|
char buffer[100];
|
|
|
|
int bufferSize = 100;
|
|
|
|
int foundFsCharset = 0;
|
|
|
|
int foundVersion = 0;
|
|
|
|
|
2006-08-01 06:18:41 +02:00
|
|
|
if (!myFgets(buffer, bufferSize, fp)) {
|
2004-04-16 02:41:56 +02:00
|
|
|
ERROR("Error reading db, fgets\n");
|
2004-04-03 01:34:16 +02:00
|
|
|
exit(EXIT_FAILURE);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
if (0 == strcmp(DIRECTORY_INFO_BEGIN, buffer)) {
|
|
|
|
while (myFgets(buffer, bufferSize, fp) &&
|
|
|
|
0 != strcmp(DIRECTORY_INFO_END, buffer)) {
|
|
|
|
if (0 == strncmp(DIRECTORY_MPD_VERSION, buffer,
|
|
|
|
strlen(DIRECTORY_MPD_VERSION)))
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
if (foundVersion) {
|
2004-02-24 00:41:20 +01:00
|
|
|
ERROR("already found "
|
2006-07-20 18:02:40 +02:00
|
|
|
"version in db\n");
|
2004-04-03 01:34:16 +02:00
|
|
|
exit(EXIT_FAILURE);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
foundVersion = 1;
|
2006-07-20 18:02:40 +02:00
|
|
|
} else if (0 ==
|
|
|
|
strncmp(DIRECTORY_FS_CHARSET, buffer,
|
|
|
|
strlen
|
|
|
|
(DIRECTORY_FS_CHARSET))) {
|
|
|
|
char *fsCharset;
|
|
|
|
char *tempCharset;
|
|
|
|
|
|
|
|
if (foundFsCharset) {
|
2004-06-12 04:06:16 +02:00
|
|
|
WARNING("already found "
|
2004-02-24 00:41:20 +01:00
|
|
|
"fs charset in db\n");
|
2004-04-03 01:34:16 +02:00
|
|
|
exit(EXIT_FAILURE);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
foundFsCharset = 1;
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
fsCharset =
|
|
|
|
&(buffer
|
|
|
|
[strlen(DIRECTORY_FS_CHARSET)]);
|
|
|
|
if ((tempCharset =
|
|
|
|
getConfigParamValue
|
|
|
|
(CONF_FS_CHARSET))
|
|
|
|
&& strcmp(fsCharset, tempCharset)) {
|
2004-06-12 04:06:16 +02:00
|
|
|
WARNING("Using \"%s\" for the "
|
2004-02-24 00:41:20 +01:00
|
|
|
"filesystem charset "
|
|
|
|
"instead of \"%s\"\n",
|
2006-07-20 18:02:40 +02:00
|
|
|
fsCharset, tempCharset);
|
2004-06-12 04:06:16 +02:00
|
|
|
WARNING("maybe you need to "
|
2004-02-24 00:41:20 +01:00
|
|
|
"recreate the db?\n");
|
|
|
|
setFsCharset(fsCharset);
|
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
} else {
|
|
|
|
ERROR
|
|
|
|
("directory: unknown line in db info: %s\n",
|
|
|
|
buffer);
|
2004-04-03 01:34:16 +02:00
|
|
|
exit(EXIT_FAILURE);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
} else {
|
2004-02-24 00:41:20 +01:00
|
|
|
ERROR("db info not found in db file\n");
|
|
|
|
ERROR("you should recreate the db using --create-db\n");
|
2006-07-20 18:02:40 +02:00
|
|
|
fseek(fp, 0, SEEK_SET);
|
2006-07-24 01:35:35 +02:00
|
|
|
return -1;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-11-14 00:22:22 +01:00
|
|
|
DEBUG("reading DB\n");
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
readDirectoryInfo(fp, mp3rootDirectory);
|
|
|
|
while (fclose(fp) && errno == EINTR) ;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
stats.numberOfSongs = countSongsIn(STDERR_FILENO, NULL);
|
|
|
|
stats.dbPlayTime = sumSongTimesIn(STDERR_FILENO, NULL);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (stat(dbFile, &st) == 0)
|
|
|
|
directory_dbModTime = st.st_mtime;
|
2004-05-17 13:56:14 +02:00
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
void updateMp3Directory()
|
|
|
|
{
|
|
|
|
switch (updateDirectory(mp3rootDirectory)) {
|
|
|
|
case 0:
|
|
|
|
/* nothing updated */
|
|
|
|
return;
|
|
|
|
case 1:
|
|
|
|
if (writeDirectoryDB() < 0) {
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* something was updated and db should be written */
|
2004-02-24 00:41:20 +01:00
|
|
|
ERROR("problems updating music db\n");
|
2006-07-20 18:02:40 +02:00
|
|
|
exit(EXIT_FAILURE);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2004-06-04 04:51:54 +02:00
|
|
|
return;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
static int traverseAllInSubDirectory(int fd, Directory * directory,
|
|
|
|
int (*forEachSong) (int, Song *,
|
2006-07-20 18:02:40 +02:00
|
|
|
void *),
|
2006-07-30 05:43:38 +02:00
|
|
|
int (*forEachDir) (int, Directory *,
|
2006-07-20 18:02:40 +02:00
|
|
|
void *), void *data)
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
ListNode *node = directory->songs->firstNode;
|
|
|
|
Song *song;
|
|
|
|
Directory *dir;
|
|
|
|
int errFlag = 0;
|
|
|
|
|
|
|
|
if (forEachDir) {
|
2006-07-30 05:43:38 +02:00
|
|
|
errFlag = forEachDir(fd, directory, data);
|
2006-07-20 18:02:40 +02:00
|
|
|
if (errFlag)
|
|
|
|
return errFlag;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (forEachSong) {
|
|
|
|
while (node != NULL && !errFlag) {
|
|
|
|
song = (Song *) node->data;
|
2006-07-30 05:43:38 +02:00
|
|
|
errFlag = forEachSong(fd, song, data);
|
2006-07-20 18:02:40 +02:00
|
|
|
node = node->nextNode;
|
|
|
|
}
|
|
|
|
if (errFlag)
|
|
|
|
return errFlag;
|
|
|
|
}
|
|
|
|
|
|
|
|
node = directory->subDirectories->firstNode;
|
|
|
|
|
|
|
|
while (node != NULL && !errFlag) {
|
|
|
|
dir = (Directory *) node->data;
|
2006-07-30 05:43:38 +02:00
|
|
|
errFlag = traverseAllInSubDirectory(fd, dir, forEachSong,
|
2006-07-20 18:02:40 +02:00
|
|
|
forEachDir, data);
|
|
|
|
node = node->nextNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
return errFlag;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
int traverseAllIn(int fd, char *name,
|
|
|
|
int (*forEachSong) (int, Song *, void *),
|
|
|
|
int (*forEachDir) (int, Directory *, void *), void *data)
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
|
|
|
Directory *directory;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if ((directory = getDirectory(name)) == NULL) {
|
|
|
|
Song *song;
|
|
|
|
if ((song = getSongFromDB(name)) && forEachSong) {
|
2006-07-30 05:43:38 +02:00
|
|
|
return forEachSong(fd, song, data);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2006-07-30 05:43:38 +02:00
|
|
|
commandError(fd, ACK_ERROR_NO_EXIST,
|
2006-07-30 10:47:50 +02:00
|
|
|
"directory or file not found");
|
2004-02-24 00:41:20 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
return traverseAllInSubDirectory(fd, directory, forEachSong, forEachDir,
|
2006-07-20 18:02:40 +02:00
|
|
|
data);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static void freeAllDirectoryStats(Directory * directory)
|
|
|
|
{
|
|
|
|
ListNode *node = directory->subDirectories->firstNode;
|
2004-06-23 05:33:35 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
while (node != NULL) {
|
|
|
|
freeAllDirectoryStats((Directory *) node->data);
|
2004-06-23 05:33:35 +02:00
|
|
|
node = node->nextNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
freeDirectoryStatFromDirectory(directory);
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
void initMp3Directory()
|
|
|
|
{
|
2004-04-16 01:36:41 +02:00
|
|
|
struct stat st;
|
|
|
|
|
2004-06-23 05:33:35 +02:00
|
|
|
mp3rootDirectory = newDirectory(NULL, NULL);
|
2004-02-24 00:41:20 +01:00
|
|
|
exploreDirectory(mp3rootDirectory);
|
2004-06-23 05:33:35 +02:00
|
|
|
freeAllDirectoryStats(mp3rootDirectory);
|
2006-07-30 05:43:38 +02:00
|
|
|
stats.numberOfSongs = countSongsIn(STDERR_FILENO, NULL);
|
|
|
|
stats.dbPlayTime = sumSongTimesIn(STDERR_FILENO, NULL);
|
2004-04-16 01:36:41 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (stat(getDbFile(), &st) == 0)
|
|
|
|
directory_dbModTime = st.st_mtime;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static Song *getSongDetails(char *file, char **shortnameRet,
|
|
|
|
Directory ** directoryRet)
|
2004-04-11 19:37:47 +02:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
void *song = NULL;
|
|
|
|
Directory *directory;
|
|
|
|
char *dir = NULL;
|
|
|
|
char *dup = strdup(file);
|
|
|
|
char *shortname = dup;
|
|
|
|
char *c = strtok(dup, "/");
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
DEBUG("get song: %s\n", file);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
while (c) {
|
2004-02-24 00:41:20 +01:00
|
|
|
shortname = c;
|
2006-07-20 18:02:40 +02:00
|
|
|
c = strtok(NULL, "/");
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (shortname != dup) {
|
|
|
|
for (c = dup; c < shortname - 1; c++) {
|
|
|
|
if (*c == '\0')
|
|
|
|
*c = '/';
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
dir = dup;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (!(directory = getDirectory(dir))) {
|
2004-02-24 00:41:20 +01:00
|
|
|
free(dup);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (!findInList(directory->songs, shortname, &song)) {
|
2004-02-24 00:41:20 +01:00
|
|
|
free(dup);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(dup);
|
2006-07-20 18:02:40 +02:00
|
|
|
if (shortnameRet)
|
|
|
|
*shortnameRet = shortname;
|
|
|
|
if (directoryRet)
|
|
|
|
*directoryRet = directory;
|
|
|
|
return (Song *) song;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
Song *getSongFromDB(char *file)
|
|
|
|
{
|
|
|
|
return getSongDetails(file, NULL, NULL);
|
2004-04-11 19:37:47 +02:00
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
time_t getDbModTime()
|
|
|
|
{
|
2004-04-16 01:36:41 +02:00
|
|
|
return directory_dbModTime;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|