2004-02-24 00:41:20 +01:00
|
|
|
/* the Music Player Daemon (MPD)
|
|
|
|
* (c)2003-2004 by Warren Dukes (shank@mercury.chem.pitt.edu)
|
|
|
|
* 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-04-13 18:46:11 +02:00
|
|
|
#include "player.h"
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
#include <string.h>
|
|
|
|
#include <sys/types.h>
|
2004-04-11 03:53:25 +02:00
|
|
|
#include <sys/time.h>
|
|
|
|
#include <sys/resource.h>
|
|
|
|
#include <sys/wait.h>
|
2004-02-24 00:41:20 +01:00
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <dirent.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <errno.h>
|
2004-04-11 03:53:25 +02:00
|
|
|
#include <signal.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: "
|
|
|
|
|
|
|
|
#define DIRECTORY_SEARCH_ALBUM "album"
|
|
|
|
#define DIRECTORY_SEARCH_ARTIST "artist"
|
|
|
|
#define DIRECTORY_SEARCH_TITLE "title"
|
|
|
|
#define DIRECTORY_SEARCH_FILENAME "filename"
|
|
|
|
|
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
|
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
typedef List DirectoryList;
|
|
|
|
|
|
|
|
typedef struct _Directory {
|
|
|
|
char * utf8name;
|
|
|
|
DirectoryList * subDirectories;
|
|
|
|
SongList * songs;
|
|
|
|
} Directory;
|
|
|
|
|
2004-04-10 19:56:01 +02:00
|
|
|
Directory * mp3rootDirectory = NULL;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-04-16 01:36:41 +02:00
|
|
|
char * directory_db;
|
|
|
|
|
|
|
|
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
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
DirectoryList * newDirectoryList();
|
|
|
|
|
|
|
|
int addToDirectory(Directory * directory, char * shortname, char * name);
|
|
|
|
|
|
|
|
void freeDirectoryList(DirectoryList * list);
|
|
|
|
|
|
|
|
void freeDirectory(Directory * directory);
|
|
|
|
|
|
|
|
int exploreDirectory(Directory * directory);
|
|
|
|
|
|
|
|
int updateDirectory(Directory * directory);
|
|
|
|
|
2004-03-09 23:48:35 +01:00
|
|
|
void deleteEmptyDirectoriesInDirectory(Directory * directory);
|
|
|
|
|
2004-04-11 19:37:47 +02:00
|
|
|
void removeSongFromDirectory(Directory * directory, char * shortname);
|
|
|
|
|
2004-04-17 01:49:48 +02:00
|
|
|
int addSubDirectoryToDirectory(Directory * directory, char * shortname,
|
2004-04-14 04:35:29 +02:00
|
|
|
char * name);
|
|
|
|
|
|
|
|
Directory * getDirectoryDetails(char * name, char ** shortname,
|
|
|
|
Directory ** parentDirectory);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-04-11 19:37:47 +02:00
|
|
|
Directory * getDirectory(char * name);
|
|
|
|
|
|
|
|
Song * getSongDetails(char * file, char ** shortnameRet,
|
|
|
|
Directory ** directoryRet);
|
|
|
|
|
2004-04-16 02:41:56 +02:00
|
|
|
int updatePath(char * utf8path);
|
2004-04-14 04:35:29 +02:00
|
|
|
|
2004-04-14 07:26:32 +02:00
|
|
|
void sortDirectory(Directory * directory);
|
|
|
|
|
2004-04-13 18:46:11 +02:00
|
|
|
void clearUpdatePid() {
|
|
|
|
directory_updatePid = 0;
|
|
|
|
}
|
|
|
|
|
2004-04-11 04:34:26 +02:00
|
|
|
int isUpdatingDB() {
|
2004-04-12 02:41:53 +02:00
|
|
|
if(directory_updatePid>0 || directory_reReadDB) {
|
|
|
|
return directory_updateJobId;
|
|
|
|
}
|
2004-04-11 04:34:26 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-04-11 03:53:25 +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));
|
|
|
|
}
|
2004-04-16 02:41:56 +02:00
|
|
|
else if(!WIFSIGNALED(status)) {
|
|
|
|
switch(WEXITSTATUS(status))
|
|
|
|
{
|
|
|
|
case DIRECTORY_UPDATE_EXIT_UPDATE:
|
|
|
|
directory_reReadDB = 1;
|
|
|
|
DEBUG("direcotry_sigChldHandler: "
|
|
|
|
"updated db\n");
|
|
|
|
case DIRECTORY_UPDATE_EXIT_NOUPDATE:
|
|
|
|
DEBUG("direcotry_sigChldHandler: "
|
|
|
|
"update exitted 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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-04-12 01:07:43 +02:00
|
|
|
void readDirectoryDBIfUpdateIsFinished() {
|
|
|
|
if(directory_reReadDB && 0==directory_updatePid) {
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-04-11 19:37:47 +02:00
|
|
|
int updateInit(FILE * fp, List * pathList) {
|
2004-04-11 03:53:25 +02:00
|
|
|
if(directory_updatePid > 0) {
|
2004-06-04 04:51:54 +02:00
|
|
|
commandError(fp, 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
|
|
|
|
even get a chance to assign directory_updatePID */
|
|
|
|
blockSignals();
|
2004-04-11 03:53:25 +02:00
|
|
|
directory_updatePid = fork();
|
|
|
|
if(directory_updatePid==0) {
|
|
|
|
/* child */
|
2004-04-16 02:41:56 +02:00
|
|
|
int dbUpdated = 0;
|
2004-04-13 18:46:11 +02:00
|
|
|
clearPlayerPid();
|
|
|
|
|
|
|
|
unblockSignals();
|
2004-04-11 03:53:25 +02:00
|
|
|
|
2004-04-11 06:15:14 +02:00
|
|
|
finishSigHandlers();
|
2004-04-11 03:53:25 +02:00
|
|
|
close(listenSocket);
|
|
|
|
freeAllInterfaces();
|
|
|
|
finishPlaylist();
|
|
|
|
finishVolume();
|
|
|
|
|
2004-04-11 19:37:47 +02:00
|
|
|
if(pathList) {
|
|
|
|
ListNode * node = pathList->firstNode;
|
|
|
|
|
|
|
|
while(node) {
|
2004-04-16 02:41:56 +02:00
|
|
|
switch(updatePath(node->key)) {
|
|
|
|
case 1:
|
|
|
|
dbUpdated = 1;
|
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
exit(DIRECTORY_UPDATE_EXIT_ERROR);
|
|
|
|
}
|
2004-04-11 19:37:47 +02:00
|
|
|
node = node->nextNode;
|
|
|
|
}
|
|
|
|
}
|
2004-04-16 02:41:56 +02:00
|
|
|
else {
|
|
|
|
if((dbUpdated = updateDirectory(mp3rootDirectory))<0) {
|
|
|
|
exit(DIRECTORY_UPDATE_EXIT_ERROR);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!dbUpdated) exit(DIRECTORY_UPDATE_EXIT_NOUPDATE);
|
|
|
|
|
2004-04-13 21:24:05 +02:00
|
|
|
/* ignore signals since we don't want them to corrupt the db*/
|
|
|
|
ignoreSignals();
|
2004-04-11 19:37:47 +02:00
|
|
|
if(writeDirectoryDB()<0) {
|
|
|
|
ERROR("problems writing music db file, \"%s\"\n",
|
2004-04-16 01:36:41 +02:00
|
|
|
directory_db);
|
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);
|
2004-04-11 03:53:25 +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");
|
2004-06-04 04:51:54 +02:00
|
|
|
commandError(fp, ACK_ERROR_SYSTEM,
|
|
|
|
"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++;
|
|
|
|
if(directory_updateJobId > 1<<15) directory_updateJobId = 1;
|
|
|
|
DEBUG("updateInit: fork()'d update child for update job id %i\n",
|
|
|
|
(int)directory_updateJobId);
|
|
|
|
myfprintf(fp,"updating_db: %i\n",(int)directory_updateJobId);
|
2004-04-11 03:53:25 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-04-16 02:41:56 +02:00
|
|
|
Directory * newDirectory(char * dirname) {
|
2004-02-24 00:41:20 +01:00
|
|
|
Directory * directory;
|
|
|
|
|
|
|
|
directory = malloc(sizeof(Directory));
|
|
|
|
|
|
|
|
if(dirname!=NULL) directory->utf8name = strdup(dirname);
|
|
|
|
else directory->utf8name = NULL;
|
|
|
|
directory->subDirectories = newDirectoryList();
|
|
|
|
directory->songs = newSongList();
|
|
|
|
|
|
|
|
return directory;
|
|
|
|
}
|
|
|
|
|
|
|
|
void freeDirectory(Directory * directory) {
|
|
|
|
freeDirectoryList(directory->subDirectories);
|
|
|
|
freeSongList(directory->songs);
|
|
|
|
if(directory->utf8name) free(directory->utf8name);
|
|
|
|
free(directory);
|
|
|
|
}
|
|
|
|
|
|
|
|
DirectoryList * newDirectoryList() {
|
|
|
|
return makeList((ListFreeDataFunc *)freeDirectory);
|
|
|
|
}
|
|
|
|
|
|
|
|
void freeDirectoryList(DirectoryList * directoryList) {
|
|
|
|
freeList(directoryList);
|
|
|
|
}
|
|
|
|
|
|
|
|
void removeSongFromDirectory(Directory * directory, char * shortname) {
|
|
|
|
void * song;
|
2004-03-10 00:07:26 +01:00
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
if(findInList(directory->songs,shortname,&song)) {
|
2004-05-13 20:16:03 +02:00
|
|
|
LOG("removing: %s\n",((Song *)song)->utf8url);
|
2004-02-24 00:41:20 +01:00
|
|
|
deleteFromList(directory->songs,shortname);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-03-09 23:48:35 +01:00
|
|
|
void deleteEmptyDirectoriesInDirectory(Directory * directory) {
|
|
|
|
ListNode * node = directory->subDirectories->firstNode;
|
|
|
|
ListNode * nextNode;
|
|
|
|
Directory * subDir;
|
|
|
|
|
|
|
|
while(node) {
|
|
|
|
subDir = (Directory *)node->data;
|
|
|
|
deleteEmptyDirectoriesInDirectory(subDir);
|
|
|
|
nextNode = node->nextNode;
|
|
|
|
if(subDir->subDirectories->numberOfNodes==0 &&
|
|
|
|
subDir->songs->numberOfNodes==0)
|
|
|
|
{
|
|
|
|
deleteNodeFromList(directory->subDirectories,node);
|
|
|
|
}
|
|
|
|
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
|
|
|
|
*/
|
2004-02-24 00:41:20 +01:00
|
|
|
int updateInDirectory(Directory * directory, char * shortname, char * name) {
|
|
|
|
time_t mtime;
|
|
|
|
void * song;
|
|
|
|
void * subDir;
|
|
|
|
|
2004-03-10 03:58:27 +01:00
|
|
|
if(isMusic(name,&mtime)) {
|
2004-02-24 00:41:20 +01:00
|
|
|
if(0==findInList(directory->songs,shortname,&song)) {
|
|
|
|
addToDirectory(directory,shortname,name);
|
2004-04-16 02:48:47 +02:00
|
|
|
return DIRECTORY_RETURN_UPDATE;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2004-03-10 04:14:31 +01:00
|
|
|
else if(mtime!=((Song *)song)->mtime) {
|
2004-02-24 00:41:20 +01:00
|
|
|
LOG("updating %s\n",name);
|
2004-03-10 10:55:54 +01:00
|
|
|
if(updateSongInfo((Song *)song)<0) {
|
|
|
|
removeSongFromDirectory(directory,shortname);
|
|
|
|
}
|
2004-04-16 02:41:56 +02:00
|
|
|
return 1;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
}
|
2004-04-16 02:41:56 +02:00
|
|
|
else if(isDir(name)) {
|
2004-02-24 00:41:20 +01:00
|
|
|
if(findInList(directory->subDirectories,shortname,(void **)&subDir)) {
|
2004-04-16 02:41:56 +02:00
|
|
|
if(updateDirectory((Directory *)subDir)>0) return 1;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2004-04-16 02:41:56 +02:00
|
|
|
else {
|
2004-04-17 01:49:48 +02:00
|
|
|
return addSubDirectoryToDirectory(directory,shortname,
|
|
|
|
name);
|
2004-04-16 02:41:56 +02:00
|
|
|
}
|
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
|
|
|
|
*/
|
2004-02-24 00:41:20 +01:00
|
|
|
int removeDeletedFromDirectory(Directory * directory) {
|
|
|
|
DIR * dir;
|
|
|
|
char cwd[2];
|
|
|
|
struct dirent * ent;
|
|
|
|
char * dirname = directory->utf8name;
|
|
|
|
List * entList = makeList(free);
|
|
|
|
void * name;
|
|
|
|
char * s;
|
|
|
|
char * utf8;
|
|
|
|
ListNode * node;
|
|
|
|
ListNode * tmpNode;
|
2004-04-16 02:41:56 +02:00
|
|
|
int ret = 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
cwd[0] = '.';
|
|
|
|
cwd[1] = '\0';
|
|
|
|
if(dirname==NULL) dirname=cwd;
|
|
|
|
|
|
|
|
if((dir = opendir(rmp2amp(utf8ToFsCharset(dirname))))==NULL) return -1;
|
|
|
|
|
|
|
|
while((ent = readdir(dir))) {
|
|
|
|
if(ent->d_name[0]=='.') continue; /* hide hidden stuff */
|
2004-06-02 04:07:07 +02:00
|
|
|
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);
|
|
|
|
|
|
|
|
if(!utf8) continue;
|
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
if(directory->utf8name) {
|
|
|
|
s = malloc(strlen(directory->utf8name)+strlen(utf8)+2);
|
|
|
|
sprintf(s,"%s/%s",directory->utf8name,utf8);
|
|
|
|
}
|
|
|
|
else s= strdup(utf8);
|
2004-04-13 06:59:57 +02:00
|
|
|
insertInList(entList,utf8,s);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
closedir(dir);
|
|
|
|
|
|
|
|
node = directory->subDirectories->firstNode;
|
|
|
|
while(node) {
|
|
|
|
tmpNode = node->nextNode;
|
|
|
|
if(findInList(entList,node->key,&name)) {
|
2004-04-16 02:41:56 +02:00
|
|
|
if(!isDir((char *)name)) {
|
2004-03-10 00:07:26 +01:00
|
|
|
LOG("removing directory: %s\n",(char*)name);
|
2004-04-14 07:26:32 +02:00
|
|
|
deleteFromList(directory->subDirectories,
|
|
|
|
node->key);
|
2004-04-16 02:41:56 +02:00
|
|
|
ret = 1;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2004-04-14 07:26:32 +02:00
|
|
|
LOG("removing directory: ");
|
|
|
|
if(directory->utf8name) LOG("%s/",directory->utf8name);
|
|
|
|
LOG("%s\n",node->key);
|
2004-02-24 00:41:20 +01:00
|
|
|
deleteFromList(directory->subDirectories,node->key);
|
2004-04-16 02:41:56 +02:00
|
|
|
ret = 1;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
node = tmpNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
node = directory->songs->firstNode;
|
|
|
|
while(node) {
|
|
|
|
tmpNode = node->nextNode;
|
|
|
|
if(findInList(entList,node->key,(void **)&name)) {
|
2004-03-10 03:58:27 +01:00
|
|
|
if(!isMusic(name,NULL)) {
|
2004-02-24 00:41:20 +01:00
|
|
|
removeSongFromDirectory(directory,node->key);
|
2004-04-16 02:41:56 +02:00
|
|
|
ret = 1;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
removeSongFromDirectory(directory,node->key);
|
2004-04-16 02:41:56 +02:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2004-04-14 07:26:32 +02:00
|
|
|
Directory * addDirectoryPathToDB(char * utf8path, char ** shortname) {
|
|
|
|
char * parent;
|
|
|
|
Directory * parentDirectory;
|
|
|
|
void * directory;
|
|
|
|
|
|
|
|
parent = strdup(parentPath(utf8path));
|
|
|
|
|
|
|
|
if(strlen(parent)==0) parentDirectory = (void *)mp3rootDirectory;
|
|
|
|
else parentDirectory = addDirectoryPathToDB(parent,shortname);
|
|
|
|
|
|
|
|
*shortname = utf8path+strlen(parent);
|
|
|
|
while(*(*shortname) && *(*shortname)=='/') (*shortname)++;
|
|
|
|
|
|
|
|
if(!findInList(parentDirectory->subDirectories,*shortname, &directory))
|
|
|
|
{
|
2004-04-17 01:49:48 +02:00
|
|
|
directory = newDirectory(utf8path);
|
|
|
|
insertInList(parentDirectory->subDirectories,*shortname,
|
|
|
|
directory);
|
2004-04-14 07:26:32 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* if we're adding directory paths, make sure to delete filenames
|
|
|
|
with potentially the same name*/
|
|
|
|
removeSongFromDirectory(parentDirectory,*shortname);
|
|
|
|
|
|
|
|
free(parent);
|
|
|
|
|
|
|
|
return (Directory *)parentDirectory;
|
|
|
|
}
|
|
|
|
|
|
|
|
Directory * addParentPathToDB(char * utf8path, char ** shortname) {
|
|
|
|
char * parent;
|
|
|
|
Directory * parentDirectory;
|
|
|
|
|
|
|
|
parent = strdup(parentPath(utf8path));
|
|
|
|
|
|
|
|
if(strlen(parent)==0) parentDirectory = (void *)mp3rootDirectory;
|
|
|
|
else parentDirectory = addDirectoryPathToDB(parent,shortname);
|
|
|
|
|
|
|
|
*shortname = utf8path+strlen(parent);
|
|
|
|
while(*(*shortname) && *(*shortname)=='/') (*shortname)++;
|
|
|
|
|
|
|
|
free(parent);
|
|
|
|
|
|
|
|
return (Directory *)parentDirectory;
|
|
|
|
}
|
|
|
|
|
2004-04-16 02:41:56 +02:00
|
|
|
/* return values:
|
|
|
|
-1 -> error
|
|
|
|
0 -> no error, but nothing updated
|
|
|
|
1 -> no error, and stuff updated
|
|
|
|
*/
|
|
|
|
int updatePath(char * utf8path) {
|
2004-04-14 04:35:29 +02:00
|
|
|
Directory * directory;
|
|
|
|
Directory * parentDirectory;
|
2004-04-14 04:55:19 +02:00
|
|
|
Song * song;
|
2004-04-14 04:35:29 +02:00
|
|
|
char * shortname;
|
2004-04-14 07:26:32 +02:00
|
|
|
char * path = sanitizePathDup(utf8path);
|
2004-04-16 02:41:56 +02:00
|
|
|
time_t mtime;
|
|
|
|
int ret = 0;
|
2004-04-14 07:26:32 +02:00
|
|
|
|
2004-04-16 02:41:56 +02:00
|
|
|
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 */
|
2004-04-14 07:26:32 +02:00
|
|
|
if((directory = getDirectoryDetails(path,&shortname,
|
2004-04-14 04:35:29 +02:00
|
|
|
&parentDirectory)))
|
|
|
|
{
|
2004-04-14 07:26:32 +02:00
|
|
|
/* if this update directory is successfull, we are done */
|
2004-04-16 02:41:56 +02:00
|
|
|
if((ret = updateDirectory(directory))>=0)
|
2004-04-14 04:35:29 +02:00
|
|
|
{
|
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 */
|
|
|
|
else if(directory == mp3rootDirectory) {
|
|
|
|
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 {
|
|
|
|
LOG("removing directory: %s\n",path);
|
2004-04-14 04:35:29 +02:00
|
|
|
deleteFromList(parentDirectory->subDirectories,
|
|
|
|
shortname);
|
2004-04-16 02:41:56 +02:00
|
|
|
ret = 1;
|
|
|
|
/* don't return, path maybe a song now*/
|
2004-04-14 04:35:29 +02:00
|
|
|
}
|
|
|
|
}
|
2004-04-14 07:26:32 +02:00
|
|
|
else if((song = getSongDetails(path,&shortname,&parentDirectory))) {
|
|
|
|
/* if this song update is successfull, we are done */
|
2004-05-13 20:16:03 +02:00
|
|
|
if(song && isMusic(song->utf8url,&mtime)) {
|
2004-04-14 07:26:32 +02:00
|
|
|
free(path);
|
2004-04-16 02:41:56 +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 {
|
|
|
|
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
|
|
|
|
* name or vice versa, we need to add it to the db
|
|
|
|
*/
|
2004-04-16 02:41:56 +02:00
|
|
|
if(isDir(path) || isMusic(path,NULL)) {
|
2004-04-14 07:26:32 +02:00
|
|
|
parentDirectory = addParentPathToDB(path,&shortname);
|
2004-04-17 01:49:48 +02:00
|
|
|
if(addToDirectory(parentDirectory,shortname,path)>0) 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
|
|
|
|
|
|
|
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
|
|
|
|
*/
|
2004-02-24 00:41:20 +01:00
|
|
|
int updateDirectory(Directory * directory) {
|
|
|
|
DIR * dir;
|
|
|
|
char cwd[2];
|
|
|
|
struct dirent * ent;
|
|
|
|
char * s;
|
|
|
|
char * utf8;
|
|
|
|
char * dirname = directory->utf8name;
|
2004-04-16 02:41:56 +02:00
|
|
|
int ret = 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
cwd[0] = '.';
|
|
|
|
cwd[1] = '\0';
|
|
|
|
if(dirname==NULL) dirname=cwd;
|
|
|
|
|
2004-04-16 02:41:56 +02:00
|
|
|
if(removeDeletedFromDirectory(directory)>0) ret = 1;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
if((dir = opendir(rmp2amp(utf8ToFsCharset(dirname))))==NULL) return -1;
|
|
|
|
|
|
|
|
while((ent = readdir(dir))) {
|
|
|
|
if(ent->d_name[0]=='.') continue; /* hide hidden stuff */
|
2004-06-02 04:07:07 +02:00
|
|
|
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);
|
|
|
|
|
|
|
|
if(!utf8) continue;
|
|
|
|
|
|
|
|
utf8 = strdup(utf8);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
if(directory->utf8name) {
|
|
|
|
s = malloc(strlen(directory->utf8name)+strlen(utf8)+2);
|
|
|
|
sprintf(s,"%s/%s",directory->utf8name,utf8);
|
|
|
|
}
|
|
|
|
else s = strdup(utf8);
|
2004-04-16 02:41:56 +02:00
|
|
|
if(updateInDirectory(directory,utf8,s)>0) ret = 1;
|
2004-02-24 00:41:20 +01:00
|
|
|
free(utf8);
|
|
|
|
free(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
|
*/
|
2004-02-24 00:41:20 +01:00
|
|
|
int exploreDirectory(Directory * directory) {
|
|
|
|
DIR * dir;
|
|
|
|
char cwd[2];
|
|
|
|
struct dirent * ent;
|
|
|
|
char * s;
|
|
|
|
char * utf8;
|
|
|
|
char * dirname = directory->utf8name;
|
2004-04-17 01:49:48 +02:00
|
|
|
int ret = 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
cwd[0] = '.';
|
|
|
|
cwd[1] = '\0';
|
|
|
|
if(dirname==NULL) dirname=cwd;
|
|
|
|
|
|
|
|
DEBUG("explore: attempting to opendir: %s\n",dirname);
|
|
|
|
if((dir = opendir(rmp2amp(utf8ToFsCharset(dirname))))==NULL) return -1;
|
|
|
|
|
2004-03-10 00:07:26 +01:00
|
|
|
DEBUG("explore: %s\n",dirname);
|
2004-02-24 00:41:20 +01:00
|
|
|
while((ent = readdir(dir))) {
|
|
|
|
if(ent->d_name[0]=='.') continue; /* hide hidden stuff */
|
2004-06-02 04:07:07 +02:00
|
|
|
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);
|
|
|
|
|
|
|
|
if(!utf8) continue;
|
|
|
|
|
|
|
|
utf8 = strdup(utf8);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
DEBUG("explore: found: %s (%s)\n",ent->d_name,utf8);
|
|
|
|
|
|
|
|
if(directory->utf8name) {
|
|
|
|
s = malloc(strlen(directory->utf8name)+strlen(utf8)+2);
|
|
|
|
sprintf(s,"%s/%s",directory->utf8name,utf8);
|
|
|
|
}
|
|
|
|
else s = strdup(utf8);
|
2004-04-17 01:49:48 +02:00
|
|
|
if(addToDirectory(directory,utf8,s)>0) ret = 1;
|
2004-02-24 00:41:20 +01:00
|
|
|
free(utf8);
|
|
|
|
free(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
closedir(dir);
|
|
|
|
|
2004-04-17 01:49:48 +02:00
|
|
|
return ret;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2004-04-17 01:49:48 +02:00
|
|
|
int addSubDirectoryToDirectory(Directory * directory, char * shortname,
|
2004-02-24 00:41:20 +01:00
|
|
|
char * name)
|
|
|
|
{
|
2004-04-16 02:41:56 +02:00
|
|
|
Directory * subDirectory = newDirectory(name);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-04-17 01:49:48 +02:00
|
|
|
if(exploreDirectory(subDirectory)<1) {
|
|
|
|
freeDirectory(subDirectory);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
insertInList(directory->subDirectories,shortname,subDirectory);
|
|
|
|
|
2004-04-17 01:49:48 +02:00
|
|
|
return 1;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int addToDirectory(Directory * directory, char * shortname, char * name) {
|
2004-04-16 02:41:56 +02:00
|
|
|
if(isDir(name)) {
|
2004-04-17 01:49:48 +02:00
|
|
|
return addSubDirectoryToDirectory(directory,shortname,name);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2004-03-10 03:58:27 +01:00
|
|
|
else if(isMusic(name,NULL)) {
|
2004-02-24 00:41:20 +01:00
|
|
|
Song * song;
|
2004-05-13 20:16:03 +02:00
|
|
|
song = addSongToList(directory->songs,shortname,name,
|
|
|
|
SONG_TYPE_FILE);
|
2004-02-24 00:41:20 +01:00
|
|
|
if(!song) return -1;
|
2004-03-10 03:38:31 +01:00
|
|
|
LOG("added %s\n",name);
|
2004-04-17 01:49:48 +02:00
|
|
|
return 1;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
DEBUG("addToDirectory: %s is not a directory or music\n",name);
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void closeMp3Directory() {
|
|
|
|
freeDirectory(mp3rootDirectory);
|
|
|
|
}
|
|
|
|
|
|
|
|
Directory * findSubDirectory(Directory * directory,char * name) {
|
|
|
|
void * subDirectory;
|
|
|
|
char * dup = strdup(name);
|
|
|
|
char * key;
|
|
|
|
|
|
|
|
key = strtok(dup,"/");
|
|
|
|
if(!key) {
|
|
|
|
free(dup);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(findInList(directory->subDirectories,key,&subDirectory)) {
|
|
|
|
free(dup);
|
|
|
|
return (Directory *)subDirectory;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(dup);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2004-04-14 04:35:29 +02:00
|
|
|
Directory * getSubDirectory(Directory * directory, char * name,
|
|
|
|
char ** shortname, Directory ** parentDirectory)
|
|
|
|
{
|
2004-02-24 00:41:20 +01:00
|
|
|
Directory * subDirectory;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if(name==NULL || name[0]=='\0' || strcmp(name,"/")==0) {
|
|
|
|
return directory;
|
|
|
|
}
|
|
|
|
|
|
|
|
if((subDirectory = findSubDirectory(directory,name))==NULL) return NULL;
|
|
|
|
|
2004-04-14 04:35:29 +02:00
|
|
|
*shortname = name;
|
|
|
|
*parentDirectory = directory;
|
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
len = 0;
|
|
|
|
while(name[len]!='/' && name[len]!='\0') len++;
|
|
|
|
while(name[len]=='/') len++;
|
|
|
|
|
2004-04-14 04:35:29 +02:00
|
|
|
return getSubDirectory(subDirectory,&(name[len]),shortname,
|
|
|
|
parentDirectory);
|
|
|
|
}
|
|
|
|
|
|
|
|
Directory * getDirectoryDetails(char * name, char ** shortname,
|
|
|
|
Directory ** parentDirectory)
|
|
|
|
{
|
|
|
|
*shortname = NULL;
|
|
|
|
*parentDirectory = NULL;
|
|
|
|
|
|
|
|
return getSubDirectory(mp3rootDirectory,name,shortname,parentDirectory);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
Directory * getDirectory(char * name) {
|
2004-04-14 04:35:29 +02:00
|
|
|
char * shortname;
|
|
|
|
Directory * parentDirectory;
|
|
|
|
|
|
|
|
return getSubDirectory(mp3rootDirectory,name,&shortname,
|
|
|
|
&parentDirectory);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int printDirectoryList(FILE * fp, DirectoryList * directoryList) {
|
|
|
|
ListNode * node = directoryList->firstNode;
|
|
|
|
Directory * directory;
|
|
|
|
|
|
|
|
while(node!=NULL) {
|
|
|
|
directory = (Directory *)node->data;
|
|
|
|
myfprintf(fp,"%s%s\n",DIRECTORY_DIR,directory->utf8name);
|
|
|
|
node = node->nextNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int printDirectoryInfo(FILE * fp, char * name) {
|
|
|
|
Directory * directory;
|
|
|
|
|
|
|
|
if((directory = getDirectory(name))==NULL) {
|
2004-06-04 04:51:54 +02:00
|
|
|
commandError(fp, ACK_ERROR_NO_EXIST, "directory not found");
|
2004-02-24 00:41:20 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
printDirectoryList(fp,directory->subDirectories);
|
|
|
|
printSongInfoFromList(fp,directory->songs);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void writeDirectoryInfo(FILE * fp, Directory * directory) {
|
|
|
|
ListNode * node = (directory->subDirectories)->firstNode;
|
|
|
|
Directory * subDirectory;
|
|
|
|
|
|
|
|
if(directory->utf8name) {
|
|
|
|
myfprintf(fp,"%s%s\n",DIRECTORY_BEGIN,directory->utf8name);
|
|
|
|
}
|
|
|
|
|
|
|
|
while(node!=NULL) {
|
|
|
|
subDirectory = (Directory *)node->data;
|
|
|
|
myfprintf(fp,"%s%s\n",DIRECTORY_DIR,node->key);
|
|
|
|
writeDirectoryInfo(fp,subDirectory);
|
|
|
|
node = node->nextNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
writeSongInfoFromList(fp,directory->songs);
|
|
|
|
|
|
|
|
if(directory->utf8name) {
|
|
|
|
myfprintf(fp,"%s%s\n",DIRECTORY_END,directory->utf8name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void readDirectoryInfo(FILE * fp,Directory * directory) {
|
|
|
|
char buffer[MAXPATHLEN*2];
|
|
|
|
int bufferSize = MAXPATHLEN*2;
|
|
|
|
char * key;
|
|
|
|
Directory * subDirectory;
|
|
|
|
char * name;
|
2004-04-10 19:56:01 +02:00
|
|
|
int strcmpRet;
|
|
|
|
ListNode * nextDirNode = directory->subDirectories->firstNode;
|
|
|
|
ListNode * nodeTemp;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
while(myFgets(buffer,bufferSize,fp) && 0!=strncmp(DIRECTORY_END,buffer,strlen(DIRECTORY_END))) {
|
|
|
|
if(0==strncmp(DIRECTORY_DIR,buffer,strlen(DIRECTORY_DIR))) {
|
|
|
|
key = strdup(&(buffer[strlen(DIRECTORY_DIR)]));
|
|
|
|
if(myFgets(buffer,bufferSize,fp)<0) {
|
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
|
|
|
}
|
2004-04-16 02:41:56 +02:00
|
|
|
/* for compatibility with db's prior to 0.11 */
|
|
|
|
if(0==strncmp(DIRECTORY_MTIME,buffer,
|
|
|
|
strlen(DIRECTORY_MTIME)))
|
|
|
|
{
|
|
|
|
if(myFgets(buffer,bufferSize,fp)<0) {
|
|
|
|
ERROR("Error reading db, fgets\n");
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
}
|
2004-02-24 00:41:20 +01:00
|
|
|
if(strncmp(DIRECTORY_BEGIN,buffer,strlen(DIRECTORY_BEGIN))) {
|
2004-04-16 02:41:56 +02:00
|
|
|
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
|
|
|
}
|
|
|
|
name = strdup(&(buffer[strlen(DIRECTORY_BEGIN)]));
|
2004-04-10 19:56:01 +02:00
|
|
|
|
|
|
|
while(nextDirNode && (strcmpRet =
|
|
|
|
strcmp(key,nextDirNode->key)) > 0) {
|
|
|
|
nodeTemp = nextDirNode->nextNode;
|
|
|
|
deleteNodeFromList(directory->subDirectories,
|
|
|
|
nextDirNode);
|
|
|
|
nextDirNode = nodeTemp;
|
|
|
|
}
|
|
|
|
|
2004-04-11 02:52:05 +02:00
|
|
|
if(NULL==nextDirNode) {
|
2004-04-16 02:41:56 +02:00
|
|
|
subDirectory = newDirectory(name);
|
2004-04-10 19:56:01 +02:00
|
|
|
insertInList(directory->subDirectories,key,
|
|
|
|
(void *)subDirectory);
|
|
|
|
}
|
|
|
|
else if(strcmpRet == 0) {
|
|
|
|
subDirectory = (Directory *)nextDirNode->data;
|
|
|
|
nextDirNode = nextDirNode->nextNode;
|
|
|
|
}
|
|
|
|
else {
|
2004-04-16 02:41:56 +02:00
|
|
|
subDirectory = newDirectory(name);
|
2004-04-10 19:56:01 +02:00
|
|
|
insertInListBeforeNode(
|
|
|
|
directory->subDirectories,
|
|
|
|
nextDirNode,
|
|
|
|
key,
|
|
|
|
(void *)subDirectory);
|
|
|
|
}
|
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
free(key);
|
|
|
|
free(name);
|
|
|
|
readDirectoryInfo(fp,subDirectory);
|
|
|
|
}
|
|
|
|
else if(0==strncmp(SONG_BEGIN,buffer,strlen(SONG_BEGIN))) {
|
|
|
|
readSongInfoIntoList(fp,directory->songs);
|
|
|
|
}
|
|
|
|
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
|
|
|
|
|
|
|
while(nextDirNode) {
|
|
|
|
nodeTemp = nextDirNode->nextNode;
|
|
|
|
deleteNodeFromList(directory->subDirectories,nextDirNode);
|
|
|
|
nextDirNode = nodeTemp;
|
|
|
|
}
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void sortDirectory(Directory * directory) {
|
|
|
|
ListNode * node = directory->subDirectories->firstNode;
|
|
|
|
Directory * subDir;
|
|
|
|
|
|
|
|
sortList(directory->subDirectories);
|
|
|
|
sortList(directory->songs);
|
|
|
|
|
|
|
|
while(node!=NULL) {
|
|
|
|
subDir = (Directory *)node->data;
|
|
|
|
sortDirectory(subDir);
|
|
|
|
node = node->nextNode;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int writeDirectoryDB() {
|
|
|
|
FILE * fp;
|
|
|
|
|
2004-03-09 23:48:35 +01:00
|
|
|
deleteEmptyDirectoriesInDirectory(mp3rootDirectory);
|
2004-02-24 00:41:20 +01:00
|
|
|
sortDirectory(mp3rootDirectory);
|
|
|
|
|
2004-04-16 01:36:41 +02:00
|
|
|
while(!(fp=fopen(directory_db,"w")) && errno==EINTR);
|
2004-02-24 00:41:20 +01:00
|
|
|
if(!fp) return -1;
|
|
|
|
|
2004-04-13 21:24:05 +02:00
|
|
|
/* block signals when writing the db so we don't get a corrupted db*/
|
2004-02-24 00:41:20 +01:00
|
|
|
myfprintf(fp,"%s\n",DIRECTORY_INFO_BEGIN);
|
|
|
|
myfprintf(fp,"%s%s\n",DIRECTORY_MPD_VERSION,VERSION);
|
|
|
|
myfprintf(fp,"%s%s\n",DIRECTORY_FS_CHARSET,getFsCharset());
|
|
|
|
myfprintf(fp,"%s\n",DIRECTORY_INFO_END);
|
|
|
|
|
|
|
|
writeDirectoryInfo(fp,mp3rootDirectory);
|
2004-04-13 19:08:31 +02:00
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
while(fclose(fp) && errno==EINTR);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int readDirectoryDB() {
|
|
|
|
FILE * fp;
|
2004-05-17 13:56:14 +02:00
|
|
|
struct stat st;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-04-16 02:41:56 +02:00
|
|
|
if(!mp3rootDirectory) mp3rootDirectory = newDirectory(NULL);
|
2004-04-16 01:36:41 +02:00
|
|
|
while(!(fp=fopen(directory_db,"r")) && errno==EINTR);
|
2004-02-24 00:41:20 +01:00
|
|
|
if(!fp) return -1;
|
|
|
|
|
|
|
|
/* get initial info */
|
|
|
|
{
|
|
|
|
char buffer[100];
|
|
|
|
int bufferSize = 100;
|
|
|
|
int foundFsCharset = 0;
|
|
|
|
int foundVersion = 0;
|
|
|
|
|
|
|
|
if(myFgets(buffer,bufferSize,fp)<0) {
|
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
|
|
|
}
|
|
|
|
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)))
|
|
|
|
{
|
|
|
|
if(foundVersion) {
|
|
|
|
ERROR("already found "
|
|
|
|
"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;
|
|
|
|
}
|
|
|
|
else if(0==strncmp(DIRECTORY_FS_CHARSET,buffer,
|
|
|
|
strlen(DIRECTORY_FS_CHARSET)))
|
|
|
|
{
|
2004-03-21 22:32:23 +01:00
|
|
|
char * fsCharset;
|
|
|
|
char * tempCharset;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
if(foundFsCharset) {
|
|
|
|
ERROR("already found "
|
|
|
|
"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;
|
|
|
|
|
|
|
|
fsCharset = &(buffer[strlen(
|
|
|
|
DIRECTORY_FS_CHARSET)]);
|
2004-03-21 22:32:23 +01:00
|
|
|
if((tempCharset =
|
|
|
|
getConf()[CONF_FS_CHARSET]) &&
|
|
|
|
strcmp(fsCharset,tempCharset))
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
|
|
|
ERROR("Using \"%s\" for the "
|
|
|
|
"filesystem charset "
|
|
|
|
"instead of \"%s\"\n",
|
2004-03-21 22:32:23 +01:00
|
|
|
fsCharset,tempCharset);
|
2004-02-24 00:41:20 +01:00
|
|
|
ERROR("maybe you need to "
|
|
|
|
"recreate the db?\n");
|
|
|
|
setFsCharset(fsCharset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2004-03-09 21:55:51 +01:00
|
|
|
ERROR("directory: unknown line in db info: %s\n",
|
2004-02-24 00:41:20 +01:00
|
|
|
buffer);
|
2004-04-03 01:34:16 +02:00
|
|
|
exit(EXIT_FAILURE);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
ERROR("db info not found in db file\n");
|
|
|
|
ERROR("you should recreate the db using --create-db\n");
|
|
|
|
fseek(fp,0,SEEK_SET);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
readDirectoryInfo(fp,mp3rootDirectory);
|
|
|
|
while(fclose(fp) && errno==EINTR);
|
|
|
|
|
|
|
|
stats.numberOfSongs = countSongsIn(stderr,NULL);
|
2004-02-27 16:39:19 +01:00
|
|
|
stats.dbPlayTime = sumSongTimesIn(stderr,NULL);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-05-17 13:56:14 +02:00
|
|
|
if(stat(directory_db,&st)==0) directory_dbModTime = st.st_mtime;
|
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-06-04 04:51:54 +02:00
|
|
|
void updateMp3Directory() {
|
2004-04-16 02:48:47 +02:00
|
|
|
switch(updateDirectory(mp3rootDirectory)) {
|
|
|
|
case 0:
|
|
|
|
/* nothing updated */
|
2004-06-04 04:51:54 +02:00
|
|
|
return;
|
2004-04-16 02:48:47 +02:00
|
|
|
case 1:
|
2004-06-04 04:51:54 +02:00
|
|
|
if(writeDirectoryDB()<0) {
|
|
|
|
ERROR("problems writing music db file, \"%s\"\n",
|
|
|
|
directory_db);
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
2004-04-16 02:48:47 +02:00
|
|
|
/* something was updated and db should be written */
|
|
|
|
break;
|
|
|
|
default:
|
2004-02-24 00:41:20 +01:00
|
|
|
ERROR("problems updating music db\n");
|
2004-06-04 04:51:54 +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
|
|
|
}
|
|
|
|
|
|
|
|
int traverseAllInSubDirectory(FILE * fp, Directory * directory,
|
|
|
|
int (*forEachSong)(FILE *, Song *, void *),
|
|
|
|
int (*forEachDir)(FILE *, Directory *, void *),
|
|
|
|
void * data)
|
|
|
|
{
|
|
|
|
ListNode * node = directory->songs->firstNode;
|
|
|
|
Song * song;
|
|
|
|
Directory * dir;
|
|
|
|
int errFlag = 0;
|
|
|
|
|
|
|
|
if(forEachDir) {
|
|
|
|
errFlag = forEachDir(fp,directory,data);
|
|
|
|
if(errFlag) return errFlag;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(forEachSong) {
|
|
|
|
while(node!=NULL && !errFlag) {
|
|
|
|
song = (Song *)node->data;
|
|
|
|
errFlag = forEachSong(fp,song,data);
|
|
|
|
node = node->nextNode;
|
|
|
|
}
|
|
|
|
if(errFlag) return errFlag;
|
|
|
|
}
|
|
|
|
|
|
|
|
node = directory->subDirectories->firstNode;
|
|
|
|
|
|
|
|
while(node!=NULL && !errFlag) {
|
|
|
|
dir = (Directory *)node->data;
|
|
|
|
errFlag = traverseAllInSubDirectory(fp,dir,forEachSong,
|
|
|
|
forEachDir,data);
|
|
|
|
node = node->nextNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
return errFlag;
|
|
|
|
}
|
|
|
|
|
|
|
|
int traverseAllIn(FILE * fp, char * name,
|
|
|
|
int (*forEachSong)(FILE *, Song *, void *),
|
|
|
|
int (*forEachDir)(FILE *, Directory *, void *),
|
|
|
|
void * data) {
|
|
|
|
Directory * directory;
|
|
|
|
|
|
|
|
if((directory = getDirectory(name))==NULL) {
|
|
|
|
Song * song;
|
2004-05-13 20:46:38 +02:00
|
|
|
if((song = getSongFromDB(name)) && forEachSong) {
|
2004-02-24 00:41:20 +01:00
|
|
|
return forEachSong(fp, song, data);
|
|
|
|
}
|
2004-06-04 04:51:54 +02:00
|
|
|
commandError(fp, ACK_ERROR_NO_EXIST,
|
|
|
|
"directory or file not found");
|
2004-02-24 00:41:20 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return traverseAllInSubDirectory(fp,directory,forEachSong,forEachDir,
|
|
|
|
data);
|
|
|
|
}
|
|
|
|
|
|
|
|
int countSongsInDirectory(FILE * fp, Directory * directory, void * data) {
|
|
|
|
int * count = (int *)data;
|
|
|
|
|
|
|
|
*count+=directory->songs->numberOfNodes;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int printDirectoryInDirectory(FILE * fp, Directory * directory, void * data) {
|
|
|
|
if(directory->utf8name) {
|
|
|
|
myfprintf(fp,"directory: %s\n",directory->utf8name);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int printSongInDirectory(FILE * fp, Song * song, void * data) {
|
2004-05-13 20:16:03 +02:00
|
|
|
myfprintf(fp,"file: %s\n",song->utf8url);
|
2004-02-24 00:41:20 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int searchForAlbumInDirectory(FILE * fp, Song * song, void * string) {
|
|
|
|
if(song->tag && song->tag->album) {
|
|
|
|
char * dup = strDupToUpper(song->tag->album);
|
|
|
|
if(strstr(dup,(char *)string)) printSongInfo(fp,song);
|
|
|
|
free(dup);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int searchForArtistInDirectory(FILE * fp, Song * song, void * string) {
|
|
|
|
if(song->tag && song->tag->artist) {
|
|
|
|
char * dup = strDupToUpper(song->tag->artist);
|
|
|
|
if(strstr(dup,(char *)string)) printSongInfo(fp,song);
|
|
|
|
free(dup);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int searchForTitleInDirectory(FILE * fp, Song * song, void * string) {
|
|
|
|
if(song->tag && song->tag->title) {
|
|
|
|
char * dup = strDupToUpper(song->tag->title);
|
|
|
|
if(strstr(dup,(char *)string)) printSongInfo(fp,song);
|
|
|
|
free(dup);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int searchForFilenameInDirectory(FILE * fp, Song * song, void * string) {
|
2004-05-13 20:16:03 +02:00
|
|
|
char * dup = strDupToUpper(song->utf8url);
|
2004-02-24 00:41:20 +01:00
|
|
|
if(strstr(dup,(char *)string)) printSongInfo(fp,song);
|
|
|
|
free(dup);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int searchForSongsIn(FILE * fp, char * name, char * item, char * string) {
|
|
|
|
char * dup = strDupToUpper(string);
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
if(strcmp(item,DIRECTORY_SEARCH_ALBUM)==0) {
|
|
|
|
ret = traverseAllIn(fp,name,searchForAlbumInDirectory,NULL,
|
|
|
|
(void *)dup);
|
|
|
|
}
|
|
|
|
else if(strcmp(item,DIRECTORY_SEARCH_ARTIST)==0) {
|
|
|
|
ret = traverseAllIn(fp,name,searchForArtistInDirectory,NULL,
|
|
|
|
(void *)dup);
|
|
|
|
}
|
|
|
|
else if(strcmp(item,DIRECTORY_SEARCH_TITLE)==0) {
|
|
|
|
ret = traverseAllIn(fp,name,searchForTitleInDirectory,NULL,
|
|
|
|
(void *)dup);
|
|
|
|
}
|
|
|
|
else if(strcmp(item,DIRECTORY_SEARCH_FILENAME)==0) {
|
|
|
|
ret = traverseAllIn(fp,name,searchForFilenameInDirectory,NULL,
|
|
|
|
(void *)dup);
|
|
|
|
}
|
2004-06-04 04:51:54 +02:00
|
|
|
else commandError(fp, ACK_ERROR_ARG, "unknown table");
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
free(dup);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int findAlbumInDirectory(FILE * fp, Song * song, void * string) {
|
|
|
|
if(song->tag && song->tag->album &&
|
|
|
|
strcmp((char *)string,song->tag->album)==0)
|
|
|
|
{
|
|
|
|
printSongInfo(fp,song);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int findArtistInDirectory(FILE * fp, Song * song, void * string) {
|
|
|
|
if(song->tag && song->tag->artist &&
|
|
|
|
strcmp((char *)string,song->tag->artist)==0)
|
|
|
|
{
|
|
|
|
printSongInfo(fp,song);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int findSongsIn(FILE * fp, char * name, char * item, char * string) {
|
|
|
|
if(strcmp(item,DIRECTORY_SEARCH_ALBUM)==0) {
|
|
|
|
return traverseAllIn(fp,name,findAlbumInDirectory,NULL,
|
|
|
|
(void *)string);
|
|
|
|
}
|
|
|
|
else if(strcmp(item,DIRECTORY_SEARCH_ARTIST)==0) {
|
|
|
|
return traverseAllIn(fp,name,findArtistInDirectory,NULL,
|
|
|
|
(void *)string);
|
|
|
|
}
|
|
|
|
|
2004-06-04 04:51:54 +02:00
|
|
|
commandError(fp, ACK_ERROR_ARG, "unknown table");
|
2004-02-24 00:41:20 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int printAllIn(FILE * fp, char * name) {
|
|
|
|
return traverseAllIn(fp,name,printSongInDirectory,
|
|
|
|
printDirectoryInDirectory,NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
int directoryAddSongToPlaylist(FILE * fp, Song * song, void * data) {
|
|
|
|
return addSongToPlaylist(fp,song);
|
|
|
|
}
|
|
|
|
|
|
|
|
int addAllIn(FILE * fp, char * name) {
|
|
|
|
return traverseAllIn(fp,name,directoryAddSongToPlaylist,NULL,NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
int directoryPrintSongInfo(FILE * fp, Song * song, void * data) {
|
|
|
|
return printSongInfo(fp,song);
|
|
|
|
}
|
|
|
|
|
2004-02-27 16:39:19 +01:00
|
|
|
int sumSongTime(FILE * fp, Song * song, void * data) {
|
|
|
|
unsigned long * time = (unsigned long *)data;
|
|
|
|
|
2004-03-11 01:16:49 +01:00
|
|
|
if(song->tag && song->tag->time>=0) *time+=song->tag->time;
|
2004-02-27 16:39:19 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
int printInfoForAllIn(FILE * fp, char * name) {
|
|
|
|
return traverseAllIn(fp,name,directoryPrintSongInfo,NULL,NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
int countSongsIn(FILE * fp, char * name) {
|
|
|
|
int count = 0;
|
|
|
|
void * ptr = (void *)&count;
|
|
|
|
|
|
|
|
traverseAllIn(fp,name,NULL,countSongsInDirectory,ptr);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2004-02-27 16:39:19 +01:00
|
|
|
unsigned long sumSongTimesIn(FILE * fp, char * name) {
|
|
|
|
unsigned long dbPlayTime = 0;
|
|
|
|
void * ptr = (void *)&dbPlayTime;
|
|
|
|
|
|
|
|
traverseAllIn(fp,name,sumSongTime,NULL,ptr);
|
|
|
|
|
|
|
|
return dbPlayTime;
|
|
|
|
}
|
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
void initMp3Directory() {
|
2004-04-16 01:36:41 +02:00
|
|
|
struct stat st;
|
|
|
|
|
2004-04-16 02:41:56 +02:00
|
|
|
mp3rootDirectory = newDirectory(NULL);
|
2004-02-24 00:41:20 +01:00
|
|
|
exploreDirectory(mp3rootDirectory);
|
2004-04-15 17:25:06 +02:00
|
|
|
stats.numberOfSongs = countSongsIn(stderr,NULL);
|
|
|
|
stats.dbPlayTime = sumSongTimesIn(stderr,NULL);
|
2004-04-16 01:36:41 +02:00
|
|
|
|
|
|
|
if(stat(directory_db,&st)==0) directory_dbModTime = st.st_mtime;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2004-04-11 19:37:47 +02:00
|
|
|
Song * getSongDetails(char * file, char ** shortnameRet,
|
|
|
|
Directory ** directoryRet)
|
|
|
|
{
|
2004-05-19 07:07:31 +02:00
|
|
|
void * song = NULL;
|
2004-02-24 00:41:20 +01:00
|
|
|
Directory * directory;
|
|
|
|
char * dir = NULL;
|
|
|
|
char * dup = strdup(file);
|
|
|
|
char * shortname = dup;
|
|
|
|
char * c = strtok(dup,"/");
|
|
|
|
|
|
|
|
DEBUG("get song: %s\n",file);
|
|
|
|
|
|
|
|
while(c) {
|
|
|
|
shortname = c;
|
|
|
|
c = strtok(NULL,"/");
|
|
|
|
}
|
|
|
|
|
|
|
|
if(shortname!=dup) {
|
|
|
|
for(c = dup; c < shortname-1; c++) {
|
|
|
|
if(*c=='\0') *c = '/';
|
|
|
|
}
|
|
|
|
dir = dup;
|
|
|
|
}
|
|
|
|
|
2004-04-14 04:35:29 +02:00
|
|
|
if(!(directory = getDirectory(dir))) {
|
2004-02-24 00:41:20 +01:00
|
|
|
free(dup);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!findInList(directory->songs,shortname,&song)) {
|
|
|
|
free(dup);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(dup);
|
2004-04-11 19:37:47 +02:00
|
|
|
if(shortnameRet) *shortnameRet = shortname;
|
|
|
|
if(directoryRet) *directoryRet = directory;
|
2004-02-24 00:41:20 +01:00
|
|
|
return (Song *)song;
|
|
|
|
}
|
|
|
|
|
2004-05-13 20:46:38 +02:00
|
|
|
Song * getSongFromDB(char * file) {
|
2004-04-11 19:37:47 +02:00
|
|
|
return getSongDetails(file,NULL,NULL);
|
|
|
|
}
|
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
time_t getDbModTime() {
|
2004-04-16 01:36:41 +02:00
|
|
|
return directory_dbModTime;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2004-04-14 16:53:41 +02:00
|
|
|
/* vim:set shiftwidth=4 tabstop=8 expandtab: */
|