1 /* ncmpc (Ncurses MPD Client)
2 * (c) 2004-2010 The Music Player Daemon Project
3 * Project homepage: http://musicpd.org
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
20 #include "config.h"
21 #include "ncmpc.h"
22 #include "mpdclient.h"
23 #include "gidle.h"
24 #include "charset.h"
25 #include "options.h"
26 #include "command.h"
27 #include "ncu.h"
28 #include "screen.h"
29 #include "screen_utils.h"
30 #include "screen_message.h"
31 #include "strfsong.h"
32 #include "i18n.h"
33 #include "player_command.h"
35 #ifndef NCMPC_MINI
36 #include "conf.h"
37 #endif
39 #ifdef ENABLE_LYRICS_SCREEN
40 #include "lyrics.h"
41 #endif
43 #ifdef ENABLE_LIRC
44 #include "lirc.h"
45 #endif
47 #include <mpd/client.h>
49 #include <stdlib.h>
50 #include <unistd.h>
51 #include <fcntl.h>
52 #include <signal.h>
53 #include <string.h>
55 #ifdef ENABLE_LOCALE
56 #include <locale.h>
57 #endif
59 /* time between mpd updates [ms] */
60 static const guint update_interval = 500;
62 #define BUFSIZE 1024
64 static struct mpdclient *mpd = NULL;
65 static GMainLoop *main_loop;
66 static guint reconnect_source_id, update_source_id;
67 static int sigwinch_pipes[2];
69 #ifndef NCMPC_MINI
70 static guint check_key_bindings_source_id;
71 #endif
73 #ifndef NCMPC_MINI
74 static void
75 update_xterm_title(void)
76 {
77 static char title[BUFSIZE];
78 char tmp[BUFSIZE];
79 struct mpd_status *status = NULL;
80 const struct mpd_song *song = NULL;
82 if (mpd) {
83 status = mpd->status;
84 song = mpd->song;
85 }
87 if (options.xterm_title_format && status && song &&
88 mpd_status_get_state(status) == MPD_STATE_PLAY)
89 strfsong(tmp, BUFSIZE, options.xterm_title_format, song);
90 else
91 g_strlcpy(tmp, PACKAGE " version " VERSION, BUFSIZE);
93 if (strncmp(title, tmp, BUFSIZE)) {
94 g_strlcpy(title, tmp, BUFSIZE);
95 set_xterm_title("%s", title);
96 }
97 }
98 #endif
100 static void
101 exit_and_cleanup(void)
102 {
103 screen_exit();
104 #ifndef NCMPC_MINI
105 set_xterm_title("");
106 #endif
107 printf("\n");
109 if (mpd) {
110 mpdclient_disconnect(mpd);
111 mpdclient_free(mpd);
112 }
113 }
115 static void
116 catch_sigint(G_GNUC_UNUSED int sig)
117 {
118 g_main_loop_quit(main_loop);
119 }
122 static void
123 catch_sigcont(G_GNUC_UNUSED int sig)
124 {
125 char irrelevant = 'a';
126 if (1 != write(sigwinch_pipes[1], &irrelevant, 1))
127 exit(EXIT_FAILURE);
128 }
130 void
131 sigstop(void)
132 {
133 def_prog_mode(); /* save the tty modes */
134 endwin(); /* end curses mode temporarily */
135 kill(0, SIGSTOP); /* issue SIGSTOP */
136 }
138 static gboolean
139 sigwinch_event(G_GNUC_UNUSED GIOChannel *source,
140 G_GNUC_UNUSED GIOCondition condition, G_GNUC_UNUSED gpointer data)
141 {
142 char ignoreme[64];
143 if (1 > read(sigwinch_pipes[0], ignoreme, 64))
144 exit(EXIT_FAILURE);
146 endwin();
147 refresh();
148 screen_resize(mpd);
150 return TRUE;
151 }
153 static void
154 catch_sigwinch(G_GNUC_UNUSED int sig)
155 {
156 char irrelevant = 'a';
157 if (1 != write(sigwinch_pipes[1], &irrelevant, 1))
158 exit(EXIT_FAILURE);
159 }
161 static void
162 idle_callback(enum mpd_error error,
163 G_GNUC_UNUSED enum mpd_server_error server_error,
164 const char *message, enum mpd_idle events,
165 G_GNUC_UNUSED void *ctx);
167 static gboolean
168 timer_mpd_update(gpointer data);
170 static void
171 enable_update_timer(void)
172 {
173 if (update_source_id != 0)
174 return;
176 update_source_id = g_timeout_add(update_interval,
177 timer_mpd_update, NULL);
178 }
180 static void
181 disable_update_timer(void)
182 {
183 if (update_source_id == 0)
184 return;
186 g_source_remove(update_source_id);
187 update_source_id = 0;
188 }
190 static bool
191 should_enable_update_timer(void)
192 {
193 return (mpdclient_is_connected(mpd) &&
194 (mpd->source == NULL || /* "idle" not supported */
195 (mpd->status != NULL &&
196 mpd_status_get_state(mpd->status) == MPD_STATE_PLAY)))
197 #ifndef NCMPC_MINI
198 || options.display_time
199 #endif
200 ;
201 }
203 static void
204 auto_update_timer(void)
205 {
206 if (should_enable_update_timer())
207 enable_update_timer();
208 else
209 disable_update_timer();
210 }
212 static void
213 check_reconnect(void);
215 static void
216 do_mpd_update(void)
217 {
218 if (mpdclient_is_connected(mpd) &&
219 (mpd->source == NULL || mpd->events != 0 ||
220 (mpd->status != NULL &&
221 mpd_status_get_state(mpd->status) == MPD_STATE_PLAY)))
222 mpdclient_update(mpd);
224 #ifndef NCMPC_MINI
225 if (options.enable_xterm_title)
226 update_xterm_title();
227 #endif
229 screen_update(mpd);
230 mpd->events = 0;
232 mpdclient_put_connection(mpd);
233 check_reconnect();
234 }
236 #if LIBMPDCLIENT_CHECK_VERSION(2,4,0)
238 static char *
239 settings_name(const struct mpd_settings *settings)
240 {
241 const char *host = mpd_settings_get_host(settings);
242 if (host == NULL)
243 host = "unknown";
245 if (host[0] == '/')
246 return g_strdup(host);
248 unsigned port = mpd_settings_get_port(settings);
249 if (port == 0 || port == 6600)
250 return g_strdup(host);
252 return g_strdup_printf("%s:%u", host, port);
253 }
255 #endif
257 static char *
258 default_settings_name(void)
259 {
260 #if LIBMPDCLIENT_CHECK_VERSION(2,4,0)
261 struct mpd_settings *settings =
262 mpd_settings_new(options.host, options.port, 0,
263 NULL, options.password);
264 if (settings == NULL)
265 return g_strdup("unknown");
267 char *name = settings_name(settings);
268 mpd_settings_free(settings);
270 return name;
271 #else
272 return g_strdup(options.host);
273 #endif
274 }
276 static char *
277 connection_settings_name(const struct mpd_connection *connection)
278 {
279 #if LIBMPDCLIENT_CHECK_VERSION(2,4,0)
280 const struct mpd_settings *settings =
281 mpd_connection_get_settings(connection);
282 if (settings == NULL)
283 return g_strdup("unknown");
285 return settings_name(settings);
286 #else
287 (void)connection;
288 return g_strdup(options.host);
289 #endif
290 }
292 /**
293 * This timer is installed when the connection to the MPD server is
294 * broken. It tries to recover by reconnecting periodically.
295 */
296 static gboolean
297 timer_reconnect(G_GNUC_UNUSED gpointer data)
298 {
299 bool success;
300 struct mpd_connection *connection;
302 assert(!mpdclient_is_connected(mpd));
304 reconnect_source_id = 0;
306 char *name = default_settings_name();
307 screen_status_printf(_("Connecting to %s... [Press %s to abort]"),
308 name, get_key_names(CMD_QUIT,0) );
309 g_free(name);
310 doupdate();
312 mpdclient_disconnect(mpd);
313 success = mpdclient_connect(mpd,
314 options.host, options.port,
315 1.5,
316 options.password);
317 if (!success) {
318 /* try again in 5 seconds */
319 reconnect_source_id = g_timeout_add(5000,
320 timer_reconnect, NULL);
321 return FALSE;
322 }
324 connection = mpdclient_get_connection(mpd);
326 #ifndef NCMPC_MINI
327 /* quit if mpd is pre 0.11.0 - song id not supported by mpd */
328 if (mpd_connection_cmp_server_version(connection, 0, 12, 0) < 0) {
329 const unsigned *version =
330 mpd_connection_get_server_version(connection);
331 screen_status_printf(_("Error: MPD version %d.%d.%d is to old (%s needed)"),
332 version[0], version[1], version[2],
333 "0.12.0");
334 mpdclient_disconnect(mpd);
335 doupdate();
337 /* try again after 30 seconds */
338 reconnect_source_id = g_timeout_add(30000,
339 timer_reconnect, NULL);
340 return FALSE;
341 }
342 #endif
344 if (mpd_connection_cmp_server_version(connection,
345 0, 14, 0) >= 0)
346 mpd->source = mpd_glib_new(connection,
347 idle_callback, mpd);
349 name = connection_settings_name(connection);
350 screen_status_printf(_("Connected to %s"), name);
351 g_free(name);
352 doupdate();
354 /* update immediately */
355 mpd->events = MPD_IDLE_DATABASE|MPD_IDLE_STORED_PLAYLIST|
356 MPD_IDLE_QUEUE|MPD_IDLE_PLAYER|MPD_IDLE_MIXER|MPD_IDLE_OUTPUT|
357 MPD_IDLE_OPTIONS|MPD_IDLE_UPDATE;
359 do_mpd_update();
361 auto_update_timer();
363 return FALSE;
364 }
366 static void
367 check_reconnect(void)
368 {
369 if (!mpdclient_is_connected(mpd) && reconnect_source_id == 0)
370 /* reconnect when the connection is lost */
371 reconnect_source_id = g_timeout_add(1000, timer_reconnect,
372 NULL);
373 }
375 /**
376 * This function is called by the gidle.c library when MPD sends us an
377 * idle event (or when the connectiond dies).
378 */
379 static void
380 idle_callback(enum mpd_error error, enum mpd_server_error server_error,
381 const char *message, enum mpd_idle events,
382 void *ctx)
383 {
384 struct mpdclient *c = ctx;
385 struct mpd_connection *connection;
387 c->idle = false;
389 connection = mpdclient_get_connection(c);
390 assert(connection != NULL);
392 if (error != MPD_ERROR_SUCCESS) {
393 char *allocated;
395 if (error == MPD_ERROR_SERVER &&
396 server_error == MPD_SERVER_ERROR_UNKNOWN_CMD) {
397 /* the "idle" command is not supported - fall
398 back to timer based polling */
399 mpd_glib_free(c->source);
400 c->source = NULL;
401 auto_update_timer();
402 return;
403 }
405 if (error == MPD_ERROR_SERVER)
406 message = allocated = utf8_to_locale(message);
407 else
408 allocated = NULL;
409 screen_status_message(message);
410 g_free(allocated);
411 screen_bell();
412 doupdate();
414 mpdclient_disconnect(c);
415 screen_update(mpd);
416 reconnect_source_id = g_timeout_add(1000, timer_reconnect,
417 NULL);
418 return;
419 }
421 c->events |= events;
422 mpdclient_update(c);
424 #ifndef NCMPC_MINI
425 if (options.enable_xterm_title)
426 update_xterm_title();
427 #endif
429 screen_update(mpd);
430 c->events = 0;
432 mpdclient_put_connection(c);
433 check_reconnect();
434 auto_update_timer();
435 }
437 static gboolean
438 timer_mpd_update(G_GNUC_UNUSED gpointer data)
439 {
440 do_mpd_update();
442 if (should_enable_update_timer())
443 return true;
444 else {
445 update_source_id = 0;
446 return false;
447 }
448 }
450 void begin_input_event(void)
451 {
452 }
454 void end_input_event(void)
455 {
456 screen_update(mpd);
457 mpd->events = 0;
459 mpdclient_put_connection(mpd);
460 check_reconnect();
461 auto_update_timer();
462 }
464 int do_input_event(command_t cmd)
465 {
466 if (cmd == CMD_QUIT) {
467 g_main_loop_quit(main_loop);
468 return -1;
469 }
471 screen_cmd(mpd, cmd);
473 if (cmd == CMD_VOLUME_UP || cmd == CMD_VOLUME_DOWN)
474 /* make sure we don't update the volume yet */
475 disable_update_timer();
477 return 0;
478 }
480 static gboolean
481 keyboard_event(G_GNUC_UNUSED GIOChannel *source,
482 G_GNUC_UNUSED GIOCondition condition,
483 G_GNUC_UNUSED gpointer data)
484 {
485 command_t cmd;
487 begin_input_event();
489 if ((cmd=get_keyboard_command()) != CMD_NONE)
490 if (do_input_event(cmd) != 0)
491 return FALSE;
493 end_input_event();
494 return TRUE;
495 }
497 #ifndef NCMPC_MINI
498 /**
499 * Check the configured key bindings for errors, and display a status
500 * message every 10 seconds.
501 */
502 static gboolean
503 timer_check_key_bindings(G_GNUC_UNUSED gpointer data)
504 {
505 char buf[256];
506 #ifdef ENABLE_KEYDEF_SCREEN
507 char comment[64];
508 #endif
509 gboolean key_error;
511 key_error = check_key_bindings(NULL, buf, sizeof(buf));
512 if (!key_error) {
513 /* no error: disable this timer for the rest of this
514 process */
515 check_key_bindings_source_id = 0;
516 return FALSE;
517 }
519 #ifdef ENABLE_KEYDEF_SCREEN
520 g_strchomp(buf);
521 g_strlcat(buf, " (", sizeof(buf));
522 /* to translators: a key was bound twice in the key editor,
523 and this is a hint for the user what to press to correct
524 that */
525 g_snprintf(comment, sizeof(comment), _("press %s for the key editor"),
526 get_key_names(CMD_SCREEN_KEYDEF, 0));
527 g_strlcat(buf, comment, sizeof(buf));
528 g_strlcat(buf, ")", sizeof(buf));
529 #endif
531 screen_status_printf("%s", buf);
533 doupdate();
534 return TRUE;
535 }
536 #endif
538 int
539 main(int argc, const char *argv[])
540 {
541 struct sigaction act;
542 #ifdef ENABLE_LOCALE
543 const char *charset = NULL;
544 #endif
545 GIOChannel *keyboard_channel;
546 #ifdef ENABLE_LIRC
547 int lirc_socket;
548 GIOChannel *lirc_channel = NULL;
549 #endif
550 GIOChannel *sigwinch_channel = NULL;
552 #ifdef ENABLE_LOCALE
553 /* time and date formatting */
554 setlocale(LC_TIME,"");
555 /* care about sorting order etc */
556 setlocale(LC_COLLATE,"");
557 /* charset */
558 setlocale(LC_CTYPE,"");
559 /* initialize charset conversions */
560 charset = charset_init();
562 /* initialize i18n support */
563 #endif
565 #ifdef ENABLE_NLS
566 setlocale(LC_MESSAGES, "");
567 bindtextdomain(GETTEXT_PACKAGE, LOCALE_DIR);
568 #ifdef ENABLE_LOCALE
569 bind_textdomain_codeset(GETTEXT_PACKAGE, charset);
570 #endif
571 textdomain(GETTEXT_PACKAGE);
572 #endif
574 /* initialize options */
575 options_init();
577 /* parse command line options - 1 pass get configuration files */
578 options_parse(argc, argv);
580 #ifndef NCMPC_MINI
581 /* read configuration */
582 read_configuration();
584 /* check key bindings */
585 check_key_bindings(NULL, NULL, 0);
586 #endif
588 /* parse command line options - 2 pass */
589 options_parse(argc, argv);
591 /* setup signal behavior - SIGINT */
592 sigemptyset(&act.sa_mask);
593 act.sa_flags = 0;
594 act.sa_handler = catch_sigint;
595 if (sigaction(SIGINT, &act, NULL) < 0) {
596 perror("signal");
597 exit(EXIT_FAILURE);
598 }
600 /* setup signal behavior - SIGTERM */
602 act.sa_handler = catch_sigint;
603 if (sigaction(SIGTERM, &act, NULL) < 0) {
604 perror("sigaction()");
605 exit(EXIT_FAILURE);
606 }
608 /* setup signal behavior - SIGCONT */
610 act.sa_handler = catch_sigcont;
611 if (sigaction(SIGCONT, &act, NULL) < 0) {
612 perror("sigaction(SIGCONT)");
613 exit(EXIT_FAILURE);
614 }
616 /* setup signal behaviour - SIGHUP*/
618 act.sa_handler = catch_sigint;
619 if (sigaction(SIGHUP, &act, NULL) < 0) {
620 perror("sigaction(SIGHUP)");
621 exit(EXIT_FAILURE);
622 }
624 /* setup SIGWINCH */
626 act.sa_flags = SA_RESTART;
627 act.sa_handler = catch_sigwinch;
628 if (sigaction(SIGWINCH, &act, NULL) < 0) {
629 perror("sigaction(SIGWINCH)");
630 exit(EXIT_FAILURE);
631 }
633 /* ignore SIGPIPE */
635 act.sa_handler = SIG_IGN;
636 if (sigaction(SIGPIPE, &act, NULL) < 0) {
637 perror("sigaction(SIGPIPE)");
638 exit(EXIT_FAILURE);
639 }
641 ncu_init();
643 #ifdef ENABLE_LYRICS_SCREEN
644 lyrics_init();
645 #endif
647 /* create mpdclient instance */
648 mpd = mpdclient_new();
650 /* initialize curses */
651 screen_init(mpd);
653 /* the main loop */
654 main_loop = g_main_loop_new(NULL, FALSE);
656 /* watch out for keyboard input */
657 keyboard_channel = g_io_channel_unix_new(STDIN_FILENO);
658 g_io_add_watch(keyboard_channel, G_IO_IN, keyboard_event, NULL);
660 #ifdef ENABLE_LIRC
661 /* watch out for lirc input */
662 lirc_socket = ncmpc_lirc_open();
663 if (lirc_socket >= 0) {
664 lirc_channel = g_io_channel_unix_new(lirc_socket);
665 g_io_add_watch(lirc_channel, G_IO_IN, lirc_event, NULL);
666 }
667 #endif
669 if (!pipe(sigwinch_pipes) &&
670 !fcntl(sigwinch_pipes[1], F_SETFL, O_NONBLOCK)) {
671 sigwinch_channel = g_io_channel_unix_new(sigwinch_pipes[0]);
672 g_io_add_watch(sigwinch_channel, G_IO_IN, sigwinch_event, NULL);
673 }
674 else {
675 perror("sigwinch pipe creation failed");
676 exit(EXIT_FAILURE);
677 }
679 /* attempt to connect */
680 reconnect_source_id = g_timeout_add(1, timer_reconnect, NULL);
682 auto_update_timer();
684 #ifndef NCMPC_MINI
685 check_key_bindings_source_id = g_timeout_add(10000, timer_check_key_bindings, NULL);
686 #endif
688 screen_paint(mpd);
690 g_main_loop_run(main_loop);
692 /* cleanup */
694 cancel_seek_timer();
696 disable_update_timer();
698 if (reconnect_source_id != 0)
699 g_source_remove(reconnect_source_id);
701 #ifndef NCMPC_MINI
702 if (check_key_bindings_source_id != 0)
703 g_source_remove(check_key_bindings_source_id);
704 #endif
706 g_main_loop_unref(main_loop);
707 g_io_channel_unref(keyboard_channel);
708 g_io_channel_unref(sigwinch_channel);
709 close(sigwinch_pipes[0]);
710 close(sigwinch_pipes[1]);
712 #ifdef ENABLE_LIRC
713 if (lirc_socket >= 0)
714 g_io_channel_unref(lirc_channel);
715 ncmpc_lirc_close();
716 #endif
718 exit_and_cleanup();
720 #ifdef ENABLE_LYRICS_SCREEN
721 lyrics_deinit();
722 #endif
724 ncu_deinit();
725 options_deinit();
727 return 0;
728 }