mpdws

mpdws.c (6728B)

---

 #include "mpdws.h"
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/select.h>
 #include <syslog.h>
 #include <time.h>
 #include <unistd.h>
 
 static struct mpd_ws_server *g_server = NULL;
 
 static void signal_handler(int sig) {
   (void)sig;
   if (g_server)
     g_server->running = 0;
 }
 
 static void broadcast_current_song(struct mpd_ws_server *server) {
   struct client_session *client = server->clients;
   size_t len = strlen(server->current_song);
 
   while (client) {
     unsigned char buf[LWS_PRE + MAX_MESSAGE_SIZE];
     memcpy(&buf[LWS_PRE], server->current_song, len);
     lws_write(client->wsi, &buf[LWS_PRE], len, LWS_WRITE_TEXT);
     client = client->next;
   }
 }
 
 static int ws_callback(struct lws *wsi, enum lws_callback_reasons reason,
                        void *user, void *in, size_t len) {
   (void)user;
   (void)in;
   (void)len;
 
   struct mpd_ws_server *server =
       (struct mpd_ws_server *)lws_context_user(lws_get_context(wsi));
 
   switch (reason) {
   case LWS_CALLBACK_ESTABLISHED: {
     struct client_session *client = malloc(sizeof(*client));
     if (client) {
       client->wsi = wsi;
       client->next = server->clients;
       server->clients = client;
       syslog(LOG_INFO, "Client connected");
       if (strlen(server->current_song) > 0) {
         lws_callback_on_writable(wsi);
       }
     }
     break;
   }
   case LWS_CALLBACK_CLOSED: {
     struct client_session **current = &server->clients;
     while (*current) {
       if ((*current)->wsi == wsi) {
         struct client_session *to_remove = *current;
         *current = (*current)->next;
         free(to_remove);
         syslog(LOG_INFO, "Client disconnected");
         break;
       }
       current = &(*current)->next;
     }
     break;
   }
   case LWS_CALLBACK_SERVER_WRITEABLE:
     if (strlen(server->current_song) > 0) {
       unsigned char buf[LWS_PRE + MAX_MESSAGE_SIZE];
       size_t msg_len = strlen(server->current_song);
       memcpy(&buf[LWS_PRE], server->current_song, msg_len);
       lws_write(wsi, &buf[LWS_PRE], msg_len, LWS_WRITE_TEXT);
     }
     break;
   default:
     break;
   }
   return 0;
 }
 
 static struct lws_protocols protocols[] = {
     {"mpd-protocol", ws_callback, 0, MAX_MESSAGE_SIZE, 0, NULL, 0},
     {NULL, NULL, 0, 0, 0, NULL, 0}};
 
 static int connect_mpd(struct mpd_ws_server *server) {
   if (server->mpd_conn) {
     if (server->mpd_idle_active) {
       mpd_send_noidle(server->mpd_conn);
       mpd_response_finish(server->mpd_conn);
     }
     mpd_connection_free(server->mpd_conn);
   }
 
   server->mpd_conn = mpd_connection_new(MPD_HOST, MPD_PORT, 0);
   server->mpd_idle_active = 0;
 
   if (mpd_connection_get_error(server->mpd_conn) != MPD_ERROR_SUCCESS) {
     syslog(LOG_ERR, "MPD connection failed: %s",
            mpd_connection_get_error_message(server->mpd_conn));
     mpd_connection_free(server->mpd_conn);
     server->mpd_conn = NULL;
     return -1;
   }
 
   syslog(LOG_INFO, "Connected to MPD at %s:%d", MPD_HOST, MPD_PORT);
   return 0;
 }
 
 static void update_current_song(struct mpd_ws_server *server) {
   if (!server->mpd_conn ||
       mpd_connection_get_error(server->mpd_conn) != MPD_ERROR_SUCCESS) {
     return;
   }
 
   mpd_send_current_song(server->mpd_conn);
   struct mpd_song *song = mpd_recv_song(server->mpd_conn);
 
   if (mpd_connection_get_error(server->mpd_conn) != MPD_ERROR_SUCCESS) {
     mpd_response_finish(server->mpd_conn);
     return;
   }
 
   char new_song[MAX_MESSAGE_SIZE];
   if (!song) {
     snprintf(new_song, sizeof(new_song), "Now Playing: No song");
   } else {
     const char *artist = mpd_song_get_tag(song, MPD_TAG_ARTIST, 0);
     const char *title = mpd_song_get_tag(song, MPD_TAG_TITLE, 0);
 
     snprintf(new_song, sizeof(new_song), "Now Playing: %s - %s", artist, title);
     mpd_song_free(song);
   }
 
   // Only send song if it's changed
   if (strcmp(new_song, server->current_song) != 0) {
     strlcpy(server->current_song, new_song, sizeof(server->current_song));
     broadcast_current_song(server);
     syslog(LOG_DEBUG, "Broadcasting: %s", server->current_song);
   }
 
   mpd_response_finish(server->mpd_conn);
 }
 
 int mpd_ws_init(struct mpd_ws_server *server) {
   memset(server, 0, sizeof(*server));
 
   g_server = server;
   signal(SIGINT, signal_handler);
   signal(SIGTERM, signal_handler);
   openlog("mpd_ws", LOG_PID | LOG_NDELAY, LOG_DAEMON);
 
   struct lws_context_creation_info info = {0};
   info.port = WEBSOCKET_PORT;
   info.protocols = protocols;
   info.gid = info.uid = -1;
   info.user = server;
 
   server->ws_context = lws_create_context(&info);
   if (!server->ws_context) {
     syslog(LOG_ERR, "Failed to create WebSocket context");
     return -1;
   }
 
   syslog(LOG_INFO, "WebSocket server listening on port %d", WEBSOCKET_PORT);
   connect_mpd(server);
   server->running = 1;
   return 0;
 }
 
 void mpd_ws_run(struct mpd_ws_server *server) {
   time_t last_reconnect = 0;
 
   while (server->running) {
     lws_service(server->ws_context, 10);
 
     // Handle MPD connection
     if (!server->mpd_conn ||
         mpd_connection_get_error(server->mpd_conn) != MPD_ERROR_SUCCESS) {
       time_t now = time(NULL);
       if (now - last_reconnect >= RECONNECT_INTERVAL_SEC) {
         if (connect_mpd(server) == 0) {
           update_current_song(server);
         }
         last_reconnect = now;
       }
       sleep(SELECT_TIMEOUT_SEC);
       continue;
     }
 
     // Start idle if needed
     if (!server->mpd_idle_active) {
       if (mpd_send_idle_mask(server->mpd_conn, MPD_IDLE_PLAYER)) {
         server->mpd_idle_active = 1;
       } else {
         connect_mpd(server);
         continue;
       }
     }
 
     // Check for MPD events
     fd_set readfds;
     int mpd_fd = mpd_connection_get_fd(server->mpd_conn);
     struct timeval timeout = {0, SELECT_TIMEOUT_SEC};
 
     FD_ZERO(&readfds);
     FD_SET(mpd_fd, &readfds);
 
     if (select(mpd_fd + 1, &readfds, NULL, NULL, &timeout) > 0 &&
         FD_ISSET(mpd_fd, &readfds)) {
 
       enum mpd_idle events = mpd_recv_idle(server->mpd_conn, false);
       server->mpd_idle_active = 0;
 
       if (mpd_connection_get_error(server->mpd_conn) == MPD_ERROR_SUCCESS) {
         if (events & MPD_IDLE_PLAYER) {
           update_current_song(server);
         }
       }
     }
   }
 }
 
 void mpd_ws_cleanup(struct mpd_ws_server *server) {
   syslog(LOG_INFO, "Shutting down");
 
   if (server->mpd_conn) {
     if (server->mpd_idle_active) {
       mpd_send_noidle(server->mpd_conn);
       mpd_response_finish(server->mpd_conn);
     }
     mpd_connection_free(server->mpd_conn);
   }
 
   if (server->ws_context) {
     lws_context_destroy(server->ws_context);
   }
 
   while (server->clients) {
     struct client_session *next = server->clients->next;
     free(server->clients);
     server->clients = next;
   }
 
   closelog();
 }