oysteikt/mpd
0
0
Fork 0
Code Issues Pull Requests Releases Activity

path: moved playlist_dir to mapper.c

Browse Source 
Added the function map_spl_utf8_to_fs() which replaces
utf8_to_fs_playlist_path().
This commit is contained in:
Max Kellermann 2008-10-31 16:47:14 +01:00
parent ef54271619
commit d8e877e335
7 changed files with 81 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
src/mapper.c
View File

@ -34,9 +34,13 @@
static char *music_dir;
static size_t music_dir_length;
static char *playlist_dir;
static size_t playlist_dir_length;
void mapper_init(void)
{
ConfigParam *music_dir_param = parseConfigFilePath(CONF_MUSIC_DIR, 1);
ConfigParam *playlist_dir_param = parseConfigFilePath(CONF_PLAYLIST_DIR, 1);
int ret;
struct stat st;
@ -51,11 +55,24 @@ void mapper_init(void)
else if (!S_ISDIR(st.st_mode))
g_warning("music directory is not a directory: \"%s\" (config line %i)\n",
music_dir_param->value, music_dir_param->line);
playlist_dir = g_strdup(playlist_dir_param->value);
playlist_dir_length = strlen(playlist_dir);
ret = stat(playlist_dir, &st);
if (ret < 0)
g_warning("failed to stat playlist directory \"%s\" (config line %i): %s\n",
playlist_dir_param->value, playlist_dir_param->line,
strerror(errno));
else if (!S_ISDIR(st.st_mode))
g_warning("playlist directory is not a directory: \"%s\" (config line %i)\n",
playlist_dir_param->value, playlist_dir_param->line);
}
void mapper_finish(void)
{
g_free(music_dir);
g_free(playlist_dir);
}
static char *
@ -117,3 +134,24 @@ map_fs_to_utf8(const char *path_fs, char *buffer)
return fs_charset_to_utf8(buffer, path_fs);
}
static char *rpp2app_r(char *dst, const char *rel_path)
{
pfx_dir(dst, rel_path, strlen(rel_path),
playlist_dir, playlist_dir_length);
return dst;
}
const char *
map_spl_path(void)
{
return playlist_dir;
}
const char *
map_spl_utf8_to_fs(const char *name, char *buffer)
{
rpp2app_r(buffer, utf8_to_fs_charset(buffer, name));
g_strlcat(buffer, "." PLAYLIST_FILE_SUFFIX, MPD_PATH_MAX);
return buffer;
}

15
src/mapper.h
View File

@ -23,6 +23,8 @@
#ifndef MPD_MAPPER_H
#define MPD_MAPPER_H
#define PLAYLIST_FILE_SUFFIX "m3u"
struct directory;
struct song;
@ -75,4 +77,17 @@ map_song_fs(const struct song *song, char *buffer);
const char *
map_fs_to_utf8(const char *path_fs, char *buffer);
/**
* Returns the playlist directory.
*/
const char *
map_spl_path(void);
/**
* Maps a playlist name (without the ".m3u" suffix) to a file system
* path.
*/
const char *
map_spl_utf8_to_fs(const char *name, char *buffer);
#endif

28
src/path.c
View File

