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

interface/connection malloc reductions from mpd-ke 

This patch massively reduces the amount of heap allocations at
the interface/command layer.  Most commands with minimal output
should not allocate memory from the heap at all.  Things like
repeatedly polling status, currentsong, and volume changes
should be faster as a result, and more importantly, not a source
of memory fragmentation.

These changes should be safe in that there's no way for a
remote-client to corrupt memory or otherwise do bad stuff to
MPD, but an extra set of eyes to review would be good.  Of
course there's never any warranty :)

No longer do we use FILE * structures in the interface, which means
we don't have to allocate any new memory for most connections.

Now, before you go on about losing the buffering that FILE *
+implies+, remember that myfprintf() never took advantage of
any of the stdio buffering features.

To reduce the diff and make bugs easier to spot in the diff,
I've kept myfprintf in places where we write to files (and not
network interfaces).  Expect myfprintf to go away entirely soon
(we'll use fprintf for writing regular files).

git-svn-id: https://svn.musicpd.org/mpd/trunk@4483 09075e82-0dd4-0310-85a5-a0d7c8717e4f
This commit is contained in:
Eric Wong 2006-07-30 03:43:38 +00:00
parent 4d5b8509eb
commit 4cf5d04ca1
32 changed files with 1080 additions and 800 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/Makefile.am
View File

@ -35,6 +35,7 @@ mpd_headers = \
dbUtils.h \
decode.h \
directory.h \
gcc.h \
inputPlugin.h \
inputPlugins/_flac_common.h \
inputPlugins/_ogg_common.h \
@ -61,6 +62,7 @@ mpd_headers = \
replayGain.h \
signal_check.h \
sig_handlers.h \
sllist.h \
song.h \
stats.h \
tag.h \
@ -107,6 +109,7 @@ mpd_SOURCES = \
replayGain.c \
sig_handlers.c \
signal_check.c \
sllist.c \
song.c \
stats.c \
tag.c \

19
src/audio.c
View File

@ -423,10 +423,10 @@ void sendMetadataToAudioDevice(MpdTag * tag)
}
}
int enableAudioDevice(FILE * fp, int device)
int enableAudioDevice(int fd, int device)
{
if (device < 0 || device >= audioOutputArraySize) {
commandError(fp, ACK_ERROR_ARG, "audio output device id %i "
commandError(fd, ACK_ERROR_ARG, "audio output device id %i "
"doesn't exist\n", device);
return -1;
}
@ -436,10 +436,10 @@ int enableAudioDevice(FILE * fp, int device)
return 0;
}
int disableAudioDevice(FILE * fp, int device)
int disableAudioDevice(int fd, int device)
{
if (device < 0 || device >= audioOutputArraySize) {
commandError(fp, ACK_ERROR_ARG, "audio output device id %i "
commandError(fd, ACK_ERROR_ARG, "audio output device id %i "
"doesn't exist\n", device);
return -1;
}
@ -449,15 +449,16 @@ int disableAudioDevice(FILE * fp, int device)
return 0;
}
void printAudioDevices(FILE * fp)
void printAudioDevices(int fd)
{
int i;
for (i = 0; i < audioOutputArraySize; i++) {
myfprintf(fp, "outputid: %i\n", i);
myfprintf(fp, "outputname: %s\n", audioOutputArray[i]->name);
myfprintf(fp, "outputenabled: %i\n",
(int)pdAudioDevicesEnabled[i]);
fdprintf(fd,
"outputid: %i\noutputname: %s\noutputenabled: %i\n",
i,
audioOutputArray[i]->name,
(int)pdAudioDevicesEnabled[i]);
}
}

6
src/audio.h
View File

@ -69,11 +69,11 @@ void sendMetadataToAudioDevice(MpdTag * tag);
/* these functions are called in the main parent process while the child
process is busy playing to the audio */
int enableAudioDevice(FILE * fp, int device);
int enableAudioDevice(int fd, int device);
int disableAudioDevice(FILE * fp, int device);
int disableAudioDevice(int fd, int device);
void printAudioDevices(FILE * fp);
void printAudioDevices(int fd);
void readAudioDevicesState();

518
src/command.c
View File

File diff suppressed because it is too large Load Diff

21
src/command.h
View File

@ -25,7 +25,9 @@
#include "myfprintf.h"
#include "log.h"
#include "ack.h"
#include "sllist.h"
#include <unistd.h>
#include <stdio.h>
#define COMMAND_RETURN_KILL 10
@ -35,30 +37,29 @@
extern char *current_command;
extern int command_listNum;
int processListOfCommands(FILE * fp, int *permission, int *expired,
int listOK, List * list);
int processListOfCommands(int fd, int *permission, int *expired,
int listOK, struct strnode *list);
int processCommand(FILE * fp, int *permission, char *commandString);
int processCommand(int fd, int *permission, char *commandString);
void initCommands();
void finishCommands();
#define commandSuccess(fp) myfprintf(fp, "OK\n")
#define commandSuccess(fd) fdprintf(fd, "OK\n")
#define commandError(fp, error, format, ... ) \
#define commandError(fd, error, format, ... ) do \
{\
if(current_command) { \
myfprintf(fp, "ACK [%i@%i] {%s} " format "\n", \
if (current_command) { \
fdprintf(fd, "ACK [%i@%i] {%s} " format "\n", \
(int)error, command_listNum, \
current_command, __VA_ARGS__); \
current_command = NULL; \
} \
else { \
myfprintf(stderr, "ACK [%i@%i] " format "\n", \
fdprintf(STDERR_FILENO, "ACK [%i@%i] " format "\n", \
(int)error, command_listNum, \
__VA_ARGS__); \
} \
}
} while (0)
#endif

76
src/dbUtils.c
View File

@ -134,7 +134,7 @@ void freeLocateTagItem(LocateTagItem * item)
free(item);
}
static int countSongsInDirectory(FILE * fp, Directory * directory, void *data)
static int countSongsInDirectory(int fd, Directory * directory, void *data)
{
int *count = (int *)data;
@ -143,18 +143,18 @@ static int countSongsInDirectory(FILE * fp, Directory * directory, void *data)
return 0;
}
static int printDirectoryInDirectory(FILE * fp, Directory * directory,
static int printDirectoryInDirectory(int fd, Directory * directory,
void *data)
{
if (directory->path) {
myfprintf(fp, "directory: %s\n", getDirectoryPath(directory));
fdprintf(fd, "directory: %s\n", getDirectoryPath(directory));
}
return 0;
}
static int printSongInDirectory(FILE * fp, Song * song, void *data)
static int printSongInDirectory(int fd, Song * song, void *data)
{
printSongUrl(fp, song);
printSongUrl(fd, song);
return 0;
}
@ -192,7 +192,7 @@ static int strstrSearchTag(Song * song, int type, char *str)
return ret;
}
static int searchInDirectory(FILE * fp, Song * song, void *data)
static int searchInDirectory(int fd, Song * song, void *data)
{
LocateTagItemArray *array = data;
int i;
@ -204,12 +204,12 @@ static int searchInDirectory(FILE * fp, Song * song, void *data)
}
}
printSongInfo(fp, song);
printSongInfo(fd, song);
return 0;
}
int searchForSongsIn(FILE * fp, char *name, int numItems, LocateTagItem * items)
int searchForSongsIn(int fd, char *name, int numItems, LocateTagItem * items)
{
int ret = -1;
int i;
@ -225,7 +225,7 @@ int searchForSongsIn(FILE * fp, char *name, int numItems, LocateTagItem * items)
array.numItems = numItems;
array.items = items;
ret = traverseAllIn(fp, name, searchInDirectory, NULL, &array);
ret = traverseAllIn(fd, name, searchInDirectory, NULL, &array);
for (i = 0; i < numItems; i++) {
free(items[i].needle);
@ -260,7 +260,7 @@ static int tagItemFoundAndMatches(Song * song, int type, char *str)
return 0;
}
static int findInDirectory(FILE * fp, Song * song, void *data)
static int findInDirectory(int fd, Song * song, void *data)
{
LocateTagItemArray *array = data;
int i;
@ -272,43 +272,43 @@ static int findInDirectory(FILE * fp, Song * song, void *data)
}
}
printSongInfo(fp, song);
printSongInfo(fd, song);
return 0;
}
int findSongsIn(FILE * fp, char *name, int numItems, LocateTagItem * items)
int findSongsIn(int fd, char *name, int numItems, LocateTagItem * items)
{
LocateTagItemArray array;
array.numItems = numItems;
array.items = items;
return traverseAllIn(fp, name, findInDirectory, NULL, (void *)&array);
return traverseAllIn(fd, name, findInDirectory, NULL, (void *)&array);
}
int printAllIn(FILE * fp, char *name)
int printAllIn(int fd, char *name)
{
return traverseAllIn(fp, name, printSongInDirectory,
return traverseAllIn(fd, name, printSongInDirectory,
printDirectoryInDirectory, NULL);
}
static int directoryAddSongToPlaylist(FILE * fp, Song * song, void *data)
static int directoryAddSongToPlaylist(int fd, Song * song, void *data)
{
return addSongToPlaylist(fp, song, 0);
return addSongToPlaylist(fd, song, 0);
}
int addAllIn(FILE * fp, char *name)
int addAllIn(int fd, char *name)
{
return traverseAllIn(fp, name, directoryAddSongToPlaylist, NULL, NULL);
return traverseAllIn(fd, name, directoryAddSongToPlaylist, NULL, NULL);
}
static int directoryPrintSongInfo(FILE * fp, Song * song, void *data)
static int directoryPrintSongInfo(int fd, Song * song, void *data)
{
return printSongInfo(fp, song);
return printSongInfo(fd, song);
}
static int sumSongTime(FILE * fp, Song * song, void *data)
static int sumSongTime(int fd, Song * song, void *data)
{
unsigned long *time = (unsigned long *)data;
@ -318,28 +318,28 @@ static int sumSongTime(FILE * fp, Song * song, void *data)
return 0;
}
int printInfoForAllIn(FILE * fp, char *name)
int printInfoForAllIn(int fd, char *name)
{
return traverseAllIn(fp, name, directoryPrintSongInfo,
return traverseAllIn(fd, name, directoryPrintSongInfo,
printDirectoryInDirectory, NULL);
}
int countSongsIn(FILE * fp, char *name)
int countSongsIn(int fd, char *name)
{
int count = 0;
void *ptr = (void *)&count;
traverseAllIn(fp, name, NULL, countSongsInDirectory, ptr);
traverseAllIn(fd, name, NULL, countSongsInDirectory, ptr);
return count;
}
unsigned long sumSongTimesIn(FILE * fp, char *name)
unsigned long sumSongTimesIn(int fd, char *name)
{
unsigned long dbPlayTime = 0;
void *ptr = (void *)&dbPlayTime;
traverseAllIn(fp, name, sumSongTime, NULL, ptr);
traverseAllIn(fd, name, sumSongTime, NULL, ptr);
return dbPlayTime;
}
@ -361,13 +361,13 @@ static void freeListCommandItem(ListCommandItem * item)
free(item);
}
static void visitTag(FILE * fp, Song * song, int tagType)
static void visitTag(int fd, Song * song, int tagType)
{
int i;
MpdTag *tag = song->tag;
if (tagType == LOCATE_TAG_FILE_TYPE) {
printSongUrl(fp, song);
printSongUrl(fd, song);
return;
}
@ -381,7 +381,7 @@ static void visitTag(FILE * fp, Song * song, int tagType)
}
}
static int listUniqueTagsInDirectory(FILE * fp, Song * song, void *data)
static int listUniqueTagsInDirectory(int fd, Song * song, void *data)
{
ListCommandItem *item = data;
int i;
@ -393,12 +393,12 @@ static int listUniqueTagsInDirectory(FILE * fp, Song * song, void *data)
}
}
visitTag(fp, song, item->tagType);
visitTag(fd, song, item->tagType);
return 0;
}
int listAllUniqueTags(FILE * fp, int type, int numConditionals,
int listAllUniqueTags(int fd, int type, int numConditionals,
LocateTagItem * conditionals)
{
int ret;
@ -409,11 +409,11 @@ int listAllUniqueTags(FILE * fp, int type, int numConditionals,
resetVisitedFlagsInTagTracker(type);
}
ret = traverseAllIn(fp, NULL, listUniqueTagsInDirectory, NULL,
ret = traverseAllIn(fd, NULL, listUniqueTagsInDirectory, NULL,
(void *)item);
if (type >= 0 && type <= TAG_NUM_OF_ITEM_TYPES) {
printVisitedInTagTracker(fp, type);
printVisitedInTagTracker(fd, type);
}
freeListCommandItem(item);
@ -421,7 +421,7 @@ int listAllUniqueTags(FILE * fp, int type, int numConditionals,
return ret;
}
static int sumSavedFilenameMemoryInDirectory(FILE * fp, Directory * dir,
static int sumSavedFilenameMemoryInDirectory(int fd, Directory * dir,
void *data)
{
int *sum = data;
@ -435,7 +435,7 @@ static int sumSavedFilenameMemoryInDirectory(FILE * fp, Directory * dir,
return 0;
}
static int sumSavedFilenameMemoryInSong(FILE * fp, Song * song, void *data)
static int sumSavedFilenameMemoryInSong(int fd, Song * song, void *data)
{
int *sum = data;
@ -448,7 +448,7 @@ void printSavedMemoryFromFilenames(void)
{
int sum = 0;
traverseAllIn(stderr, NULL, sumSavedFilenameMemoryInSong,
traverseAllIn(STDERR_FILENO, NULL, sumSavedFilenameMemoryInSong,
sumSavedFilenameMemoryInDirectory, (void *)&sum);
DEBUG("saved memory from filenames: %i\n", sum);

16
src/dbUtils.h
View File

@ -43,22 +43,22 @@ void freeLocateTagItemArray(int count, LocateTagItem * array);
void freeLocateTagItem(LocateTagItem * item);
int printAllIn(FILE * fp, char *name);
int printAllIn(int fd, char *name);
int addAllIn(FILE * fp, char *name);
int addAllIn(int fd, char *name);
int printInfoForAllIn(FILE * fp, char *name);
int printInfoForAllIn(int fd, char *name);
int searchForSongsIn(FILE * fp, char *name, int numItems,
int searchForSongsIn(int fd, char *name, int numItems,
LocateTagItem * items);
int findSongsIn(FILE * fp, char *name, int numItems, LocateTagItem * items);
int findSongsIn(int fd, char *name, int numItems, LocateTagItem * items);
int countSongsIn(FILE * fp, char *name);
int countSongsIn(int fd, char *name);
unsigned long sumSongTimesIn(FILE * fp, char *name);
unsigned long sumSongTimesIn(int fd, char *name);
int listAllUniqueTags(FILE * fp, int type, int numConditiionals,
int listAllUniqueTags(int fd, int type, int numConditiionals,
LocateTagItem * conditionals);
void printSavedMemoryFromFilenames();

54
src/directory.c
View File

@ -159,10 +159,10 @@ void readDirectoryDBIfUpdateIsFinished()
}
}
int updateInit(FILE * fp, List * pathList)
int updateInit(int fd, List * pathList)
{
if (directory_updatePid > 0) {
commandError(fp, ACK_ERROR_UPDATE_ALREADY, "already updating",
commandError(fd, ACK_ERROR_UPDATE_ALREADY, "already updating",
NULL);
return -1;
}
@ -216,7 +216,7 @@ int updateInit(FILE * fp, List * pathList)
} else if (directory_updatePid < 0) {
unblockSignals();
ERROR("updateInit: Problems forking()'ing\n");
commandError(fp, ACK_ERROR_SYSTEM,
commandError(fd, ACK_ERROR_SYSTEM,
"problems trying to update", NULL);
directory_updatePid = 0;
return -1;
@ -228,7 +228,7 @@ int updateInit(FILE * fp, List * pathList)
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);
fdprintf(fd, "updating_db: %i\n", (int)directory_updateJobId);
return 0;
}
@ -871,33 +871,33 @@ static Directory *getDirectory(char *name)
return getSubDirectory(mp3rootDirectory, name, &shortname);
}
static int printDirectoryList(FILE * fp, DirectoryList * directoryList)
static int printDirectoryList(int fd, DirectoryList * directoryList)
{
ListNode *node = directoryList->firstNode;
Directory *directory;
while (node != NULL) {
directory = (Directory *) node->data;
myfprintf(fp, "%s%s\n", DIRECTORY_DIR,
getDirectoryPath(directory));
fdprintf(fd, "%s%s\n", DIRECTORY_DIR,
getDirectoryPath(directory));
node = node->nextNode;
}
return 0;
}
int printDirectoryInfo(FILE * fp, char *name)
int printDirectoryInfo(int fd, char *name)
{
Directory *directory;
if ((directory = getDirectory(name)) == NULL) {
commandError(fp, ACK_ERROR_NO_EXIST, "directory not found",
commandError(fd, ACK_ERROR_NO_EXIST, "directory not found",
NULL);
return -1;
}
printDirectoryList(fp, directory->subDirectories);
printSongInfoFromList(fp, directory->songs);
printDirectoryList(fd, directory->subDirectories);
printSongInfoFromList(fd, directory->songs);
return 0;
}
@ -1208,8 +1208,8 @@ int readDirectoryDB()
readDirectoryInfo(fp, mp3rootDirectory);
while (fclose(fp) && errno == EINTR) ;
stats.numberOfSongs = countSongsIn(stderr, NULL);
stats.dbPlayTime = sumSongTimesIn(stderr, NULL);
stats.numberOfSongs = countSongsIn(STDERR_FILENO, NULL);
stats.dbPlayTime = sumSongTimesIn(STDERR_FILENO, NULL);
if (stat(dbFile, &st) == 0)
directory_dbModTime = st.st_mtime;
@ -1237,10 +1237,10 @@ void updateMp3Directory()
return;
}
static int traverseAllInSubDirectory(FILE * fp, Directory * directory,
int (*forEachSong) (FILE *, Song *,
static int traverseAllInSubDirectory(int fd, Directory * directory,
int (*forEachSong) (int, Song *,
void *),
int (*forEachDir) (FILE *, Directory *,
int (*forEachDir) (int, Directory *,
void *), void *data)
{
ListNode *node = directory->songs->firstNode;
@ -1249,7 +1249,7 @@ static int traverseAllInSubDirectory(FILE * fp, Directory * directory,
int errFlag = 0;
if (forEachDir) {
errFlag = forEachDir(fp, directory, data);
errFlag = forEachDir(fd, directory, data);
if (errFlag)
return errFlag;
}
@ -1257,7 +1257,7 @@ static int traverseAllInSubDirectory(FILE * fp, Directory * directory,
if (forEachSong) {
while (node != NULL && !errFlag) {
song = (Song *) node->data;
errFlag = forEachSong(fp, song, data);
errFlag = forEachSong(fd, song, data);
node = node->nextNode;
}
if (errFlag)
@ -1268,7 +1268,7 @@ static int traverseAllInSubDirectory(FILE * fp, Directory * directory,
while (node != NULL && !errFlag) {
dir = (Directory *) node->data;
errFlag = traverseAllInSubDirectory(fp, dir, forEachSong,
errFlag = traverseAllInSubDirectory(fd, dir, forEachSong,
forEachDir, data);
node = node->nextNode;
}
@ -1276,23 +1276,23 @@ static int traverseAllInSubDirectory(FILE * fp, Directory * directory,
return errFlag;
}
int traverseAllIn(FILE * fp, char *name,
int (*forEachSong) (FILE *, Song *, void *),
int (*forEachDir) (FILE *, Directory *, void *), void *data)
int traverseAllIn(int fd, char *name,
int (*forEachSong) (int, Song *, void *),
int (*forEachDir) (int, Directory *, void *), void *data)
{
Directory *directory;
if ((directory = getDirectory(name)) == NULL) {
Song *song;
if ((song = getSongFromDB(name)) && forEachSong) {
return forEachSong(fp, song, data);
return forEachSong(fd, song, data);
}
commandError(fp, ACK_ERROR_NO_EXIST,
commandError(fd, ACK_ERROR_NO_EXIST,
"directory or file not found", NULL);
return -1;
}
return traverseAllInSubDirectory(fp, directory, forEachSong, forEachDir,
return traverseAllInSubDirectory(fd, directory, forEachSong, forEachDir,
data);
}
@ -1315,8 +1315,8 @@ void initMp3Directory()
mp3rootDirectory = newDirectory(NULL, NULL);
exploreDirectory(mp3rootDirectory);
freeAllDirectoryStats(mp3rootDirectory);
stats.numberOfSongs = countSongsIn(stderr, NULL);
stats.dbPlayTime = sumSongTimesIn(stderr, NULL);
stats.numberOfSongs = countSongsIn(STDERR_FILENO, NULL);
stats.dbPlayTime = sumSongTimesIn(STDERR_FILENO, NULL);
if (stat(getDbFile(), &st) == 0)
directory_dbModTime = st.st_mtime;

10
src/directory.h
View File

@ -45,13 +45,13 @@ int isUpdatingDB();
void directory_sigChldHandler(int pid, int status);
int updateInit(FILE * fp, List * pathList);
int updateInit(int fd, List * pathList);
void initMp3Directory();
void closeMp3Directory();
int printDirectoryInfo(FILE * fp, char *dirname);
int printDirectoryInfo(int fd, char *dirname);
int checkDirectoryDB();
@ -65,9 +65,9 @@ Song *getSongFromDB(char *file);
time_t getDbModTime();
int traverseAllIn(FILE * fp, char *name,
int (*forEachSong) (FILE *, Song *, void *),
int (*forEachDir) (FILE *, Directory *, void *), void *data);
int traverseAllIn(int fd, char *name,
int (*forEachSong) (int, Song *, void *),
int (*forEachDir) (int, Directory *, void *), void *data);
#define getDirectoryPath(dir) ((dir && dir->path) ? dir->path : "")

50
src/gcc.h Normal file
View File

@ -0,0 +1,50 @@
#ifndef MPD_GCC_H
#define MPD_GCC_H
/* this allows us to take advantage of special gcc features while still
* allowing other compilers to compile:
*
* example taken from: http://rlove.org/log/2005102601
*/
/* disabled (0) until I fix all the warnings :) */
#if (0 && __GNUC__ >= 3)
# define mpd_const __attribute__ ((const))
# define mpd_deprecated __attribute__ ((deprecated))
# define mpd_malloc __attribute__ ((malloc))
# define mpd_must_check __attribute__ ((warn_unused_result))
# define mpd_noreturn __attribute__ ((noreturn))
# define mpd_packed __attribute__ ((packed))
/* these are very useful for type checking */
# define mpd_printf __attribute__ ((format(printf,1,2)))
# define mpd_fprintf __attribute__ ((format(printf,2,3)))
# define mpd_fprintf_ __attribute__ ((format(printf,3,4)))
# define mpd_pure __attribute__ ((pure))
# define mpd_scanf __attribute__ ((format(scanf,1,2)))
# define mpd_unused __attribute__ ((unused))
# define mpd_used __attribute__ ((used))
/* # define inline inline __attribute__ ((always_inline)) */
# define mpd_noinline __attribute__ ((noinline))
# define likely(x) __builtin_expect (!!(x), 1)
# define unlikely(x) __builtin_expect (!!(x), 0)
#else
# define mpd_const
# define mpd_deprecated
# define mpd_malloc
# define mpd_must_check
# define mpd_noreturn
# define mpd_packed
# define mpd_printf
# define mpd_fprintf
# define mpd_fprintf_
# define mpd_pure
# define mpd_scanf
# define mpd_unused
# define mpd_used
/* # define inline */
# define mpd_noinline
# define likely(x) (x)
# define unlikely(x) (x)
#endif
#endif /* MPD_GCC_H */

443
src/interface.c
View File

@ -24,7 +24,7 @@
#include "listen.h"
#include "playlist.h"
#include "permission.h"
#include "sig_handlers.h"
#include "sllist.h"
#include <stdio.h>
#include <stdlib.h>
@ -41,7 +41,7 @@
#include <errno.h>
#include <signal.h>
#define GREETING "OK MPD"
#define GREETING "OK MPD " VERSION "\n"
#define INTERFACE_MAX_BUFFER_LENGTH (40960)
#define INTERFACE_LIST_MODE_BEGIN "command_list_begin"
@ -61,26 +61,36 @@ static size_t interface_max_command_list_size =
static size_t interface_max_output_buffer_size =
INTERFACE_MAX_OUTPUT_BUFFER_SIZE_DEFAULT;
/* maybe make conf option for this, or... 32 might be good enough */
static long int interface_list_cache_size = 32;
/* shared globally between all interfaces: */
static struct strnode *list_cache = NULL;
static struct strnode *list_cache_head = NULL;
static struct strnode *list_cache_tail = NULL;
typedef struct _Interface {
char buffer[INTERFACE_MAX_BUFFER_LENGTH];
int bufferLength;
int bufferPos;
int fd; /* file descriptor */
FILE *fp; /* file pointer */
int open; /* open/used */
int permission;
time_t lastTime;
List *commandList; /* for when in list mode */
int commandListOK; /* print OK after each command execution */
size_t commandListSize; /* mem commandList consumes */
List *bufferList; /* for output if client is slow */
size_t outputBufferSize; /* mem bufferList consumes */
struct strnode *cmd_list; /* for when in list mode */
struct strnode *cmd_list_tail; /* for when in list mode */
int cmd_list_OK; /* print OK after each command execution */
int cmd_list_size; /* mem cmd_list consumes */
int cmd_list_dup; /* has the cmd_list been copied to private space? */
struct sllnode *deferred_send; /* for output if client is slow */
int deferred_bytes; /* mem deferred_send consumes */
int expired; /* set whether this interface should be closed on next
check of old interfaces */
int num; /* interface number */
char *outBuffer;
int outBuflen;
int outBufSize;
char *send_buf;
int send_buf_used; /* bytes used this instance */
int send_buf_size; /* bytes usable this instance */
int send_buf_alloc; /* bytes actually allocated */
} Interface;
static Interface *interfaces = NULL;
@ -89,66 +99,150 @@ static void flushInterfaceBuffer(Interface * interface);
static void printInterfaceOutBuffer(Interface * interface);
#ifdef SO_SNDBUF
static int get_default_snd_buf_size(Interface * interface)
{
int new_size;
socklen_t sockOptLen = sizeof(int);
if (getsockopt(interface->fd, SOL_SOCKET, SO_SNDBUF,
(char *)&new_size, &sockOptLen) < 0) {
DEBUG("problem getting sockets send buffer size\n");
return INTERFACE_DEFAULT_OUT_BUFFER_SIZE;
}
if (new_size > 0)
return new_size;
DEBUG("sockets send buffer size is not positive\n");
return INTERFACE_DEFAULT_OUT_BUFFER_SIZE;
}
#else /* !SO_SNDBUF */
static int get_default_snd_buf_size(Interface * interface)
{
return INTERFACE_DEFAULT_OUT_BUFFER_SIZE;
}
#endif /* !SO_SNDBUF */
static void set_send_buf_size(Interface * interface)
{
int new_size = get_default_snd_buf_size(interface);
if (interface->send_buf_size != new_size) {
interface->send_buf_size = new_size;
/* don't resize to get smaller, only bigger */
if (interface->send_buf_alloc < new_size) {
if (interface->send_buf)
free(interface->send_buf);
interface->send_buf = malloc(new_size);
interface->send_buf_alloc = new_size;
}
}
}
static void openInterface(Interface * interface, int fd)
{
int flags;
assert(interface->open == 0);
assert(interface->fd < 0);
interface->cmd_list_size = 0;
interface->cmd_list_dup = 0;
interface->cmd_list_OK = -1;
interface->bufferLength = 0;
interface->bufferPos = 0;
interface->fd = fd;
/* fcntl(interface->fd,F_SETOWN,(int)getpid()); */
while ((flags = fcntl(fd, F_GETFL)) < 0 && errno == EINTR) ;
flags |= O_NONBLOCK;
while (fcntl(interface->fd, F_SETFL, flags) < 0 && errno == EINTR) ;
while ((interface->fp = fdopen(fd, "rw")) == NULL && errno == EINTR) ;
interface->open = 1;
while (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0 && errno == EINTR) ;
interface->lastTime = time(NULL);
interface->commandList = NULL;
interface->bufferList = NULL;
interface->cmd_list = NULL;
interface->cmd_list_tail = NULL;
interface->deferred_send = NULL;
interface->expired = 0;
interface->outputBufferSize = 0;
interface->outBuflen = 0;
interface->deferred_bytes = 0;
interface->send_buf_used = 0;
interface->permission = getDefaultPermissions();
set_send_buf_size(interface);
interface->outBufSize = INTERFACE_DEFAULT_OUT_BUFFER_SIZE;
#ifdef SO_SNDBUF
{
int getSize;
unsigned int sockOptLen = sizeof(int);
xwrite(fd, GREETING, strlen(GREETING));
}
if (getsockopt(interface->fd, SOL_SOCKET, SO_SNDBUF,
(char *)&getSize, &sockOptLen) < 0) {
DEBUG("problem getting sockets send buffer size\n");
} else if (getSize <= 0) {
DEBUG("sockets send buffer size is not positive\n");
static void free_cmd_list(struct strnode *list)
{
struct strnode *tmp = list;
while (tmp) {
struct strnode *next = tmp->next;
if (tmp >= list_cache_head && tmp <= list_cache_tail) {
/* inside list_cache[] array */
tmp->data = NULL;
tmp->next = NULL;
} else
interface->outBufSize = getSize;
free(tmp);
tmp = next;
}
#endif
interface->outBuffer = malloc(interface->outBufSize);
}
myfprintf(interface->fp, "%s %s\n", GREETING, VERSION);
printInterfaceOutBuffer(interface);
static void cmd_list_clone(Interface * interface)
{
struct strnode *new = dup_strlist(interface->cmd_list);
free_cmd_list(interface->cmd_list);
interface->cmd_list = new;
interface->cmd_list_dup = 1;
/* new tail */
while (new && new->next)
new = new->next;
interface->cmd_list_tail = new;
}
static void new_cmd_list_ptr(Interface * interface, char *s, const int size)
{
int i;
struct strnode *new;
if (!interface->cmd_list_dup) {
for (i = interface_list_cache_size - 1; i >= 0; --i) {
if (list_cache[i].data)
continue;
new = &(list_cache[i]);
new->data = s;
/* implied in free_cmd_list() and init: */
/* last->next->next = NULL; */
goto out;
}
}
/* allocate from the heap */
new = interface->cmd_list_dup ? new_strnode_dup(s, size)
: new_strnode(s);
out:
if (interface->cmd_list) {
interface->cmd_list_tail->next = new;
interface->cmd_list_tail = new;
} else
interface->cmd_list = interface->cmd_list_tail = new;
}
static void closeInterface(Interface * interface)
{
if (!interface->open)
struct sllnode *buf;
if (interface->fd < 0)
return;
xclose(interface->fd);
interface->fd = -1;
interface->open = 0;
if (interface->cmd_list) {
free_cmd_list(interface->cmd_list);
interface->cmd_list = NULL;
}
while (fclose(interface->fp) && errno == EINTR) ;
if (interface->commandList)
freeList(interface->commandList);
if (interface->bufferList)
freeList(interface->bufferList);
free(interface->outBuffer);
if ((buf = interface->deferred_send)) {
do {
struct sllnode *prev = buf;
buf = buf->next;
free(prev);
} while (buf);
interface->deferred_send = NULL;
}
SECURE("interface %i: closed\n", interface->num);
}
@ -157,11 +251,12 @@ void openAInterface(int fd, struct sockaddr *addr)
{
int i;
for (i = 0; i < interface_max_connections && interfaces[i].open; i++) ;
for (i = 0; i < interface_max_connections
&& interfaces[i].fd >= 0; i++) /* nothing */ ;
if (i == interface_max_connections) {
ERROR("Max Connections Reached!\n");
while (close(fd) && errno == EINTR) ;
xclose(fd);
} else {
SECURE("interface %i: opened from ", i);
switch (addr->sa_family) {
@ -207,74 +302,60 @@ static int processLineOfInput(Interface * interface)
int ret = 1;
char *line = interface->buffer + interface->bufferPos;
if (interface->bufferLength - interface->bufferPos > 1) {
if (interface->buffer[interface->bufferLength - 2] == '\r') {
interface->buffer[interface->bufferLength - 2] = '\0';
}
}
if (interface->commandList) {
if (interface->cmd_list_OK >= 0) {
if (strcmp(line, INTERFACE_LIST_MODE_END) == 0) {
DEBUG("interface %i: process command "
"list\n", interface->num);
ret = processListOfCommands(interface->fp,
ret = processListOfCommands(interface->fd,
&(interface->permission),
&(interface->expired),
interface->commandListOK,
interface->commandList);
interface->cmd_list_OK,
interface->cmd_list);
DEBUG("interface %i: process command "
"list returned %i\n", interface->num, ret);
if (ret == 0)
commandSuccess(interface->fp);
commandSuccess(interface->fd);
else if (ret == COMMAND_RETURN_CLOSE
|| interface->expired) {
|| interface->expired)
closeInterface(interface);
}
printInterfaceOutBuffer(interface);
freeList(interface->commandList);
interface->commandList = NULL;
printInterfaceOutBuffer(interface);
free_cmd_list(interface->cmd_list);
interface->cmd_list = NULL;
interface->cmd_list_OK = -1;
} else {
interface->commandListSize += sizeof(ListNode);
interface->commandListSize += strlen(line) + 1;
if (interface->commandListSize >
size_t len = strlen(line) + 1;
interface->cmd_list_size += len;
if (interface->cmd_list_size >
interface_max_command_list_size) {
ERROR("interface %i: command "
"list size (%lli) is "
"list size (%i) is "
"larger than the max "
"(%lli)\n",
"(%i)\n",
interface->num,
(long long)interface->
commandListSize, (long long)
interface->cmd_list_size,
interface_max_command_list_size);
closeInterface(interface);
ret = COMMAND_RETURN_CLOSE;
} else {
insertInListWithoutKey(interface->commandList,
strdup(line));
}
} else
new_cmd_list_ptr(interface, line, len);
}
} else {
if (strcmp(line, INTERFACE_LIST_MODE_BEGIN) == 0) {
interface->commandList = makeList(free, 1);
interface->commandListSize = sizeof(List);
interface->commandListOK = 0;
interface->cmd_list_OK = 0;
ret = 1;
} else if (strcmp(line, INTERFACE_LIST_OK_MODE_BEGIN) == 0) {
interface->commandList = makeList(free, 1);
interface->commandListSize = sizeof(List);
interface->commandListOK = 1;
interface->cmd_list_OK = 1;
ret = 1;
} else {
DEBUG("interface %i: process command \"%s\"\n",
interface->num, line);
ret = processCommand(interface->fp,
ret = processCommand(interface->fd,
&(interface->permission), line);
DEBUG("interface %i: command returned %i\n",
interface->num, ret);
if (ret == 0)
commandSuccess(interface->fp);
commandSuccess(interface->fd);
else if (ret == COMMAND_RETURN_CLOSE
|| interface->expired) {
closeInterface(interface);
@ -289,12 +370,18 @@ static int processLineOfInput(Interface * interface)
static int processBytesRead(Interface * interface, int bytesRead)
{
int ret = 0;
char *buf_tail = &(interface->buffer[interface->bufferLength - 1]);
while (bytesRead > 0) {
interface->bufferLength++;
bytesRead--;
if (interface->buffer[interface->bufferLength - 1] == '\n') {
interface->buffer[interface->bufferLength - 1] = '\0';
buf_tail++;
if (*buf_tail == '\n') {
*buf_tail = '\0';
if (interface->bufferLength - interface->bufferPos > 1) {
if (*(buf_tail - 1) == '\r')
*(buf_tail - 1) = '\0';
}
ret = processLineOfInput(interface);
interface->bufferPos = interface->bufferLength;
}
@ -305,6 +392,9 @@ static int processBytesRead(Interface * interface, int bytesRead)
closeInterface(interface);
return 1;
}
if (interface->cmd_list_OK >= 0 &&
!interface->cmd_list_dup)
cmd_list_clone(interface);
interface->bufferLength -= interface->bufferPos;
memmove(interface->buffer,
interface->buffer + interface->bufferPos,
@ -347,8 +437,8 @@ static void addInterfacesReadyToReadAndListenSocketToFdSet(fd_set * fds,
addListenSocketsToFdSet(fds, fdmax);
for (i = 0; i < interface_max_connections; i++) {
if (interfaces[i].open && !interfaces[i].expired
&& !interfaces[i].bufferList) {
if (interfaces[i].fd >= 0 && !interfaces[i].expired
&& !interfaces[i].deferred_send) {
FD_SET(interfaces[i].fd, fds);
if (*fdmax < interfaces[i].fd)
*fdmax = interfaces[i].fd;
@ -363,8 +453,8 @@ static void addInterfacesForBufferFlushToFdSet(fd_set * fds, int *fdmax)
FD_ZERO(fds);
for (i = 0; i < interface_max_connections; i++) {
if (interfaces[i].open && !interfaces[i].expired
&& interfaces[i].bufferList) {
if (interfaces[i].fd >= 0 && !interfaces[i].expired
&& interfaces[i].deferred_send) {
FD_SET(interfaces[i].fd, fds);
if (*fdmax < interfaces[i].fd)
*fdmax = interfaces[i].fd;
@ -382,7 +472,7 @@ static void closeNextErroredInterface(void)
tv.tv_usec = 0;
for (i = 0; i < interface_max_connections; i++) {
if (interfaces[i].open) {
if (interfaces[i].fd >= 0) {
FD_ZERO(&fds);
FD_SET(interfaces[i].fd, &fds);
if (select(FD_SETSIZE, &fds, NULL, NULL, &tv) < 0) {
@ -424,7 +514,7 @@ int doIOForInterfaces(void)
getConnections(&rfds);
for (i = 0; i < interface_max_connections; i++) {
if (interfaces[i].open
if (interfaces[i].fd >= 0
&& FD_ISSET(interfaces[i].fd, &rfds)) {
if (COMMAND_RETURN_KILL ==
interfaceReadInput(&(interfaces[i]))) {
@ -432,7 +522,7 @@ int doIOForInterfaces(void)
}
interfaces[i].lastTime = time(NULL);
}
if (interfaces[i].open
if (interfaces[i].fd >= 0
&& FD_ISSET(interfaces[i].fd, &wfds)) {
flushInterfaceBuffer(&interfaces[i]);
interfaces[i].lastTime = time(NULL);
@ -504,8 +594,15 @@ void initInterfaces(void)
interfaces = malloc(sizeof(Interface) * interface_max_connections);
list_cache = calloc(interface_list_cache_size, sizeof(struct strnode));
list_cache_head = &(list_cache[0]);
list_cache_tail = &(list_cache[interface_list_cache_size - 1]);
for (i = 0; i < interface_max_connections; i++) {
interfaces[i].open = 0;
interfaces[i].fd = -1;
interfaces[i].send_buf = NULL;
interfaces[i].send_buf_size = 0;
interfaces[i].send_buf_alloc = 0;
interfaces[i].num = i;
}
}
@ -514,13 +611,13 @@ static void closeAllInterfaces(void)
{
int i;
fflush(NULL);
for (i = 0; i < interface_max_connections; i++) {
if (interfaces[i].open) {
if (interfaces[i].fd > 0)
closeInterface(&(interfaces[i]));
}
if (interfaces[i].send_buf)
free(interfaces[i].send_buf);
}
free(list_cache);
}
void freeAllInterfaces(void)
@ -537,7 +634,7 @@ void closeOldInterfaces(void)
int i;
for (i = 0; i < interface_max_connections; i++) {
if (interfaces[i].open) {
if (interfaces[i].fd > 0) {
if (interfaces[i].expired) {
DEBUG("interface %i: expired\n", i);
closeInterface(&(interfaces[i]));
@ -552,37 +649,45 @@ void closeOldInterfaces(void)
static void flushInterfaceBuffer(Interface * interface)
{
ListNode *node = NULL;
char *str;
struct sllnode *buf;
int ret = 0;
while ((node = interface->bufferList->firstNode)) {
str = (char *)node->data;
if ((ret = write(interface->fd, str, strlen(str))) < 0)
buf = interface->deferred_send;
while (buf) {
ret = write(interface->fd, buf->data, buf->size);
if (ret < 0)
break;
else if (ret < strlen(str)) {
interface->outputBufferSize -= ret;
str = strdup(&str[ret]);
free(node->data);
node->data = str;
else if (ret < buf->size) {
interface->deferred_bytes -= ret;
buf->data += ret;
buf->size -= ret;
} else {
interface->outputBufferSize -= strlen(str) + 1;
interface->outputBufferSize -= sizeof(ListNode);
deleteNodeFromList(interface->bufferList, node);
struct sllnode *tmp = buf;
interface->deferred_bytes -= (buf->size +
sizeof(struct sllnode));
buf = buf->next;
free(tmp);
interface->deferred_send = buf;
}
interface->lastTime = time(NULL);
}
if (!interface->bufferList->firstNode) {
DEBUG("interface %i: buffer empty\n", interface->num);
freeList(interface->bufferList);
interface->bufferList = NULL;
if (!interface->deferred_send) {
DEBUG("interface %i: buffer empty %i\n", interface->num,
interface->deferred_bytes);
assert(interface->deferred_bytes == 0);
} else if (ret < 0 && errno != EAGAIN && errno != EINTR) {
/* cause interface to close */
DEBUG("interface %i: problems flushing buffer\n",
interface->num);
freeList(interface->bufferList);
interface->bufferList = NULL;
buf = interface->deferred_send;
do {
struct sllnode *prev = buf;
buf = buf->next;
free(prev);
} while (buf);
interface->deferred_send = NULL;
interface->deferred_bytes = 0;
interface->expired = 1;
}
}
@ -593,10 +698,12 @@ int interfacePrintWithFD(int fd, char *buffer, int buflen)
int copylen;
Interface *interface;
assert(fd > 0);
if (i >= interface_max_connections ||
!interfaces[i].open || interfaces[i].fd != fd) {
interfaces[i].fd < 0 || interfaces[i].fd != fd) {
for (i = 0; i < interface_max_connections; i++) {
if (interfaces[i].open && interfaces[i].fd == fd)
if (interfaces[i].fd == fd)
break;
}
if (i == interface_max_connections)
@ -610,17 +717,15 @@ int interfacePrintWithFD(int fd, char *buffer, int buflen)
interface = interfaces + i;
while (buflen > 0 && !interface->expired) {
copylen = buflen >
interface->outBufSize - interface->outBuflen ?
interface->outBufSize - interface->outBuflen : buflen;
memcpy(interface->outBuffer + interface->outBuflen, buffer,
int left = interface->send_buf_size - interface->send_buf_used;
copylen = buflen > left ? left : buflen;
memcpy(interface->send_buf + interface->send_buf_used, buffer,
copylen);
buflen -= copylen;
interface->outBuflen += copylen;
interface->send_buf_used += copylen;
buffer += copylen;
if (interface->outBuflen >= interface->outBufSize) {
if (interface->send_buf_used >= interface->send_buf_size)
printInterfaceOutBuffer(interface);
}
}
return 0;
@ -628,73 +733,63 @@ int interfacePrintWithFD(int fd, char *buffer, int buflen)
static void printInterfaceOutBuffer(Interface * interface)
{
char *buffer;
int ret;
struct sllnode *buf;
if (!interface->open || interface->expired || !interface->outBuflen) {
if (interface->fd < 0 || interface->expired ||
!interface->send_buf_used)
return;
}
if (interface->bufferList) {
interface->outputBufferSize += sizeof(ListNode);
interface->outputBufferSize += interface->outBuflen + 1;
if (interface->outputBufferSize >
if ((buf = interface->deferred_send)) {
interface->deferred_bytes += sizeof(struct sllnode)
+ interface->send_buf_used;
if (interface->deferred_bytes >
interface_max_output_buffer_size) {
ERROR("interface %i: output buffer size (%lli) is "
"larger than the max (%lli)\n",
ERROR("interface %i: output buffer size (%li) is "
"larger than the max (%li)\n",
interface->num,
(long long)interface->outputBufferSize,
(long long)interface_max_output_buffer_size);
(long)interface->deferred_bytes,
(long)interface_max_output_buffer_size);
/* cause interface to close */
freeList(interface->bufferList);
interface->bufferList = NULL;
interface->expired = 1;
do {
struct sllnode *prev = buf;
buf = buf->next;
free(prev);
} while (buf);
interface->deferred_send = NULL;
interface->deferred_bytes = 0;
} else {
buffer = malloc(interface->outBuflen + 1);
memcpy(buffer, interface->outBuffer,
interface->outBuflen);
buffer[interface->outBuflen] = '\0';
insertInListWithoutKey(interface->bufferList,
(void *)buffer);
flushInterfaceBuffer(interface);
while (buf->next)
buf = buf->next;
buf->next = new_sllnode(interface->send_buf,
interface->send_buf_used);
}
} else {
if ((ret = write(interface->fd, interface->outBuffer,
interface->outBuflen)) < 0) {
if ((ret = write(interface->fd, interface->send_buf,
interface->send_buf_used)) < 0) {
if (errno == EAGAIN || errno == EINTR) {
buffer = malloc(interface->outBuflen + 1);
memcpy(buffer, interface->outBuffer,
interface->outBuflen);
buffer[interface->outBuflen] = '\0';
interface->bufferList = makeList(free, 1);
insertInListWithoutKey(interface->bufferList,
(void *)buffer);
interface->deferred_send =
new_sllnode(interface->send_buf,
interface->send_buf_used);
} else {
DEBUG("interface %i: problems writing\n",
interface->num);
interface->expired = 1;
return;
}
} else if (ret < interface->outBuflen) {
buffer = malloc(interface->outBuflen - ret + 1);
memcpy(buffer, interface->outBuffer + ret,
interface->outBuflen - ret);
buffer[interface->outBuflen - ret] = '\0';
interface->bufferList = makeList(free, 1);
insertInListWithoutKey(interface->bufferList, buffer);
} else if (ret < interface->send_buf_used) {
interface->deferred_send =
new_sllnode(interface->send_buf + ret,
interface->send_buf_used - ret);
}
/* if we needed to create buffer, initialize bufferSize info */
if (interface->bufferList) {
if (interface->deferred_send) {
DEBUG("interface %i: buffer created\n", interface->num);
interface->outputBufferSize = sizeof(List);
interface->outputBufferSize += sizeof(ListNode);
interface->outputBufferSize += strlen((char *)
interface->
bufferList->
firstNode->data) +
1;
interface->deferred_bytes =
interface->deferred_send->size
+ sizeof(struct sllnode);
}
}
interface->outBuflen = 0;
interface->send_buf_used = 0;
}

8
src/ls.c
View File

@ -32,12 +32,12 @@ static char *remoteUrlPrefixes[] = {
NULL
};
int printRemoteUrlHandlers(FILE * fp)
int printRemoteUrlHandlers(int fd)
{
char **prefixes = remoteUrlPrefixes;
while (*prefixes) {
myfprintf(fp, "handler: %s\n", *prefixes);
fdprintf(fd, "handler: %s\n", *prefixes);
prefixes++;
}
@ -100,7 +100,7 @@ int isRemoteUrl(char *url)
return 0;
}
int lsPlaylists(FILE * fp, char *utf8path)
int lsPlaylists(int fd, char *utf8path)
{
DIR *dir;
struct stat st;
@ -166,7 +166,7 @@ int lsPlaylists(FILE * fp, char *utf8path)
node = list->firstNode;
while (node != NULL) {
if (!strchr(node->key, '\n')) {
myfprintf(fp, "playlist: %s%s\n", dup,
fdprintf(fd, "playlist: %s%s\n", dup,
node->key);
}
node = node->nextNode;

4
src/ls.h
View File

@ -29,7 +29,7 @@
#include <unistd.h>
#include <time.h>
int lsPlaylists(FILE * fp, char *utf8path);
int lsPlaylists(int fd, char *utf8path);
char *getSuffix(char *utf8file);
@ -47,6 +47,6 @@ InputPlugin *hasMusicSuffix(char *utf8file, unsigned int next);
InputPlugin *isMusic(char *utf8file, time_t * mtime, unsigned int next);
int printRemoteUrlHandlers(FILE * fp);
int printRemoteUrlHandlers(int fd);
#endif

76
src/myfprintf.c
View File

@ -21,6 +21,7 @@
#include "path.h"
#include "log.h"
#include "conf.h"
#include "utils.h"
#include <stdarg.h>
#include <sys/param.h>
@ -38,28 +39,41 @@ static FILE *myfprintf_err;
static char *myfprintf_outFilename;
static char *myfprintf_errFilename;
static void blockingWrite(int fd, char *string, int len)
static void blockingWrite(const int fd, const char *string, size_t len)
{
int ret;
while (len) {
ret = write(fd, string, len);
if (ret == 0)
size_t ret = xwrite(fd, string, len);
if (ret == len)
return;
if (ret < 0) {
switch (errno) {
case EAGAIN:
case EINTR:
continue;
default:
return;
}
if (ret >= 0) {
len -= ret;
string += ret;
continue;
}
len -= ret;
string += ret;
return; /* error */
}
}
void vfdprintf(const int fd, const char *fmt, va_list args)
{
static char buffer[BUFFER_LENGTH + 1];
char *buf = buffer;
size_t len;
vsnprintf(buf, BUFFER_LENGTH, fmt, args);
len = strlen(buf);
if (interfacePrintWithFD(fd, buf, len) < 0)
blockingWrite(fd, buf, len);
}
mpd_fprintf void fdprintf(const int fd, const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
vfdprintf(fd, fmt, args);
va_end(args);
}
void myfprintfStdLogMode(FILE * out, FILE * err)
{
myfprintf_stdLogMode = 1;
@ -69,38 +83,6 @@ void myfprintfStdLogMode(FILE * out, FILE * err)
myfprintf_errFilename = getConfigParamValue(CONF_ERROR_FILE);
}
void myfprintf(FILE * fp, char *format, ...)
{
static char buffer[BUFFER_LENGTH + 1];
va_list arglist;
int fd = fileno(fp);
va_start(arglist, format);
if (fd == 1 || fd == 2) {
if (myfprintf_stdLogMode) {
time_t t = time(NULL);
if (fd == 1)
fp = myfprintf_out;
else
fp = myfprintf_err;
strftime(buffer, 14, "%b %e %R", localtime(&t));
blockingWrite(fd, buffer, strlen(buffer));
blockingWrite(fd, " : ", 3);
}
vsnprintf(buffer, BUFFER_LENGTH, format, arglist);
blockingWrite(fd, buffer, strlen(buffer));
} else {
int len;
vsnprintf(buffer, BUFFER_LENGTH, format, arglist);
len = strlen(buffer);
if (interfacePrintWithFD(fd, buffer, len) < 0) {
blockingWrite(fd, buffer, len);
}
}
va_end(arglist);
}
int myfprintfCloseAndOpenLogFile(void)
{
if (myfprintf_stdLogMode) {

10
src/myfprintf.h
View File

@ -20,12 +20,20 @@
#define MYFPRINTF_H
#include "../config.h"
#include "gcc.h"
#include <stdarg.h>
#include <stdio.h>
void myfprintfStdLogMode(FILE * out, FILE * err);
void myfprintf(FILE * fp, char *format, ...);
mpd_fprintf void fdprintf(const int fd, const char *fmt, ...);
void vfdprintf(const int fd, const char *fmt, va_list arglist);
#define myfprintf(fp, ...) do { \
fprintf(fp, __VA_ARGS__); \
fflush(fp); \
} while (0)
int myfprintfCloseAndOpenLogFile();

23
src/player.c
View File

@ -156,14 +156,11 @@ int playerInitReal()
return 0;
}
int playerPlay(FILE * fp, Song * song)
int playerPlay(int fd, Song * song)
{
PlayerControl *pc = &(getPlayerData()->playerControl);
if (fp == NULL)
fp = stderr;
if (playerStop(fp) < 0)
if (playerStop(fd) < 0)
return -1;
if (song->tag)
@ -189,7 +186,7 @@ int playerPlay(FILE * fp, Song * song)
return 0;
}
int playerStop(FILE * fp)
int playerStop(int fd)
{
PlayerControl *pc = &(getPlayerData()->playerControl);
@ -219,7 +216,7 @@ void playerKill()
kill(pid, SIGTERM);
}
int playerPause(FILE * fp)
int playerPause(int fd)
{
PlayerControl *pc = &(getPlayerData()->playerControl);
@ -232,7 +229,7 @@ int playerPause(FILE * fp)
return 0;
}
int playerSetPause(FILE * fp, int pause)
int playerSetPause(int fd, int pause)
{
PlayerControl *pc = &(getPlayerData()->playerControl);
@ -242,11 +239,11 @@ int playerSetPause(FILE * fp, int pause)
switch (pc->state) {
case PLAYER_STATE_PLAY:
if (pause)
playerPause(fp);
playerPause(fd);
break;
case PLAYER_STATE_PAUSE:
if (!pause)
playerPause(fp);
playerPause(fd);
break;
}
@ -329,7 +326,7 @@ void playerCloseAudio()
PlayerControl *pc = &(getPlayerData()->playerControl);
if (getPlayerPid() > 0) {
if (playerStop(stderr) < 0)
if (playerStop(STDERR_FILENO) < 0)
return;
pc->closeAudio = 1;
}
@ -393,12 +390,12 @@ void playerQueueUnlock()
}
}
int playerSeek(FILE * fp, Song * song, float time)
int playerSeek(int fd, Song * song, float time)
{
PlayerControl *pc = &(getPlayerData()->playerControl);
if (pc->state == PLAYER_STATE_STOP) {
commandError(fp, ACK_ERROR_PLAYER_SYNC,
commandError(fd, ACK_ERROR_PLAYER_SYNC,
"player not currently playing", NULL);
return -1;
}

10
src/player.h
View File

@ -93,13 +93,13 @@ int playerInitReal();
void player_sigChldHandler(int pid, int status);
int playerPlay(FILE * fp, Song * song);
int playerPlay(int fd, Song * song);
int playerSetPause(FILE * fp, int pause);
int playerSetPause(int fd, int pause);
int playerPause(FILE * fp);
int playerPause(int fd);
int playerStop(FILE * fp);
int playerStop(int fd);
void playerCloseAudio();
@ -131,7 +131,7 @@ void playerQueueLock();
void playerQueueUnlock();
int playerSeek(FILE * fp, Song * song, float time);
int playerSeek(int fd, Song * song, float time);
void setPlayerCrossFade(float crossFadeInSeconds);

249
src/playlist.c
View File

@ -89,7 +89,7 @@ static int playlist_noGoToNext = 0;
static int playlist_saveAbsolutePaths = DEFAULT_PLAYLIST_SAVE_ABSOLUTE_PATHS;
static void swapOrder(int a, int b);
static int playPlaylistOrderNumber(FILE * fp, int orderNum);
static int playPlaylistOrderNumber(int fd, int orderNum);
static void randomizeOrder(int start, int end);
char *getStateFile(void)
@ -223,11 +223,11 @@ void finishPlaylist(void)
playlist.positionToId = NULL;
}
int clearPlaylist(FILE * fp)
int clearPlaylist(int fd)
{
int i;
if (stopPlaylist(fp) < 0)
if (stopPlaylist(fd) < 0)
return -1;
for (i = 0; i < playlist.length; i++) {
@ -245,12 +245,12 @@ int clearPlaylist(FILE * fp)
return 0;
}
int showPlaylist(FILE * fp)
int showPlaylist(int fd)
{
int i;
for (i = 0; i < playlist.length; i++) {
myfprintf(fp, "%i:%s\n", i, getSongUrl(playlist.songs[i]));
fdprintf(fd, "%i:%s\n", i, getSongUrl(playlist.songs[i]));
}
return 0;
@ -298,14 +298,14 @@ void savePlaylistState(void)
myfprintf(fp, "%s%i\n", PLAYLIST_STATE_FILE_CROSSFADE,
(int)(getPlayerCrossFade()));
myfprintf(fp, "%s\n", PLAYLIST_STATE_FILE_PLAYLIST_BEGIN);
showPlaylist(fp);
showPlaylist(fileno(fp));
myfprintf(fp, "%s\n", PLAYLIST_STATE_FILE_PLAYLIST_END);
while (fclose(fp) && errno == EINTR) ;
}
}
void loadPlaylistFromStateFile(FILE * fp, char *buffer, int state, int current,
void loadPlaylistFromStateFile(FILE *fp, char *buffer, int state, int current,
int time)
{
char *temp;
@ -322,15 +322,17 @@ void loadPlaylistFromStateFile(FILE * fp, char *buffer, int state, int current,
ERROR("error parsing state file \"%s\"\n", stateFile);
exit(EXIT_FAILURE);
}
if (addToPlaylist(stderr, temp, 0) == 0 && current == song) {
if (!addToPlaylist(STDERR_FILENO, temp, 0) && current == song) {
if (state != PLAYER_STATE_STOP) {
playPlaylist(stderr, playlist.length - 1, 0);
playPlaylist(STDERR_FILENO,
playlist.length - 1, 0);
}
if (state == PLAYER_STATE_PAUSE) {
playerPause(stderr);
playerPause(STDERR_FILENO);
}
if (state != PLAYER_STATE_STOP) {
seekSongInPlaylist(stderr, playlist.length - 1,
seekSongInPlaylist(STDERR_FILENO,
playlist.length - 1,
time);
}
}
@ -402,9 +404,11 @@ void readPlaylistState(void)
(buffer
[strlen(PLAYLIST_STATE_FILE_REPEAT)]),
"1") == 0) {
setPlaylistRepeatStatus(stderr, 1);
setPlaylistRepeatStatus(STDERR_FILENO,
1);
} else
setPlaylistRepeatStatus(stderr, 0);
setPlaylistRepeatStatus(STDERR_FILENO,
0);
} else
if (strncmp
(buffer, PLAYLIST_STATE_FILE_CROSSFADE,
@ -423,9 +427,11 @@ void readPlaylistState(void)
(buffer
[strlen(PLAYLIST_STATE_FILE_RANDOM)]),
"1") == 0) {
setPlaylistRandomStatus(stderr, 1);
setPlaylistRandomStatus(STDERR_FILENO,
1);
} else
setPlaylistRandomStatus(stderr, 0);
setPlaylistRandomStatus(STDERR_FILENO,
0);
} else if (strncmp(buffer, PLAYLIST_STATE_FILE_CURRENT,
strlen(PLAYLIST_STATE_FILE_CURRENT))
== 0) {
@ -454,14 +460,13 @@ void readPlaylistState(void)
}
}
void printPlaylistSongInfo(FILE * fp, int song)
void printPlaylistSongInfo(int fd, int song)
{
printSongInfo(fp, playlist.songs[song]);
myfprintf(fp, "Pos: %i\n", song);
myfprintf(fp, "Id: %i\n", playlist.positionToId[song]);
printSongInfo(fd, playlist.songs[song]);
fdprintf(fd, "Pos: %i\nId: %i\n", song, playlist.positionToId[song]);
}
int playlistChanges(FILE * fp, mpd_uint32 version)
int playlistChanges(int fd, mpd_uint32 version)
{
int i;
@ -469,14 +474,14 @@ int playlistChanges(FILE * fp, mpd_uint32 version)
if (version > playlist.version ||
playlist.songMod[i] >= version ||
playlist.songMod[i] == 0) {
printPlaylistSongInfo(fp, i);
printPlaylistSongInfo(fd, i);
}
}
return 0;
}
int playlistChangesPosId(FILE * fp, mpd_uint32 version)
int playlistChangesPosId(int fd, mpd_uint32 version)
{
int i;
@ -484,15 +489,15 @@ int playlistChangesPosId(FILE * fp, mpd_uint32 version)
if (version > playlist.version ||
playlist.songMod[i] >= version ||
playlist.songMod[i] == 0) {
myfprintf(fp, "cpos: %i\n", i);
myfprintf(fp, "Id: %i\n", playlist.positionToId[i]);
fdprintf(fd, "cpos: %i\nId: %i\n",
i, playlist.positionToId[i]);
}
}
return 0;
}
int playlistInfo(FILE * fp, int song)
int playlistInfo(int fd, int song)
{
int i;
int begin = 0;
@ -503,13 +508,13 @@ int playlistInfo(FILE * fp, int song)
end = song + 1;
}
if (song >= playlist.length) {
commandError(fp, ACK_ERROR_NO_EXIST,
commandError(fd, ACK_ERROR_NO_EXIST,
"song doesn't exist: \"%i\"", song);
return -1;
}
for (i = begin; i < end; i++)
printPlaylistSongInfo(fp, i);
printPlaylistSongInfo(fd, i);
return 0;
}
@ -518,13 +523,13 @@ int playlistInfo(FILE * fp, int song)
if(id < 0 || id >= PLAYLIST_HASH_MULT*playlist_max_length || \
playlist.idToPosition[id] == -1 ) \
{ \
commandError(fp, ACK_ERROR_NO_EXIST, \
commandError(fd, ACK_ERROR_NO_EXIST, \
"song id doesn't exist: \"%i\"", id); \
return -1; \
} \
}
int playlistId(FILE * fp, int id)
int playlistId(int fd, int id)
{
int i;
int begin = 0;
@ -537,7 +542,7 @@ int playlistId(FILE * fp, int id)
}
for (i = begin; i < end; i++)
printPlaylistSongInfo(fp, i);
printPlaylistSongInfo(fd, i);
return 0;
}
@ -642,7 +647,7 @@ void clearPlayerQueue(void)
}
}
int addToPlaylist(FILE * fp, char *url, int printId)
int addToPlaylist(int fd, char *url, int printId)
{
Song *song;
@ -651,21 +656,21 @@ int addToPlaylist(FILE * fp, char *url, int printId)
if ((song = getSongFromDB(url))) {
} else if (!(isValidRemoteUtf8Url(url) &&
(song = newSong(url, SONG_TYPE_URL, NULL)))) {
commandError(fp, ACK_ERROR_NO_EXIST,
commandError(fd, ACK_ERROR_NO_EXIST,
"\"%s\" is not in the music db or is "
"not a valid url", url);
return -1;
}
return addSongToPlaylist(fp, song, printId);
return addSongToPlaylist(fd, song, printId);
}
int addSongToPlaylist(FILE * fp, Song * song, int printId)
int addSongToPlaylist(int fd, Song * song, int printId)
{
int id;
if (playlist.length == playlist_max_length) {
commandError(fp, ACK_ERROR_PLAYLIST_MAX,
commandError(fd, ACK_ERROR_PLAYLIST_MAX,
"playlist is at the max size", NULL);
return -1;
}
@ -707,23 +712,23 @@ int addSongToPlaylist(FILE * fp, Song * song, int printId)
incrPlaylistVersion();
if (printId)
myfprintf(fp, "Id: %i\n", id);
fdprintf(fd, "Id: %i\n", id);
return 0;
}
int swapSongsInPlaylist(FILE * fp, int song1, int song2)
int swapSongsInPlaylist(int fd, int song1, int song2)
{
int queuedSong = -1;
int currentSong = -1;
if (song1 < 0 || song1 >= playlist.length) {
commandError(fp, ACK_ERROR_NO_EXIST,
commandError(fd, ACK_ERROR_NO_EXIST,
"song doesn't exist: \"%i\"", song1);
return -1;
}
if (song2 < 0 || song2 >= playlist.length) {
commandError(fp, ACK_ERROR_NO_EXIST,
commandError(fd, ACK_ERROR_NO_EXIST,
"song doesn't exist: \"%i\"", song2);
return -1;
}
@ -768,12 +773,12 @@ int swapSongsInPlaylist(FILE * fp, int song1, int song2)
return 0;
}
int swapSongsInPlaylistById(FILE * fp, int id1, int id2)
int swapSongsInPlaylistById(int fd, int id1, int id2)
{
checkSongId(id1);
checkSongId(id2);
return swapSongsInPlaylist(fp, playlist.idToPosition[id1],
return swapSongsInPlaylist(fd, playlist.idToPosition[id1],
playlist.idToPosition[id2]);
}
@ -784,13 +789,13 @@ int swapSongsInPlaylistById(FILE * fp, int id1, int id2)
playlist.songMod[to] = playlist.version; \
}
int deleteFromPlaylist(FILE * fp, int song)
int deleteFromPlaylist(int fd, int song)
{
int i;
int songOrder;
if (song < 0 || song >= playlist.length) {
commandError(fp, ACK_ERROR_NO_EXIST,
commandError(fd, ACK_ERROR_NO_EXIST,
"song doesn't exist: \"%i\"", song);
return -1;
}
@ -837,9 +842,9 @@ int deleteFromPlaylist(FILE * fp, int song)
if (playlist_state != PLAYLIST_STATE_STOP
&& playlist.current == songOrder) {
/*if(playlist.current>=playlist.length) return playerStop(fp);
else return playPlaylistOrderNumber(fp,playlist.current); */
playerStop(stderr);
/*if(playlist.current>=playlist.length) return playerStop(fd);
else return playPlaylistOrderNumber(fd,playlist.current); */
playerStop(STDERR_FILENO);
playlist_noGoToNext = 1;
}
@ -856,11 +861,11 @@ int deleteFromPlaylist(FILE * fp, int song)
return 0;
}
int deleteFromPlaylistById(FILE * fp, int id)
int deleteFromPlaylistById(int fd, int id)
{
checkSongId(id);
return deleteFromPlaylist(fp, playlist.idToPosition[id]);
return deleteFromPlaylist(fd, playlist.idToPosition[id]);
}
void deleteASongFromPlaylist(Song * song)
@ -872,15 +877,15 @@ void deleteASongFromPlaylist(Song * song)
for (i = 0; i < playlist.length; i++) {
if (song == playlist.songs[i]) {
deleteFromPlaylist(stderr, i);
deleteFromPlaylist(STDERR_FILENO, i);
}
}
}
int stopPlaylist(FILE * fp)
int stopPlaylist(int fd)
{
DEBUG("playlist: stop\n");
if (playerStop(fp) < 0)
if (playerStop(fd) < 0)
return -1;
playerCloseAudio();
playlist.queued = -1;
@ -891,10 +896,10 @@ int stopPlaylist(FILE * fp)
return 0;
}
int playPlaylistOrderNumber(FILE * fp, int orderNum)
int playPlaylistOrderNumber(int fd, int orderNum)
{
if (playerStop(fp) < 0)
if (playerStop(fd) < 0)
return -1;
playlist_state = PLAYLIST_STATE_PLAY;
@ -905,8 +910,8 @@ int playPlaylistOrderNumber(FILE * fp, int orderNum)
DEBUG("playlist: play %i:\"%s\"\n", orderNum,
getSongUrl(playlist.songs[playlist.order[orderNum]]));
if (playerPlay(fp, (playlist.songs[playlist.order[orderNum]])) < 0) {
stopPlaylist(fp);
if (playerPlay(fd, (playlist.songs[playlist.order[orderNum]])) < 0) {
stopPlaylist(fd);
return -1;
} else
playlist.current++;
@ -916,7 +921,7 @@ int playPlaylistOrderNumber(FILE * fp, int orderNum)
return 0;
}
int playPlaylist(FILE * fp, int song, int stopOnError)
int playPlaylist(int fd, int song, int stopOnError)
{
int i = song;
@ -927,7 +932,7 @@ int playPlaylist(FILE * fp, int song, int stopOnError)
return 0;
if (playlist_state == PLAYLIST_STATE_PLAY) {
return playerSetPause(fp, 0);
return playerSetPause(fd, 0);
}
if (playlist.current >= 0 && playlist.current < playlist.length) {
i = playlist.current;
@ -935,7 +940,7 @@ int playPlaylist(FILE * fp, int song, int stopOnError)
i = 0;
}
} else if (song < 0 || song >= playlist.length) {
commandError(fp, ACK_ERROR_NO_EXIST,
commandError(fd, ACK_ERROR_NO_EXIST,
"song doesn't exist: \"%i\"", song);
return -1;
}
@ -957,18 +962,18 @@ int playPlaylist(FILE * fp, int song, int stopOnError)
playlist_stopOnError = stopOnError;
playlist_errorCount = 0;
return playPlaylistOrderNumber(fp, i);
return playPlaylistOrderNumber(fd, i);
}
int playPlaylistById(FILE * fp, int id, int stopOnError)
int playPlaylistById(int fd, int id, int stopOnError)
{
if (id == -1) {
return playPlaylist(fp, id, stopOnError);
return playPlaylist(fd, id, stopOnError);
}
checkSongId(id);
return playPlaylist(fp, playlist.idToPosition[id], stopOnError);
return playPlaylist(fd, playlist.idToPosition[id], stopOnError);
}
void syncCurrentPlayerDecodeMetadata(void)
@ -1010,7 +1015,7 @@ void syncPlayerAndPlaylist(void)
syncCurrentPlayerDecodeMetadata();
}
int currentSongInPlaylist(FILE * fp)
int currentSongInPlaylist(int fd)
{
if (playlist_state != PLAYLIST_STATE_PLAY)
return 0;
@ -1020,14 +1025,14 @@ int currentSongInPlaylist(FILE * fp)
syncPlaylistWithQueue(0);
if (playlist.current >= 0 && playlist.current < playlist.length) {
return playPlaylistOrderNumber(fp, playlist.current);
return playPlaylistOrderNumber(fd, playlist.current);
} else
return stopPlaylist(fp);;
return stopPlaylist(fd);
return 0;
}
int nextSongInPlaylist(FILE * fp)
int nextSongInPlaylist(int fd)
{
if (playlist_state != PLAYLIST_STATE_PLAY)
return 0;
@ -1037,14 +1042,14 @@ int nextSongInPlaylist(FILE * fp)
playlist_stopOnError = 0;
if (playlist.current < playlist.length - 1) {
return playPlaylistOrderNumber(fp, playlist.current + 1);
return playPlaylistOrderNumber(fd, playlist.current + 1);
} else if (playlist.length && playlist.repeat) {
if (playlist.random)
randomizeOrder(0, playlist.length - 1);
return playPlaylistOrderNumber(fp, 0);
return playPlaylistOrderNumber(fd, 0);
} else {
incrPlaylistCurrent();
return stopPlaylist(fp);;
return stopPlaylist(fd);
}
return 0;
@ -1065,11 +1070,11 @@ void playPlaylistIfPlayerStopped(void)
|| error == PLAYER_ERROR_AUDIO
|| error == PLAYER_ERROR_SYSTEM
|| playlist_errorCount >= playlist.length)) {
stopPlaylist(stderr);
stopPlaylist(STDERR_FILENO);
} else if (playlist_noGoToNext)
currentSongInPlaylist(stderr);
currentSongInPlaylist(STDERR_FILENO);
else
nextSongInPlaylist(stderr);
nextSongInPlaylist(STDERR_FILENO);
}
}
@ -1083,10 +1088,10 @@ int getPlaylistRandomStatus(void)
return playlist.random;
}
int setPlaylistRepeatStatus(FILE * fp, int status)
int setPlaylistRepeatStatus(int fd, int status)
{
if (status != 0 && status != 1) {
commandError(fp, ACK_ERROR_ARG, "\"%i\" is not 0 or 1", status);
commandError(fd, ACK_ERROR_ARG, "\"%i\" is not 0 or 1", status);
return -1;
}
@ -1103,7 +1108,7 @@ int setPlaylistRepeatStatus(FILE * fp, int status)
return 0;
}
int moveSongInPlaylist(FILE * fp, int from, int to)
int moveSongInPlaylist(int fd, int from, int to)
{
int i;
Song *tmpSong;
@ -1112,13 +1117,13 @@ int moveSongInPlaylist(FILE * fp, int from, int to)
int currentSong = -1;
if (from < 0 || from >= playlist.length) {
commandError(fp, ACK_ERROR_NO_EXIST,
commandError(fd, ACK_ERROR_NO_EXIST,
"song doesn't exist: \"%i\"", from);
return -1;
}
if (to < 0 || to >= playlist.length) {
commandError(fp, ACK_ERROR_NO_EXIST,
commandError(fd, ACK_ERROR_NO_EXIST,
"song doesn't exist: \"%i\"", to);
return -1;
}
@ -1176,11 +1181,11 @@ int moveSongInPlaylist(FILE * fp, int from, int to)
return 0;
}
int moveSongInPlaylistById(FILE * fp, int id1, int to)
int moveSongInPlaylistById(int fd, int id1, int to)
{
checkSongId(id1);
return moveSongInPlaylist(fp, playlist.idToPosition[id1], to);
return moveSongInPlaylist(fd, playlist.idToPosition[id1], to);
}
static void orderPlaylist(void)
@ -1238,12 +1243,12 @@ static void randomizeOrder(int start, int end)
}
int setPlaylistRandomStatus(FILE * fp, int status)
int setPlaylistRandomStatus(int fd, int status)
{
int statusWas = playlist.random;
if (status != 0 && status != 1) {
commandError(fp, ACK_ERROR_ARG, "\"%i\" is not 0 or 1", status);
commandError(fd, ACK_ERROR_ARG, "\"%i\" is not 0 or 1", status);
return -1;
}
@ -1268,7 +1273,7 @@ int setPlaylistRandomStatus(FILE * fp, int status)
return 0;
}
int previousSongInPlaylist(FILE * fp)
int previousSongInPlaylist(int fd)
{
static time_t lastTime = 0;
time_t diff = time(NULL) - lastTime;
@ -1281,22 +1286,22 @@ int previousSongInPlaylist(FILE * fp)
syncPlaylistWithQueue(0);
if (diff && getPlayerElapsedTime() > PLAYLIST_PREV_UNLESS_ELAPSED) {
return playPlaylistOrderNumber(fp, playlist.current);
return playPlaylistOrderNumber(fd, playlist.current);
} else {
if (playlist.current > 0) {
return playPlaylistOrderNumber(fp,
return playPlaylistOrderNumber(fd,
playlist.current - 1);
} else if (playlist.repeat) {
return playPlaylistOrderNumber(fp, playlist.length - 1);
return playPlaylistOrderNumber(fd, playlist.length - 1);
} else {
return playPlaylistOrderNumber(fp, playlist.current);
return playPlaylistOrderNumber(fd, playlist.current);
}
}
return 0;
}
int shufflePlaylist(FILE * fp)
int shufflePlaylist(int fd)
{
int i;
int ri;
@ -1331,7 +1336,7 @@ int shufflePlaylist(FILE * fp)
return 0;
}
int deletePlaylist(FILE * fp, char *utf8file)
int deletePlaylist(int fd, char *utf8file)
{
char *file = utf8ToFsCharset(utf8file);
char *rfile = malloc(strlen(file) + strlen(".") +
@ -1348,13 +1353,13 @@ int deletePlaylist(FILE * fp, char *utf8file)
free(rfile);
else {
free(rfile);
commandError(fp, ACK_ERROR_NO_EXIST,
commandError(fd, ACK_ERROR_NO_EXIST,
"playlist \"%s\" not found", utf8file);
return -1;
}
if (unlink(actualFile) < 0) {
commandError(fp, ACK_ERROR_SYSTEM,
commandError(fd, ACK_ERROR_SYSTEM,
"problems deleting file", NULL);
return -1;
}
@ -1362,7 +1367,7 @@ int deletePlaylist(FILE * fp, char *utf8file)
return 0;
}
int savePlaylist(FILE * fp, char *utf8file)
int savePlaylist(int fd, char *utf8file)
{
FILE *fileP;
int i;
@ -1373,7 +1378,7 @@ int savePlaylist(FILE * fp, char *utf8file)
char *url;
if (strstr(utf8file, "/")) {
commandError(fp, ACK_ERROR_ARG,
commandError(fd, ACK_ERROR_ARG,
"cannot save \"%s\", saving playlists to "
"subdirectories is not supported", utf8file);
return -1;
@ -1395,14 +1400,14 @@ int savePlaylist(FILE * fp, char *utf8file)
free(rfile);
if (0 == stat(actualFile, &st)) {
commandError(fp, ACK_ERROR_EXIST, "a file or directory already "
commandError(fd, ACK_ERROR_EXIST, "a file or directory already "
"exists with the name \"%s\"", utf8file);
return -1;
}
while (!(fileP = fopen(actualFile, "w")) && errno == EINTR) ;
if (fileP == NULL) {
commandError(fp, ACK_ERROR_SYSTEM, "problems opening file",
commandError(fd, ACK_ERROR_SYSTEM, "problems opening file",
NULL);
return -1;
}
@ -1445,12 +1450,12 @@ int getPlaylistLength(void)
return playlist.length;
}
int seekSongInPlaylist(FILE * fp, int song, float time)
int seekSongInPlaylist(int fd, int song, float time)
{
int i = song;
if (song < 0 || song >= playlist.length) {
commandError(fp, ACK_ERROR_NO_EXIST,
commandError(fd, ACK_ERROR_NO_EXIST,
"song doesn't exist: \"%i\"", song);
return -1;
}
@ -1468,22 +1473,22 @@ int seekSongInPlaylist(FILE * fp, int song, float time)
clearPlayerQueue();
unlockPlaylistInteraction();
}
} else if (playPlaylistOrderNumber(fp, i) < 0)
} else if (playPlaylistOrderNumber(fd, i) < 0)
return -1;
if (playlist.current != i) {
if (playPlaylistOrderNumber(fp, i) < 0)
if (playPlaylistOrderNumber(fd, i) < 0)
return -1;
}
return playerSeek(fp, playlist.songs[playlist.order[i]], time);
return playerSeek(fd, playlist.songs[playlist.order[i]], time);
}
int seekSongInPlaylistById(FILE * fp, int id, float time)
int seekSongInPlaylistById(int fd, int id, float time)
{
checkSongId(id);
return seekSongInPlaylist(fp, playlist.idToPosition[id], time);
return seekSongInPlaylist(fd, playlist.idToPosition[id], time);
}
int getPlaylistSongId(int song)
@ -1491,8 +1496,8 @@ int getPlaylistSongId(int song)
return playlist.positionToId[song];
}
static int PlaylistIterFunc(FILE * fp, char *utf8file,
void (*IterFunc) (FILE * fp, char *utf8_file,
static int PlaylistIterFunc(int fd, char *utf8file,
void (*IterFunc) (int fd, char *utf8_file,
char **errored_File))
{
FILE *fileP;
@ -1518,14 +1523,14 @@ static int PlaylistIterFunc(FILE * fp, char *utf8file,
free(rfile);
else {
free(rfile);
commandError(fp, ACK_ERROR_NO_EXIST,
commandError(fd, ACK_ERROR_NO_EXIST,
"playlist \"%s\" not found", utf8file);
return -1;
}
while (!(fileP = fopen(actualFile, "r")) && errno == EINTR) ;
if (fileP == NULL) {
commandError(fp, ACK_ERROR_SYSTEM,
commandError(fd, ACK_ERROR_SYSTEM,
"problems opening file \"%s\"", utf8file);
return -1;
}
@ -1547,7 +1552,7 @@ static int PlaylistIterFunc(FILE * fp, char *utf8file,
strncat(s, "/", MAXPATHLEN - parentlen);
strncat(s, temp, MAXPATHLEN - parentlen - 1);
if (strlen(s) >= MAXPATHLEN) {
commandError(fp,
commandError(fd,
ACK_ERROR_PLAYLIST_LOAD,
"\"%s\" too long", temp);
free(temp);
@ -1568,12 +1573,12 @@ static int PlaylistIterFunc(FILE * fp, char *utf8file,
* for our current IterFunction set
* but just in case, we copy to s */
strcpy(s, temp);
IterFunc(fp, s, &erroredFile);
IterFunc(fd, s, &erroredFile);
}
free(temp);
} else if (slength == MAXPATHLEN) {
s[slength] = '\0';
commandError(fp, ACK_ERROR_PLAYLIST_LOAD,
commandError(fd, ACK_ERROR_PLAYLIST_LOAD,
"line in \"%s\" is too long", utf8file);
ERROR("line \"%s\" in playlist \"%s\" is too long\n",
s, utf8file);
@ -1588,7 +1593,7 @@ static int PlaylistIterFunc(FILE * fp, char *utf8file,
while (fclose(fileP) && errno == EINTR) ;
if (erroredFile) {
commandError(fp, ACK_ERROR_PLAYLIST_LOAD,
commandError(fd, ACK_ERROR_PLAYLIST_LOAD,
"can't add file \"%s\"", erroredFile);
free(erroredFile);
return -1;
@ -1597,25 +1602,25 @@ static int PlaylistIterFunc(FILE * fp, char *utf8file,
return 0;
}
static void PlaylistInfoPrintInfo(FILE * fp, char *utf8file, char **erroredfile)
static void PlaylistInfoPrintInfo(int fd, char *utf8file, char **erroredfile)
{
Song *song = getSongFromDB(utf8file);
if (song) {
printSongInfo(fp, song);
printSongInfo(fd, song);
} else {
myfprintf(fp, "file: %s\n", utf8file);
fdprintf(fd, "file: %s\n", utf8file);
}
}
static void PlaylistInfoPrint(FILE * fp, char *utf8file, char **erroredfile)
static void PlaylistInfoPrint(int fd, char *utf8file, char **erroredfile)
{
myfprintf(fp, "file: %s\n", utf8file);
fdprintf(fd, "file: %s\n", utf8file);
}
static void PlaylistLoadIterFunc(FILE * fp, char *temp, char **erroredFile)
static void PlaylistLoadIterFunc(int fd, char *temp, char **erroredFile)
{
if (!getSongFromDB(temp) && !isRemoteUrl(temp)) {
} else if ((addToPlaylist(stderr, temp, 0)) < 0) {
} else if ((addToPlaylist(STDERR_FILENO, temp, 0)) < 0) {
/* for windows compatibilit, convert slashes */
char *temp2 = strdup(temp);
char *p = temp2;
@ -1624,7 +1629,7 @@ static void PlaylistLoadIterFunc(FILE * fp, char *temp, char **erroredFile)
*p = '/';
p++;
}
if ((addToPlaylist(stderr, temp2, 0)) < 0) {
if ((addToPlaylist(STDERR_FILENO, temp2, 0)) < 0) {
if (!*erroredFile) {
*erroredFile = strdup(temp);
}
@ -1633,15 +1638,15 @@ static void PlaylistLoadIterFunc(FILE * fp, char *temp, char **erroredFile)
}
}
int PlaylistInfo(FILE * fp, char *utf8file, int detail)
int PlaylistInfo(int fd, char *utf8file, int detail)
{
if (detail) {
return PlaylistIterFunc(fp, utf8file, PlaylistInfoPrintInfo);
return PlaylistIterFunc(fd, utf8file, PlaylistInfoPrintInfo);
}
return PlaylistIterFunc(fp, utf8file, PlaylistInfoPrint);
return PlaylistIterFunc(fd, utf8file, PlaylistInfoPrint);
}
int loadPlaylist(FILE * fp, char *utf8file)
int loadPlaylist(int fd, char *utf8file)
{
return PlaylistIterFunc(fp, utf8file, PlaylistLoadIterFunc);
return PlaylistIterFunc(fd, utf8file, PlaylistLoadIterFunc);
}

58
src/playlist.h
View File

@ -38,61 +38,61 @@ void readPlaylistState();
void savePlaylistState();
int clearPlaylist(FILE * fp);
int clearPlaylist(int fd);
int addToPlaylist(FILE * fp, char *file, int printId);
int addToPlaylist(int fd, char *file, int printId);
int addSongToPlaylist(FILE * fp, Song * song, int printId);
int addSongToPlaylist(int fd, Song * song, int printId);
int showPlaylist(FILE * fp);
int showPlaylist(int fd);
int deleteFromPlaylist(FILE * fp, int song);
int deleteFromPlaylist(int fd, int song);
int deleteFromPlaylistById(FILE * fp, int song);
int deleteFromPlaylistById(int fd, int song);
int playlistInfo(FILE * fp, int song);
int playlistInfo(int fd, int song);
int playlistId(FILE * fp, int song);
int playlistId(int fd, int song);
int stopPlaylist(FILE * fp);
int stopPlaylist(int fd);
int playPlaylist(FILE * fp, int song, int stopOnError);
int playPlaylist(int fd, int song, int stopOnError);
int playPlaylistById(FILE * fp, int song, int stopOnError);
int playPlaylistById(int fd, int song, int stopOnError);
int nextSongInPlaylist(FILE * fp);
int nextSongInPlaylist(int fd);
void syncPlayerAndPlaylist();
int previousSongInPlaylist(FILE * fp);
int previousSongInPlaylist(int fd);
int shufflePlaylist(FILE * fp);
int shufflePlaylist(int fd);
int savePlaylist(FILE * fp, char *utf8file);
int savePlaylist(int fd, char *utf8file);
int deletePlaylist(FILE * fp, char *utf8file);
int deletePlaylist(int fd, char *utf8file);
int deletePlaylistById(FILE * fp, char *utf8file);
int deletePlaylistById(int fd, char *utf8file);
void deleteASongFromPlaylist(Song * song);
int moveSongInPlaylist(FILE * fp, int from, int to);
int moveSongInPlaylist(int fd, int from, int to);
int moveSongInPlaylistById(FILE * fp, int id, int to);
int moveSongInPlaylistById(int fd, int id, int to);
int swapSongsInPlaylist(FILE * fp, int song1, int song2);
int swapSongsInPlaylist(int fd, int song1, int song2);
int swapSongsInPlaylistById(FILE * fp, int id1, int id2);
int swapSongsInPlaylistById(int fd, int id1, int id2);
int loadPlaylist(FILE * fp, char *utf8file);
int loadPlaylist(int fd, char *utf8file);
int getPlaylistRepeatStatus();
int setPlaylistRepeatStatus(FILE * fp, int status);
int setPlaylistRepeatStatus(int fd, int status);
int getPlaylistRandomStatus();
int setPlaylistRandomStatus(FILE * fp, int status);
int setPlaylistRandomStatus(int fd, int status);
int getPlaylistCurrentSong();
@ -104,17 +104,17 @@ unsigned long getPlaylistVersion();
void playPlaylistIfPlayerStopped();
int seekSongInPlaylist(FILE * fp, int song, float time);
int seekSongInPlaylist(int fd, int song, float time);
int seekSongInPlaylistById(FILE * fp, int id, float time);
int seekSongInPlaylistById(int fd, int id, float time);
void playlistVersionChange();
int playlistChanges(FILE * fp, mpd_uint32 version);
int playlistChanges(int fd, mpd_uint32 version);
int playlistChangesPosId(FILE * fp, mpd_uint32 version);
int playlistChangesPosId(int fd, mpd_uint32 version);
int PlaylistInfo(FILE * fp, char *utf8file, int detail);
int PlaylistInfo(int fd, char *utf8file, int detail);
char *getStateFile();

71
src/sllist.c Normal file
View File

@ -0,0 +1,71 @@
/* the Music Player Daemon (MPD)
* (c)2003-2006 by Warren Dukes (warren.dukes@gmail.com)
* 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
*/
/* a very simple singly-linked-list structure for queues/buffers */
#include "sllist.h"
#include "utils.h"
static void init_strnode(struct strnode *x, char *s)
{
x->data = s;
x->next = NULL;
}
struct strnode *new_strnode(char *s)
{
struct strnode *x = malloc(sizeof(struct strnode));
init_strnode(x, s);
return x;
}
struct strnode *new_strnode_dup(char *s, const size_t size)
{
struct strnode *x = malloc(sizeof(struct strnode) + size);
x->next = NULL;
x->data = ((void *)x + sizeof(struct strnode));
memcpy((void *)x->data, (void*)s, size);
return x;
}
struct sllnode *new_sllnode(void *s, const size_t size)
{
struct sllnode *x = malloc(sizeof(struct sllnode) + size);
x->next = NULL;
x->size = size;
x->data = ((void *)x + sizeof(struct sllnode));
memcpy(x->data, (void *)s, size);
return x;
}
struct strnode *dup_strlist(struct strnode *old)
{
struct strnode *tmp, *new, *cur;
tmp = old;
cur = new = new_strnode_dup(tmp->data, strlen(tmp->data) + 1);
tmp = tmp->next;
while (tmp) {
cur->next = new_strnode_dup(tmp->data, strlen(tmp->data) + 1);
cur = cur->next;
tmp = tmp->next;
}
return new;
}

34
src/sllist.h Normal file
View File

@ -0,0 +1,34 @@
/* a very simple singly-linked-list structure for queues/buffers */
#ifndef SLLIST_H
#define SLLIST_H
#include "utils.h"
/* just free the entire structure if it's free-able, the 'data' member
* should _NEVER_ be explicitly freed
*
* there's no free command, iterate through them yourself and just
* call free() on it iff you malloc'd them */
struct strnode {
struct strnode *next;
char *data;
};
struct sllnode {
struct sllnode *next;
void *data;
size_t size;
};
struct strnode *new_strnode(char *s);
struct strnode *new_strnode_dup(char *s, const size_t size);
struct strnode *dup_strlist(struct strnode *old);
struct sllnode *new_sllnode(void *s, const size_t size);
#endif /* SLLIST_H */

18
src/song.c
View File

@ -134,32 +134,32 @@ void freeSongList(SongList * list)
freeList(list);
}
void printSongUrl(FILE * fp, Song * song)
void printSongUrl(int fd, Song * song)
{
if (song->parentDir && song->parentDir->path) {
myfprintf(fp, "%s%s/%s\n", SONG_FILE,
fdprintf(fd, "%s%s/%s\n", SONG_FILE,
getDirectoryPath(song->parentDir), song->url);
} else {
myfprintf(fp, "%s%s\n", SONG_FILE, song->url);
fdprintf(fd, "%s%s\n", SONG_FILE, song->url);
}
}
int printSongInfo(FILE * fp, Song * song)
int printSongInfo(int fd, Song * song)
{
printSongUrl(fp, song);
printSongUrl(fd, song);
if (song->tag)
printMpdTag(fp, song->tag);
printMpdTag(fd, song->tag);
return 0;
}
int printSongInfoFromList(FILE * fp, SongList * list)
int printSongInfoFromList(int fd, SongList * list)
{
ListNode *tempNode = list->firstNode;
while (tempNode != NULL) {
printSongInfo(fp, (Song *) tempNode->data);
printSongInfo(fd, (Song *) tempNode->data);
tempNode = tempNode->nextNode;
}
@ -174,7 +174,7 @@ void writeSongInfoFromList(FILE * fp, SongList * list)
while (tempNode != NULL) {
myfprintf(fp, "%s%s\n", SONG_KEY, tempNode->key);
printSongInfo(fp, (Song *) tempNode->data);
printSongInfo(fileno(fp), (Song *) tempNode->data);
myfprintf(fp, "%s%li\n", SONG_MTIME,
(long)((Song *) tempNode->data)->mtime);
tempNode = tempNode->nextNode;

6
src/song.h
View File

@ -58,9 +58,9 @@ void freeSongList(SongList * list);
Song *addSongToList(SongList * list, char *url, char *utf8path,
int songType, struct _Directory *parentDir);
int printSongInfo(FILE * fp, Song * song);
int printSongInfo(int fd, Song * song);
int printSongInfoFromList(FILE * fp, SongList * list);
int printSongInfoFromList(int fd, SongList * list);
void writeSongInfoFromList(FILE * fp, SongList * list);
@ -69,7 +69,7 @@ void readSongInfoIntoList(FILE * fp, SongList * list,
int updateSongInfo(Song * song);
void printSongUrl(FILE * fp, Song * song);
void printSongUrl(int fd, Song * song);
char *getSongUrl(Song * song);

16
src/stats.c
View File

@ -34,15 +34,15 @@ void initStats(void)
stats.numberOfSongs = 0;
}
int printStats(FILE * fp)
int printStats(int fd)
{
myfprintf(fp, "artists: %li\n", getNumberOfTagItems(TAG_ITEM_ARTIST));
myfprintf(fp, "albums: %li\n", getNumberOfTagItems(TAG_ITEM_ALBUM));
myfprintf(fp, "songs: %i\n", stats.numberOfSongs);
myfprintf(fp, "uptime: %li\n", time(NULL) - stats.daemonStart);
myfprintf(fp, "playtime: %li\n",
fdprintf(fd, "artists: %li\n", getNumberOfTagItems(TAG_ITEM_ARTIST));
fdprintf(fd, "albums: %li\n", getNumberOfTagItems(TAG_ITEM_ALBUM));
fdprintf(fd, "songs: %i\n", stats.numberOfSongs);
fdprintf(fd, "uptime: %li\n", time(NULL) - stats.daemonStart);
fdprintf(fd, "playtime: %li\n",
(long)(getPlayerTotalPlayTime() + 0.5));
myfprintf(fp, "db_playtime: %li\n", stats.dbPlayTime);
myfprintf(fp, "db_update: %li\n", getDbModTime());
fdprintf(fd, "db_playtime: %li\n", stats.dbPlayTime);
fdprintf(fd, "db_update: %li\n", getDbModTime());
return 0;
}

2
src/stats.h
View File

@ -35,6 +35,6 @@ extern Stats stats;
void initStats();
int printStats(FILE * fp);
int printStats(int fd);
#endif

6
src/tag.c
View File

@ -121,15 +121,15 @@ void initTagConfig(void)
free(temp);
}
void printMpdTag(FILE * fp, MpdTag * tag)
void printMpdTag(int fd, MpdTag * tag)
{
int i;
if (tag->time >= 0)
myfprintf(fp, "Time: %i\n", tag->time);
fdprintf(fd, "Time: %i\n", tag->time);
for (i = 0; i < tag->numOfItems; i++) {
myfprintf(fp, "%s: %s\n", mpdTagItemKeys[tag->items[i].type],
fdprintf(fd, "%s: %s\n", mpdTagItemKeys[tag->items[i].type],
tag->items[i].value);
}
}

2
src/tag.h
View File

@ -78,7 +78,7 @@ void addItemToMpdTagWithLen(MpdTag * tag, int itemType, char *value, int len);
#define addItemToMpdTag(tag, itemType, value) \
addItemToMpdTagWithLen(tag, itemType, value, strlen(value))
void printMpdTag(FILE * fp, MpdTag * tag);
void printMpdTag(int fd, MpdTag * tag);
MpdTag *mpdTagDup(MpdTag * tag);

6
src/tagTracker.c
View File

@ -147,7 +147,7 @@ void visitInTagTracker(int type, char *str)
((TagTrackerItem *) item)->visited = 1;
}
void printVisitedInTagTracker(FILE * fp, int type)
void printVisitedInTagTracker(int fd, int type)
{
ListNode *node;
TagTrackerItem *item;
@ -160,8 +160,8 @@ void printVisitedInTagTracker(FILE * fp, int type)
while (node) {
item = node->data;
if (item->visited) {
myfprintf(fp, "%s: %s\n", mpdTagItemKeys[type],
node->key);
fdprintf(fd, "%s: %s\n", mpdTagItemKeys[type],
node->key);
}
node = node->nextNode;
}

2
src/tagTracker.h
View File

@ -33,6 +33,6 @@ void resetVisitedFlagsInTagTracker(int type);
void visitInTagTracker(int type, char *str);
void printVisitedInTagTracker(FILE * fp, int type);
void printVisitedInTagTracker(int fd, int type);
#endif

41
src/utils.h
View File

@ -21,7 +21,13 @@
#include "../config.h"
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
char *myFgets(char *buffer, int bufferSize, FILE * fp);
@ -37,4 +43,39 @@ char *appendToString(char *dest, const char *src);
unsigned long readLEuint32(const unsigned char *p);
/* trivial functions, keep them inlined */
static inline int xopen(const char *path, int flags, mode_t mode)
{
int fd;
while(0>(fd = open(path,flags,mode)) && errno == EINTR);
return fd;
}
static inline void xclose(int fd)
{
while (close(fd) && errno == EINTR);
}
static inline ssize_t xread(int fd, void *buf, size_t len)
{
ssize_t nr;
while (1) {
nr = read(fd, buf, len);
if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
continue;
return nr;
}
}
static inline ssize_t xwrite(int fd, const void *buf, size_t len)
{
ssize_t nr;
while (1) {
nr = write(fd, buf, len);
if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
continue;
return nr;
}
}
#endif

20
src/volume.c
View File

@ -169,7 +169,7 @@ static int getOssVolumeLevel(void)
return left;
}
static int changeOssVolumeLevel(FILE * fp, int change, int rel)
static int changeOssVolumeLevel(int fd, int change, int rel)
{
int current;
int new;
@ -177,7 +177,7 @@ static int changeOssVolumeLevel(FILE * fp, int change, int rel)
if (rel) {
if ((current = getOssVolumeLevel()) < 0) {
commandError(fp, ACK_ERROR_SYSTEM,
commandError(fd, ACK_ERROR_SYSTEM,
"problem getting current volume", NULL);
return -1;
}
@ -198,7 +198,7 @@ static int changeOssVolumeLevel(FILE * fp, int change, int rel)
if (ioctl(volume_ossFd, MIXER_WRITE(volume_ossControl), &level) < 0) {
closeOssMixer();
commandError(fp, ACK_ERROR_SYSTEM, "problems setting volume",
commandError(fd, ACK_ERROR_SYSTEM, "problems setting volume",
NULL);
return -1;
}
@ -328,7 +328,7 @@ static int getAlsaVolumeLevel(void)
return ret;
}
static int changeAlsaVolumeLevel(FILE * fp, int change, int rel)
static int changeAlsaVolumeLevel(int fd, int change, int rel)
{
float vol;
long level;
@ -361,7 +361,7 @@ static int changeAlsaVolumeLevel(FILE * fp, int change, int rel)
if ((err =
snd_mixer_selem_set_playback_volume_all(volume_alsaElem,
level)) < 0) {
commandError(fp, ACK_ERROR_SYSTEM, "problems setting volume",
commandError(fd, ACK_ERROR_SYSTEM, "problems setting volume",
NULL);
WARNING("problems setting alsa volume: %s\n",
snd_strerror(err));
@ -471,7 +471,7 @@ int getVolumeLevel(void)
}
}
static int changeSoftwareVolume(FILE * fp, int change, int rel)
static int changeSoftwareVolume(int fd, int change, int rel)
{
int new = change;
@ -499,19 +499,19 @@ static int changeSoftwareVolume(FILE * fp, int change, int rel)
return 0;
}
int changeVolumeLevel(FILE * fp, int change, int rel)
int changeVolumeLevel(int fd, int change, int rel)
{
switch (volume_mixerType) {
#ifdef HAVE_ALSA
case VOLUME_MIXER_TYPE_ALSA:
return changeAlsaVolumeLevel(fp, change, rel);
return changeAlsaVolumeLevel(fd, change, rel);
#endif
#ifdef HAVE_OSS
case VOLUME_MIXER_TYPE_OSS:
return changeOssVolumeLevel(fp, change, rel);
return changeOssVolumeLevel(fd, change, rel);
#endif
case VOLUME_MIXER_TYPE_SOFTWARE:
return changeSoftwareVolume(fp, change, rel);
return changeSoftwareVolume(fd, change, rel);
default:
return 0;
break;

2
src/volume.h
View File

@ -35,6 +35,6 @@ void finishVolume();
int getVolumeLevel();
int changeVolumeLevel(FILE * fp, int change, int rel);
int changeVolumeLevel(int fd, int change, int rel);
#endif