#include <mpd/idle.h>
#include <mpd/tag.h>
#include <mpd/status.h>
#include <mpd/client.h>
#include <stdio.h>
#include <assert.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h>
struct mpd_connection *conn;
typedef struct mpd_song mpd_song_t;
typedef struct mpd_status mpd_status_t;
#define MAINLOOP_ERROR do { handle_error(conn); return; } while (0)
#define MAX_HASH 1021
#define MAX_INFO_BUFF 256
#define MAX_OUTPUT_BUFF 2048
const char *host = "192.168.248.130";
unsigned int port = 6600;
const char *state_name[4] = {"unknown", "stopped", "now playing", "paused"};
const char *shell = "bash";
const char *trigger_command = "terminal-notifier -title \"{title}: {state} ({elapsed_pct}%)\" "
"-subtitle \"{artist}\" -message \"{album} @ {track?{track}:unknown track}\" -sender com.apple.iTunes";
typedef const char *(*Hook_t)(mpd_status_t status, mpd_song_t song);
typedef struct Entry {
const char *name;
const char **content_ref;
struct Entry *next;
} Entry;
typedef struct {
Entry *head[MAX_HASH];
} HashTable;
HashTable *hash_table_create() {
HashTable *ht = (HashTable *)malloc(sizeof(HashTable));
memset(ht->head, sizeof(ht->head), 0);
return ht;
}
unsigned hash_table_hash_func(const char *name) {
unsigned int seed = 131, res = 0;
while (*name)
res = res * seed + (*name++ - 'a');
return res % MAX_HASH;
}
void hash_table_destroy(HashTable *ht) {
unsigned int i;
for (i = 0; i < MAX_HASH; i++)
{
Entry *e, *ne;
for (e = ht->head[i]; e; e = ne)
{
ne = e->next;
free(e);
}
}
}
void hash_table_register(HashTable *ht, const char *name, const char **content_ref) {
unsigned int hv = hash_table_hash_func(name);
Entry *e = (Entry *)malloc(sizeof(Entry));
e->name = name;
e->content_ref = content_ref;
e->next = ht->head[hv];
ht->head[hv] = e;
}
const char *hash_table_lookup(HashTable *ht, const char *name) {
unsigned int hv = hash_table_hash_func(name);
Entry *e;
for (e = ht->head[hv]; e; e = e->next)
if (!strcmp(e->name, name))
return *(e->content_ref);
return NULL;
}
char etime_buff[MAX_INFO_BUFF], ttime_buff[MAX_INFO_BUFF], epct_buff[MAX_INFO_BUFF];
const char *title, *artist, *album, *track, *state,
*elapsed_time = etime_buff, *total_time = ttime_buff, *elapsed_pct = epct_buff;
HashTable *dict;
void handle_error(struct mpd_connection *conn) {
fprintf(stderr, "%s\n", mpd_connection_get_error_message(conn));
mpd_connection_free(conn);
}
const char *substitution(const char *exp, size_t *size) {
static char output_buff[MAX_OUTPUT_BUFF];
const char *content;
char *optr = output_buff;
char *cond_pos = NULL, *sep_pos = NULL;
*size = 0;
while (*exp)
{
if (*exp == '?') cond_pos = optr;
else if (*exp == ':') sep_pos = optr;
*optr++ = *exp++;
(*size)++;
}
*optr = '\0';
if (cond_pos && sep_pos) /* a substitution */
{
char *start;
*cond_pos = '\0';
*sep_pos = '\0';
content = hash_table_lookup(dict, output_buff);
start = (content && *content) ? cond_pos + 1: sep_pos + 1;
*size = strlen(start);
memmove(output_buff, start, *size);
output_buff[*size] = '\0';
}
else
{
if ((content = hash_table_lookup(dict, output_buff)))
{
*size = strlen(content);
memmove(output_buff, content, *size);
output_buff[*size] = '\0';
}
}
return output_buff;
}
const char *filter(const char *input) {
static char output_buff[MAX_OUTPUT_BUFF];
static char *pos[MAX_OUTPUT_BUFF];
char *optr = output_buff;
char **pptr = pos - 1;
enum {
ESCAPE,
NORMAL
} state = NORMAL;
while (*input)
{
if (state == NORMAL)
{
if (*input == '\\')
state = ESCAPE;
else if (*input == '}')
{
size_t csize;
const char *content;
char *bptr = optr - 1;
if (pptr >= pos)
{
while (bptr != *pptr) bptr--;
*optr = '\0'; /* mark the end of the token */
content = substitution(bptr + 1, &csize);
memmove(bptr, content, csize);
optr = bptr + csize;
pptr--;
}
else *optr++ = '}';
state = NORMAL;
}
else
{
if (*input == '{')
*(++pptr) = optr;
*optr++ = *input;
}
}
else
{
*optr++ = *input;
state = NORMAL;
}
input++;
}
*optr = '\0';
return output_buff;
}
void trigger(const char *filtered_cmd) {
pid_t pid;
int fd[2];
pipe(fd);
fprintf(stderr, "executing: %s\n", filtered_cmd);
if ((pid = fork()) == -1)
{
fprintf(stderr, "failed to fork\n");
return;
}
else if (!pid)
{
dup2(fd[0], 0); /* override stdin */
close(fd[0]);
close(fd[1]);
execlp(shell, shell, (char *)NULL);
}
close(fd[0]);
write(fd[1], filtered_cmd, strlen(filtered_cmd));
close(fd[1]);
waitpid(pid, NULL, 0);
}
void main_loop() {
for (;;)
{