@ -32,8 +32,6 @@
#include <glib.h>
static const char *playlistDir;
static size_t playlist_dir_len;
static char *fsCharset;
char *fs_charset_to_utf8(char *dst, const char *str)
@ -99,22 +97,10 @@ const char *getFsCharset(void)
void initPaths(void)
{
ConfigParam *playlistParam = parseConfigFilePath(CONF_PLAYLIST_DIR, 1);
ConfigParam *fsCharsetParam = getConfigParam(CONF_FS_CHARSET);
char *charset = NULL;
char *originalLocale;
DIR *dir;
playlistDir = xstrdup(playlistParam->value);
playlist_dir_len = strlen(playlistDir);
if ((dir = opendir(playlistDir)) == NULL) {
ERROR("cannot open %s \"%s\" (config line %i): %s\n",
CONF_PLAYLIST_DIR, playlistParam->value,
playlistParam->line, strerror(errno));
} else
closedir(dir);
if (fsCharsetParam) {
charset = xstrdup(fsCharsetParam->value);
@ -183,13 +169,6 @@ char *pfx_dir(char *dst,
return (dst + pfx_len + 1);
}
char *rpp2app_r(char *dst, const char *rel_path)
{
pfx_dir(dst, rel_path, strlen(rel_path),
(const char *)playlistDir, playlist_dir_len);
return dst;
}
char *sanitizePathDup(const char *path)
{
int len = strlen(path) + 1;
@ -229,10 +208,3 @@ char *sanitizePathDup(const char *path)
return xrealloc(ret, len + 1);
}
void utf8_to_fs_playlist_path(char *path_max_tmp, const char *utf8path)
{
utf8_to_fs_charset(path_max_tmp, utf8path);
rpp2app_r(path_max_tmp, path_max_tmp);
strncat(path_max_tmp, "." PLAYLIST_FILE_SUFFIX, MPD_PATH_MAX - 1);
}

9
src/path.h
View File

@ -55,16 +55,7 @@ char *pfx_dir(char *dst,
const char *path, const size_t path_len,
const char *pfx, const size_t pfx_len);
/* relative playlist path to absolute playlist path */
char *rpp2app_r(char *dst, const char *rel_path);
/* strips extra "///" and leading "/" and trailing "/" */
char *sanitizePathDup(const char *path);
/*
* converts a path passed from a client into an absolute FS path.
* paths passed by clients do NOT have file suffixes in them
*/
void utf8_to_fs_playlist_path(char *path_max_tmp, const char *utf8path);
#endif

7
src/playlist.c
View File

@ -1190,15 +1190,16 @@ enum playlist_result savePlaylist(const char *utf8file)
FILE *fp;
struct stat sb;
char path_max_tmp[MPD_PATH_MAX];
const char *path;
if (!is_valid_playlist_name(utf8file))
return PLAYLIST_RESULT_BAD_NAME;
utf8_to_fs_playlist_path(path_max_tmp, utf8file);
if (!stat(path_max_tmp, &sb))
path = map_spl_utf8_to_fs(utf8file, path_max_tmp);
if (!stat(path, &sb))
return PLAYLIST_RESULT_LIST_EXISTS;
while (!(fp = fopen(path_max_tmp, "w")) && errno == EINTR);
while (!(fp = fopen(path, "w")) && errno == EINTR);
if (fp == NULL)
return PLAYLIST_RESULT_ERRNO;

1
src/playlist.h
View File

@ -24,7 +24,6 @@
#include <stdbool.h>
#include <stdio.h>
#define PLAYLIST_FILE_SUFFIX "m3u"
#define PLAYLIST_COMMENT '#'
struct client;

41
src/stored_playlist.c
View File

@ -70,13 +70,12 @@ load_playlist_info(const char *parent_path_fs, const char *name_fs)
GPtrArray *
spl_list(void)
{
char parent_path_fs[MPD_PATH_MAX];
const char *parent_path_fs = map_spl_path();
DIR *dir;
struct dirent *ent;
GPtrArray *list;
struct stored_playlist_info *playlist;
rpp2app_r(parent_path_fs, "");
dir = opendir(parent_path_fs);
if (dir == NULL)
return NULL;
@ -111,12 +110,13 @@ spl_save(GPtrArray *list, const char *utf8path)
{
FILE *file;
char path_max_tmp[MPD_PATH_MAX];
const char *path_fs;
assert(utf8path != NULL);
utf8_to_fs_playlist_path(path_max_tmp, utf8path);
path_fs = map_spl_utf8_to_fs(utf8path, path_max_tmp);
while (!(file = fopen(path_max_tmp, "w")) && errno == EINTR);
while (!(file = fopen(path_fs, "w")) && errno == EINTR);
if (file == NULL)
return PLAYLIST_RESULT_ERRNO;
@ -136,12 +136,14 @@ spl_load(const char *utf8path)
GPtrArray *list;
char buffer[MPD_PATH_MAX];
char path_max_tmp[MPD_PATH_MAX];
const char *path_fs;
if (!is_valid_playlist_name(utf8path))
return NULL;
utf8_to_fs_playlist_path(path_max_tmp, utf8path);
while (!(file = fopen(path_max_tmp, "r")) && errno == EINTR);
path_fs = map_spl_utf8_to_fs(utf8path, path_max_tmp);
while (!(file = fopen(path_fs, "r")) && errno == EINTR);
if (file == NULL)
return NULL;
@ -248,14 +250,15 @@ enum playlist_result
spl_clear(const char *utf8path)
{
char filename[MPD_PATH_MAX];
const char *path_fs;
FILE *file;
if (!is_valid_playlist_name(utf8path))
return PLAYLIST_RESULT_BAD_NAME;
utf8_to_fs_playlist_path(filename, utf8path);
path_fs = map_spl_utf8_to_fs(utf8path, filename);
while (!(file = fopen(filename, "w")) && errno == EINTR);
while (!(file = fopen(path_fs, "w")) && errno == EINTR);
if (file == NULL)
return PLAYLIST_RESULT_ERRNO;
@ -269,10 +272,11 @@ enum playlist_result
spl_delete(const char *name_utf8)
{
char filename[MPD_PATH_MAX];
const char *path_fs;
utf8_to_fs_playlist_path(filename, name_utf8);
path_fs = map_spl_utf8_to_fs(name_utf8, filename);
if (unlink(filename) < 0)
if (unlink(path_fs) < 0)
return errno == ENOENT
? PLAYLIST_RESULT_NO_SUCH_LIST
: PLAYLIST_RESULT_ERRNO;
@ -312,12 +316,14 @@ spl_append_song(const char *utf8path, struct song *song)
FILE *file;
struct stat st;
char path_max_tmp[MPD_PATH_MAX];
const char *path_fs;
if (!is_valid_playlist_name(utf8path))
return PLAYLIST_RESULT_BAD_NAME;
utf8_to_fs_playlist_path(path_max_tmp, utf8path);
while (!(file = fopen(path_max_tmp, "a")) && errno == EINTR);
path_fs = map_spl_utf8_to_fs(utf8path, path_max_tmp);
while (!(file = fopen(path_fs, "a")) && errno == EINTR);
if (file == NULL) {
int save_errno = errno;
while (fclose(file) != 0 && errno == EINTR);
@ -373,21 +379,22 @@ spl_rename(const char *utf8from, const char *utf8to)
struct stat st;
char from[MPD_PATH_MAX];
char to[MPD_PATH_MAX];
const char *from_path_fs, *to_path_fs;
if (!is_valid_playlist_name(utf8from) ||
!is_valid_playlist_name(utf8to))
return PLAYLIST_RESULT_BAD_NAME;
utf8_to_fs_playlist_path(from, utf8from);
utf8_to_fs_playlist_path(to, utf8to);
from_path_fs = map_spl_utf8_to_fs(utf8from, from);
to_path_fs = map_spl_utf8_to_fs(utf8to, to);
if (stat(from, &st) != 0)
if (stat(from_path_fs, &st) != 0)
return PLAYLIST_RESULT_NO_SUCH_LIST;
if (stat(to, &st) == 0)
if (stat(to_path_fs, &st) == 0)
return PLAYLIST_RESULT_LIST_EXISTS;
if (rename(from, to) < 0)
if (rename(from_path_fs, to_path_fs) < 0)
return PLAYLIST_RESULT_ERRNO;
idle_add(IDLE_STORED_PLAYLIST);