316 lines
7.0 KiB
C
316 lines
7.0 KiB
C
/* 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 "path.h"
|
|
#include "log.h"
|
|
#include "charConv.h"
|
|
#include "conf.h"
|
|
#include "utf8.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
#include <dirent.h>
|
|
|
|
#ifdef HAVE_LOCALE
|
|
#ifdef HAVE_LANGINFO_CODESET
|
|
#include <locale.h>
|
|
#include <langinfo.h>
|
|
#endif
|
|
#endif
|
|
|
|
char * musicDir;
|
|
char * playlistDir;
|
|
|
|
char * fsCharset = NULL;
|
|
|
|
char * pathConvCharset(char * to, char * from, char * str, char * ret) {
|
|
if(ret) {
|
|
free(ret);
|
|
ret = NULL;
|
|
}
|
|
|
|
if(setCharSetConversion(to,from)==0) {
|
|
ret = convStrDup(str);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
char * fsCharsetToUtf8(char * str) {
|
|
static char * ret = NULL;
|
|
|
|
ret = pathConvCharset("UTF-8",fsCharset,str,ret);
|
|
|
|
if(ret && !validUtf8String(ret)) {
|
|
free(ret);
|
|
ret = NULL;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
char * utf8ToFsCharset(char * str) {
|
|
static char * ret = NULL;
|
|
|
|
ret = pathConvCharset(fsCharset,"UTF-8",str,ret);
|
|
|
|
if(!ret) ret = strdup(str);
|
|
|
|
return ret;
|
|
}
|
|
|
|
void setFsCharset(char * charset) {
|
|
int error = 0;
|
|
|
|
if(fsCharset) free(fsCharset);
|
|
|
|
fsCharset = strdup(charset);
|
|
|
|
DEBUG("setFsCharset: fs charset is: %s\n",fsCharset);
|
|
|
|
if(setCharSetConversion("UTF-8",fsCharset)!=0) {
|
|
WARNING("fs charset conversion problem: "
|
|
"not able to convert from \"%s\" to \"%s\"\n",
|
|
fsCharset,"UTF-8");
|
|
error = 1;
|
|
}
|
|
if(setCharSetConversion(fsCharset,"UTF-8")!=0) {
|
|
WARNING("fs charset conversion problem: "
|
|
"not able to convert from \"%s\" to \"%s\"\n",
|
|
"UTF-8",fsCharset);
|
|
error = 1;
|
|
}
|
|
|
|
if(error) {
|
|
free(fsCharset);
|
|
WARNING("setting fs charset to ISO-8859-1!\n");
|
|
fsCharset = strdup("ISO-8859-1");
|
|
}
|
|
}
|
|
|
|
char * getFsCharset() {
|
|
return fsCharset;
|
|
}
|
|
|
|
static char * appendSlash(char ** path) {
|
|
char * temp = *path;
|
|
int len = strlen(temp);
|
|
|
|
if(temp[len-1] != '/') {
|
|
temp = malloc(len+2);
|
|
memset(temp, 0, len+2);
|
|
memcpy(temp, *path, len);
|
|
temp[len] = '/';
|
|
free(*path);
|
|
*path = temp;
|
|
}
|
|
|
|
return temp;
|
|
}
|
|
|
|
void initPaths() {
|
|
ConfigParam * musicParam = parseConfigFilePath(CONF_MUSIC_DIR, 1);
|
|
ConfigParam * playlistParam = parseConfigFilePath(CONF_PLAYLIST_DIR, 1);
|
|
ConfigParam * fsCharsetParam = getConfigParam(CONF_FS_CHARSET);
|
|
|
|
char * charset = NULL;
|
|
char * originalLocale;
|
|
DIR * dir;
|
|
|
|
musicDir = appendSlash(&(musicParam->value));
|
|
playlistDir = appendSlash(&(playlistParam->value));
|
|
|
|
if((dir = opendir(playlistDir)) == NULL) {
|
|
ERROR("cannot open %s \"%s\" (config line %i): %s\n",
|
|
CONF_PLAYLIST_DIR, playlistParam->value,
|
|
playlistParam->line, strerror(errno));
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
closedir(dir);
|
|
|
|
if((dir = opendir(musicDir)) == NULL) {
|
|
ERROR("cannot open %s \"%s\" (config line %i): %s\n",
|
|
CONF_MUSIC_DIR, musicParam->value,
|
|
musicParam->line, strerror(errno));
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
closedir(dir);
|
|
|
|
if(fsCharsetParam) {
|
|
charset = strdup(fsCharsetParam->value);
|
|
}
|
|
#ifdef HAVE_LOCALE
|
|
#ifdef HAVE_LANGINFO_CODESET
|
|
else if((originalLocale = setlocale(LC_CTYPE,NULL))) {
|
|
char * temp;
|
|
char * currentLocale;
|
|
originalLocale = strdup(originalLocale);
|
|
|
|
if(!(currentLocale = setlocale(LC_CTYPE,""))) {
|
|
WARNING("problems setting current locale with "
|
|
"setlocale()\n");
|
|
}
|
|
else {
|
|
if(strcmp(currentLocale,"C")==0 ||
|
|
strcmp(currentLocale,"POSIX")==0)
|
|
{
|
|
WARNING("current locale is \"%s\"\n",
|
|
currentLocale);
|
|
}
|
|
else if((temp = nl_langinfo(CODESET))) {
|
|
charset = strdup(temp);
|
|
}
|
|
else WARNING("problems getting charset for locale\n");
|
|
if(!setlocale(LC_CTYPE,originalLocale)) {
|
|
WARNING("problems resetting locale with setlocale()\n");
|
|
}
|
|
}
|
|
|
|
free(originalLocale);
|
|
}
|
|
else WARNING("problems getting locale with setlocale()\n");
|
|
#endif
|
|
#endif
|
|
|
|
if(charset) {
|
|
setFsCharset(charset);
|
|
free(charset);
|
|
}
|
|
else {
|
|
WARNING("setting filesystem charset to ISO-8859-1\n");
|
|
setFsCharset("ISO-8859-1");
|
|
}
|
|
}
|
|
|
|
void finishPaths() {
|
|
free(fsCharset);
|
|
fsCharset = NULL;
|
|
}
|
|
|
|
char * rmp2amp(char * relativePath) {
|
|
static char absolutePath[MAXPATHLEN+1];
|
|
|
|
memset(absolutePath,0,MAXPATHLEN+1);
|
|
|
|
strncpy(absolutePath,musicDir,MAXPATHLEN);
|
|
strncat(absolutePath,relativePath,MAXPATHLEN-strlen(musicDir));
|
|
|
|
return absolutePath;
|
|
}
|
|
|
|
char * rpp2app(char * relativePath) {
|
|
static char absolutePath[MAXPATHLEN+1];
|
|
|
|
memset(absolutePath,0,MAXPATHLEN+1);
|
|
|
|
strncpy(absolutePath,playlistDir,MAXPATHLEN);
|
|
strncat(absolutePath,relativePath,MAXPATHLEN-strlen(musicDir));
|
|
|
|
return absolutePath;
|
|
}
|
|
|
|
char * parentPath(char * path) {
|
|
static char parentPath[MAXPATHLEN+1];
|
|
char * c;
|
|
|
|
memset(parentPath,0,MAXPATHLEN+1);
|
|
strncpy(parentPath,path,MAXPATHLEN);
|
|
|
|
c = strrchr(parentPath,'/');
|
|
if (c == NULL)
|
|
parentPath[0] = '\0';
|
|
else {
|
|
while ((parentPath <= c) && *(--c) == '/') /* nothing */;
|
|
c[1] = '\0';
|
|
}
|
|
|
|
return parentPath;
|
|
}
|
|
|
|
char * sanitizePathDup(char * path) {
|
|
int len = strlen(path)+1;
|
|
char * ret = malloc(len);
|
|
char * cp = ret;
|
|
|
|
memset(ret,0,len);
|
|
|
|
len = 0;
|
|
|
|
/* illeminate more than one '/' in a row, like "///" */
|
|
while(*path) {
|
|
while(*path=='/') path++;
|
|
if(*path=='.') {
|
|
/* we dont want to have hidden directoires, or '.' or
|
|
".." in our path */
|
|
free(ret);
|
|
return NULL;
|
|
}
|
|
while(*path && *path!='/') {
|
|
*(cp++) = *(path++);
|
|
len++;
|
|
}
|
|
if(*path=='/') {
|
|
*(cp++) = *(path++);
|
|
len++;
|
|
}
|
|
}
|
|
|
|
if(len && ret[len-1]=='/') {
|
|
len--;
|
|
ret[len] = '\0';
|
|
}
|
|
|
|
DEBUG("sanitized: %s\n", ret);
|
|
|
|
return realloc(ret,len+1);
|
|
}
|
|
|
|
char * prependCwdToPathDup(char * path) {
|
|
int len = MAXPATHLEN+1;
|
|
char * ret = malloc(len);
|
|
|
|
memset(ret,0,len);
|
|
|
|
len = 0;
|
|
|
|
if(path[0]=='/') {
|
|
strncpy(ret,path,MAXPATHLEN);
|
|
len = strlen(ret);
|
|
}
|
|
else {
|
|
getcwd(ret,MAXPATHLEN);
|
|
len = strlen(ret);
|
|
if(ret[len-1]!='/') {
|
|
strncat(ret,"/",MAXPATHLEN-len);
|
|
len = strlen(ret);
|
|
}
|
|
strncat(ret,path,MAXPATHLEN-len);
|
|
len = strlen(ret);
|
|
}
|
|
if(ret[len-1]!='/') {
|
|
strncat(ret,"/",MAXPATHLEN-len);
|
|
len = strlen(ret);
|
|
}
|
|
|
|
return realloc(ret,len+1);
|
|
}
|