aniani/ezstream
1
0
Fork 0
mirror of https://gitlab.xiph.org/xiph/ezstream.git synced 2024-09-15 04:08:07 -04:00
Code

Prefer SIGSEGV over SIGABRT in case of explicit internal API abuse

Browse Source 
While here, declare some module-internal functions static.
This commit is contained in:
Moritz Grimm 2015-04-22 19:49:07 +02:00
parent 41058dac79
commit c6747ef998
3 changed files with 85 additions and 254 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/ezstream.c
View File

@ -133,11 +133,6 @@ urlParse(const char *url, char **hostname, unsigned short *port,
size_t hostsiz, mountsiz; size_t hostsiz, mountsiz;
const char *errstr; const char *errstr;
if (hostname == NULL || port == NULL || mountname == NULL) {
log_alert("urlParse: bad arguments");
abort();
}
if (strncmp(url, "http://", strlen("http://")) != 0) { if (strncmp(url, "http://", strlen("http://")) != 0) {
log_error("invalid <url>: not an HTTP address"); log_error("invalid <url>: not an HTTP address");
return (0); return (0);
@ -385,11 +380,6 @@ getMetadataString(const char *format, metadata_t *mdata)
{ {
char *tmp, *str; char *tmp, *str;
if (mdata == NULL) {
log_alert("getMetadataString: bad argument");
abort();
}
if (format == NULL) if (format == NULL)
return (NULL); return (NULL);
@ -457,11 +447,6 @@ setMetadata(shout_t *shout, metadata_t *mdata, char **mdata_copy)
const char *artist, *title; const char *artist, *title;
int ret = SHOUTERR_SUCCESS; int ret = SHOUTERR_SUCCESS;
if (shout == NULL) {
log_alert("setMetadata: bad argument");
abort();
}
if (cfg_no_metadata_updates()) if (cfg_no_metadata_updates())
return (SHOUTERR_SUCCESS); return (SHOUTERR_SUCCESS);
@ -727,11 +712,6 @@ sendStream(shout_t *shout, FILE *filepstream, const char *fileName,
struct timeval timeStamp, *startTime = tv; struct timeval timeStamp, *startTime = tv;
struct timeval callTime, currentTime; struct timeval callTime, currentTime;
if (startTime == NULL) {
log_alert("sendStream: bad argument");
abort();
}
ez_gettimeofday((void *)&callTime); ez_gettimeofday((void *)&callTime);
timeStamp.tv_sec = startTime->tv_sec; timeStamp.tv_sec = startTime->tv_sec;

131
src/metadata.c
View File

@ -30,6 +30,8 @@
#endif /* HAVE_VORBISFILE */ #endif /* HAVE_VORBISFILE */
#include <shout/shout.h> #include <shout/shout.h>
#include <assert.h>
#include "log.h" #include "log.h"
#include "metadata.h" #include "metadata.h"
#include "util.h" #include "util.h"
@ -62,16 +64,16 @@ struct ID3Tag {
char genre; char genre;
}; };
metadata_t * metadata_create(const char *); static metadata_t * metadata_create(const char *);
void metadata_use_taglib(metadata_t *, FILE **); static void metadata_use_taglib(metadata_t *, FILE **);
void metadata_use_self(metadata_t *, FILE **); static void metadata_use_self(metadata_t *, FILE **);
void metadata_clean_md(metadata_t *); static void metadata_clean_md(metadata_t *);
void metadata_get_extension(char *, size_t, const char *); static void metadata_get_extension(char *, size_t, const char *);
char * metadata_get_name(const char *); static char * metadata_get_name(const char *);
void metadata_process_md(metadata_t *); static void metadata_process_md(metadata_t *);
void metadata_normalize_string(char **); static void metadata_normalize_string(char **);
metadata_t * static metadata_t *
metadata_create(const char *filename) metadata_create(const char *filename)
{ {
metadata_t *md; metadata_t *md;
@ -83,7 +85,7 @@ metadata_create(const char *filename)
return (md); return (md);
} }
void static void
metadata_use_taglib(metadata_t *md, FILE **filep) metadata_use_taglib(metadata_t *md, FILE **filep)
#ifdef HAVE_TAGLIB #ifdef HAVE_TAGLIB
{ {
@ -92,11 +94,6 @@ metadata_use_taglib(metadata_t *md, FILE **filep)
const TagLib_AudioProperties *ta; const TagLib_AudioProperties *ta;
char *str; char *str;
if (md == NULL || md->filename == NULL) {
log_alert("metadata_use_taglib: bad arguments");
abort();
}
if (filep != NULL) if (filep != NULL)
fclose(*filep); fclose(*filep);
@ -149,7 +146,7 @@ metadata_use_taglib(metadata_t *md, FILE **filep)
} }
#endif /* HAVE_TAGLIB */ #endif /* HAVE_TAGLIB */
void static void
metadata_use_self(metadata_t *md, FILE **filep) metadata_use_self(metadata_t *md, FILE **filep)
#ifdef HAVE_TAGLIB #ifdef HAVE_TAGLIB
{ {
@ -164,12 +161,6 @@ metadata_use_self(metadata_t *md, FILE **filep)
char extension[25]; char extension[25];
struct ID3Tag id3tag; struct ID3Tag id3tag;
if (md == NULL || filep == NULL || *filep == NULL ||
md->filename == NULL) {
log_alert("metadata_use_self: bad arguments");
abort();
}
metadata_clean_md(md); metadata_clean_md(md);
metadata_get_extension(extension, sizeof(extension), md->filename); metadata_get_extension(extension, sizeof(extension), md->filename);
@ -244,14 +235,9 @@ metadata_use_self(metadata_t *md, FILE **filep)
} }
#endif /* HAVE_TAGLIB */ #endif /* HAVE_TAGLIB */
void static void
metadata_clean_md(metadata_t *md) metadata_clean_md(metadata_t *md)
{ {
if (md == NULL) {
log_alert("metadata_clean_md: bad argument");
abort();
}
if (md->string != NULL) { if (md->string != NULL) {
xfree(md->string); xfree(md->string);
md->string = NULL; md->string = NULL;
@ -266,16 +252,11 @@ metadata_clean_md(metadata_t *md)
} }
} }
void static void
metadata_get_extension(char *buf, size_t siz, const char *filename) metadata_get_extension(char *buf, size_t siz, const char *filename)
{ {
char *p; char *p;
if (buf == NULL || siz == 0 || filename == NULL) {
log_alert("metadata_get_extension: bad arguments");
abort();
}
if ((p = strrchr(filename, '.')) != NULL) if ((p = strrchr(filename, '.')) != NULL)
strlcpy(buf, p, siz); strlcpy(buf, p, siz);
else else
@ -284,17 +265,12 @@ metadata_get_extension(char *buf, size_t siz, const char *filename)
*p = tolower((int)*p); *p = tolower((int)*p);
} }
char * static char *
metadata_get_name(const char *file) metadata_get_name(const char *file)
{ {
char *filename = xstrdup(file); char *filename = xstrdup(file);
char *p1, *p2, *name; char *p1, *p2, *name;
if (file == NULL) {
log_alert("metadata_get_name: bad arguments");
abort();
}
if ((p1 = basename(filename)) == NULL) { if ((p1 = basename(filename)) == NULL) {
log_alert("basename: unexpected failure with input: %s", log_alert("basename: unexpected failure with input: %s",
filename); filename);
@ -313,14 +289,9 @@ metadata_get_name(const char *file)
return (name); return (name);
} }
void static void
metadata_process_md(metadata_t *md) metadata_process_md(metadata_t *md)
{ {
if (md == NULL) {
log_alert("metadata_process_md: bad arguments");
abort();
}
if (md->string == NULL) if (md->string == NULL)
md->string = metadata_assemble_string(md); md->string = metadata_assemble_string(md);
@ -331,7 +302,7 @@ metadata_process_md(metadata_t *md)
} }
} }
void static void
metadata_normalize_string(char **s) metadata_normalize_string(char **s)
{ {
char *str, *cp, *tmpstr, *tp; char *str, *cp, *tmpstr, *tp;
@ -367,11 +338,6 @@ metadata_file(const char *filename, int normalize)
{ {
metadata_t *md; metadata_t *md;
if (filename == NULL || strlen(filename) == 0) {
log_alert("metadata_file: bad arguments");
abort();
}
md = metadata_create(filename); md = metadata_create(filename);
if (!metadata_file_update(md)) { if (!metadata_file_update(md)) {
metadata_free(&md); metadata_free(&md);
@ -393,11 +359,6 @@ metadata_program(const char *program, int normalize)
FILE *filep; FILE *filep;
#endif #endif
if (program == NULL || strlen(program) == 0) {
log_alert("metadata_program: bad arguments");
abort();
}
md = metadata_create(program); md = metadata_create(program);
md->program = 1; md->program = 1;
md->string = xstrdup(""); md->string = xstrdup("");
@ -456,15 +417,7 @@ metadata_file_update(metadata_t *md)
{ {
FILE *filep; FILE *filep;
if (md == NULL) { assert(!md->program);
log_alert("metadata_file_update: bad argument");
abort();
}
if (md->program) {
log_alert("metadata_file_update: called with program handle");
abort();
}
if ((filep = fopen(md->filename, "rb")) == NULL) { if ((filep = fopen(md->filename, "rb")) == NULL) {
log_error("%s: %s", md->filename, strerror(errno)); log_error("%s: %s", md->filename, strerror(errno));
@ -489,15 +442,7 @@ metadata_program_update(metadata_t *md, enum metadata_request md_req)
char buf[METADATA_MAX + 1]; char buf[METADATA_MAX + 1];
char command[PATH_MAX + sizeof(" artist")]; char command[PATH_MAX + sizeof(" artist")];
if (md == NULL) { assert(md->program);
log_alert("metadata_program_update: bad argument");
abort();
}
if (!md->program) {
log_alert("metadata_program_update: called with file handle");
abort();
}
switch (md_req) { switch (md_req) {
case METADATA_ALL: case METADATA_ALL:
@ -600,27 +545,13 @@ metadata_program_update(metadata_t *md, enum metadata_request md_req)
const char * const char *
metadata_get_string(metadata_t *md) metadata_get_string(metadata_t *md)
{ {
if (md == NULL) { assert(md->string);
log_alert("metadata_get_string: bad argument");
abort();
}
if (md->string == NULL) {
log_alert("metadata_get_string: md->string is NULL");
abort();
}
return (md->string); return (md->string);
} }
const char * const char *
metadata_get_artist(metadata_t *md) metadata_get_artist(metadata_t *md)
{ {
if (md == NULL) {
log_alert("metadata_get_artist: bad argument");
abort();
}
if (md->artist == NULL) if (md->artist == NULL)
return (blankString); return (blankString);
else else
@ -630,11 +561,6 @@ metadata_get_artist(metadata_t *md)
const char * const char *
metadata_get_title(metadata_t *md) metadata_get_title(metadata_t *md)
{ {
if (md == NULL) {
log_alert("metadata_get_title: bad argument");
abort();
}
if (md->title == NULL) if (md->title == NULL)
return (blankString); return (blankString);
else else
@ -644,11 +570,6 @@ metadata_get_title(metadata_t *md)
const char * const char *
metadata_get_filename(metadata_t *md) metadata_get_filename(metadata_t *md)
{ {
if (md == NULL) {
log_alert("metadata_get_filename: bad argument");
abort();
}
if (md->filename == NULL) if (md->filename == NULL)
/* Should never happen: */ /* Should never happen: */
return (blankString); return (blankString);
@ -659,11 +580,6 @@ metadata_get_filename(metadata_t *md)
int int
metadata_get_length(metadata_t *md) metadata_get_length(metadata_t *md)
{ {
if (md == NULL) {
log_alert("metadata_get_length: bad argument");
abort();
}
return (md->songLen); return (md->songLen);
} }
@ -673,11 +589,6 @@ metadata_assemble_string(metadata_t *md)
size_t len; size_t len;
char *str; char *str;
if (md == NULL) {
log_alert("metadata_assemble_string: bad argument");
abort();
}
if (md->artist == NULL && md->title == NULL && md->program == 0) if (md->artist == NULL && md->title == NULL && md->program == 0)
return (metadata_get_name(md->filename)); return (metadata_get_name(md->filename));

188
src/playlist.c
View File

@ -39,12 +39,12 @@ struct playlist {
char *prog_track; char *prog_track;
}; };
playlist_t * playlist_create(const char *); static playlist_t * playlist_create(const char *);
int playlist_add(playlist_t *, const char *); static int playlist_add(playlist_t *, const char *);
unsigned int playlist_random(void); static unsigned int playlist_random(void);
const char * playlist_run_program(playlist_t *); static const char * playlist_run_program(playlist_t *);
playlist_t * static playlist_t *
playlist_create(const char *filename) playlist_create(const char *filename)
{ {
playlist_t *pl; playlist_t *pl;
@ -55,16 +55,11 @@ playlist_create(const char *filename)
return (pl); return (pl);
} }
int static int
playlist_add(playlist_t *pl, const char *entry) playlist_add(playlist_t *pl, const char *entry)
{ {
size_t num; size_t num;
if (pl == NULL || entry == NULL) {
log_alert("playlist_add: bad arguments");
abort();
}
num = pl->num + 1; num = pl->num + 1;
if (pl->size == 0) { if (pl->size == 0) {
@ -88,7 +83,7 @@ playlist_add(playlist_t *pl, const char *entry)
return (1); return (1);
} }
unsigned int static unsigned int
playlist_random(void) playlist_random(void)
{ {
unsigned int ret = 0; unsigned int ret = 0;
@ -104,6 +99,63 @@ playlist_random(void)
return (ret); return (ret);
} }
static const char *
playlist_run_program(playlist_t *pl)
{
FILE *filep;
char buf[PATH_MAX];
if (!pl->program)
return (NULL);
fflush(NULL);
errno = 0;
log_debug("running command: %s", pl->filename);
if ((filep = popen(pl->filename, "r")) == NULL) {
/* popen() does not set errno reliably ... */
if (errno)
log_error("execution error: %s: %s", pl->filename,
strerror(errno));
else
log_error("execution error: %s", pl->filename);
return (NULL);
}
if (fgets(buf, (int)sizeof(buf), filep) == NULL) {
int errnum = errno;
pclose(filep);
if (ferror(filep)) {
log_alert("%s: output read error: %s", pl->filename,
strerror(errnum));
exit(1);
}
/* No output (end of playlist.) */
return (NULL);
}
pclose(filep);
if (strlen(buf) == sizeof(buf) - 1) {
log_error("%s: output too long", pl->filename);
return (NULL);
}
buf[strcspn(buf, "\n")] = '\0';
buf[strcspn(buf, "\r")] = '\0';
if (buf[0] == '\0')
/* Empty line (end of playlist.) */
return (NULL);
if (pl->prog_track != NULL)
xfree(pl->prog_track);
pl->prog_track = xstrdup(buf);
return ((const char *)pl->prog_track);
}
void void
playlist_init(void) playlist_init(void)
{ {
@ -279,11 +331,6 @@ playlist_free(playlist_t **pl_p)
const char * const char *
playlist_get_next(playlist_t *pl) playlist_get_next(playlist_t *pl)
{ {
if (pl == NULL) {
log_alert("playlist_get_next: bad argument");
abort();
}
if (pl->program) if (pl->program)
return (playlist_run_program(pl)); return (playlist_run_program(pl));
@ -296,11 +343,6 @@ playlist_get_next(playlist_t *pl)
const char * const char *
playlist_peek_next(playlist_t *pl) playlist_peek_next(playlist_t *pl)
{ {
if (pl == NULL) {
log_alert("playlist_peek_next: bad argument");
abort();
}
if (pl->program || pl->num == 0) if (pl->program || pl->num == 0)
return (NULL); return (NULL);
@ -310,11 +352,6 @@ playlist_peek_next(playlist_t *pl)
void void
playlist_skip_next(playlist_t *pl) playlist_skip_next(playlist_t *pl)
{ {
if (pl == NULL) {
log_alert("playlist_skip_next: bad argument");
abort();
}
if (pl->program || pl->num == 0) if (pl->program || pl->num == 0)
return; return;
@ -325,11 +362,6 @@ playlist_skip_next(playlist_t *pl)
unsigned long unsigned long
playlist_get_num_items(playlist_t *pl) playlist_get_num_items(playlist_t *pl)
{ {
if (pl == NULL) {
log_alert("playlist_get_position: bad argument");
abort();
}
if (pl->program) if (pl->program)
return (0); return (0);
@ -339,11 +371,6 @@ playlist_get_num_items(playlist_t *pl)
unsigned long unsigned long
playlist_get_position(playlist_t *pl) playlist_get_position(playlist_t *pl)
{ {
if (pl == NULL) {
log_alert("playlist_get_position: bad argument");
abort();
}
if (pl->program) if (pl->program)
return (0); return (0);
@ -353,11 +380,6 @@ playlist_get_position(playlist_t *pl)
int int
playlist_set_position(playlist_t *pl, unsigned long idx) playlist_set_position(playlist_t *pl, unsigned long idx)
{ {
if (pl == NULL) {
log_alert("playlist_set_position: bad argument");
abort();
}
if (pl->program || idx > pl->num - 1) if (pl->program || idx > pl->num - 1)
return (0); return (0);
@ -371,11 +393,6 @@ playlist_goto_entry(playlist_t *pl, const char *entry)
{ {
unsigned long i; unsigned long i;
if (pl == NULL || entry == NULL) {
log_alert("playlist_goto_entry: bad arguments");
abort();
}
if (pl->program) if (pl->program)
return (0); return (0);
@ -392,11 +409,6 @@ playlist_goto_entry(playlist_t *pl, const char *entry)
void void
playlist_rewind(playlist_t *pl) playlist_rewind(playlist_t *pl)
{ {
if (pl == NULL) {
log_alert("playlist_rewind: bad argument");
abort();
}
if (pl->program) if (pl->program)
return; return;
@ -408,11 +420,6 @@ playlist_reread(playlist_t **plist)
{ {
playlist_t *new_pl, *pl; playlist_t *new_pl, *pl;
if (plist == NULL || *plist == NULL) {
log_alert("playlist_reread: bad argument");
abort();
}
pl = *plist; pl = *plist;
if (pl->program) if (pl->program)
@ -436,11 +443,6 @@ playlist_shuffle(playlist_t *pl)
size_t d, i, range; size_t d, i, range;
char *temp; char *temp;
if (pl == NULL) {
log_alert("playlist_shuffle: bad argument");
abort();
}
if (pl->program || pl->num < 2) if (pl->program || pl->num < 2)
return; return;
@ -466,65 +468,3 @@ playlist_shuffle(playlist_t *pl)
pl->list[i] = temp; pl->list[i] = temp;
} }
} }
const char *
playlist_run_program(playlist_t *pl)
{
FILE *filep;
char buf[PATH_MAX];
if (pl == NULL) {
log_alert("playlist_run_program: bad argument");
abort();
}
if (!pl->program)
return (NULL);
fflush(NULL);
errno = 0;
log_debug("running command: %s", pl->filename);
if ((filep = popen(pl->filename, "r")) == NULL) {
/* popen() does not set errno reliably ... */
if (errno)
log_error("execution error: %s: %s", pl->filename,
strerror(errno));
else
log_error("execution error: %s", pl->filename);
return (NULL);
}
if (fgets(buf, (int)sizeof(buf), filep) == NULL) {
int errnum = errno;
pclose(filep);
if (ferror(filep)) {
log_alert("%s: output read error: %s", pl->filename,
strerror(errnum));
exit(1);
}
/* No output (end of playlist.) */
return (NULL);
}
pclose(filep);
if (strlen(buf) == sizeof(buf) - 1) {
log_error("%s: output too long", pl->filename);
return (NULL);
}
buf[strcspn(buf, "\n")] = '\0';
buf[strcspn(buf, "\r")] = '\0';
if (buf[0] == '\0')
/* Empty line (end of playlist.) */
return (NULL);
if (pl->prog_track != NULL)
xfree(pl->prog_track);
pl->prog_track = xstrdup(buf);
return ((const char *)pl->prog_track);
}