/* * dwmstatus.c: simple PulseAudio-enabled dwmstatus * * Copyright (c) 2015 - 2016, Přemysl Janouch * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * */ #define LIBERTY_WANT_POLLER #define LIBERTY_WANT_ASYNC #define LIBERTY_WANT_PROTO_MPD #define _GNU_SOURCE // openat #include "config.h" #undef PROGRAM_NAME #define PROGRAM_NAME "dwmstatus" #include "liberty/liberty.c" #include #include #include #include #include #include #include #include #include #include #include // --- Utilities --------------------------------------------------------------- static void log_message_custom (void *user_data, const char *quote, const char *fmt, va_list ap) { (void) user_data; FILE *stream = stdout; fprintf (stream, PROGRAM_NAME ": "); fputs (quote, stream); vfprintf (stream, fmt, ap); fputs ("\n", stream); } static void set_dwm_status (Display *dpy, const char *str) { print_debug ("setting status to: %s", str); XStoreName (dpy, DefaultRootWindow (dpy), str); XSync (dpy, False); } // --- PulseAudio mainloop abstraction ----------------------------------------- struct pa_io_event { LIST_HEADER (pa_io_event) pa_mainloop_api *api; ///< Parent structure struct poller_fd fd; ///< Underlying FD event pa_io_event_cb_t dispatch; ///< Dispatcher pa_io_event_destroy_cb_t free; ///< Destroyer void *user_data; ///< User data }; struct pa_time_event { LIST_HEADER (pa_time_event) pa_mainloop_api *api; ///< Parent structure struct poller_timer timer; ///< Underlying timer event pa_time_event_cb_t dispatch; ///< Dispatcher pa_time_event_destroy_cb_t free; ///< Destroyer void *user_data; ///< User data }; struct pa_defer_event { LIST_HEADER (pa_defer_event) pa_mainloop_api *api; ///< Parent structure struct poller_idle idle; ///< Underlying idle event pa_defer_event_cb_t dispatch; ///< Dispatcher pa_defer_event_destroy_cb_t free; ///< Destroyer void *user_data; ///< User data }; struct poller_pa { struct poller *poller; ///< The underlying event loop int result; ///< Result on quit bool running; ///< Not quitting pa_io_event *io_list; ///< I/O events pa_time_event *time_list; ///< Timer events pa_defer_event *defer_list; ///< Deferred events }; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static short poller_pa_flags_to_events (pa_io_event_flags_t flags) { short result = 0; if (flags & PA_IO_EVENT_ERROR) result |= POLLERR; if (flags & PA_IO_EVENT_HANGUP) result |= POLLHUP; if (flags & PA_IO_EVENT_INPUT) result |= POLLIN; if (flags & PA_IO_EVENT_OUTPUT) result |= POLLOUT; return result; } static pa_io_event_flags_t poller_pa_events_to_flags (short events) { pa_io_event_flags_t result = 0; if (events & POLLERR) result |= PA_IO_EVENT_ERROR; if (events & POLLHUP) result |= PA_IO_EVENT_HANGUP; if (events & POLLIN) result |= PA_IO_EVENT_INPUT; if (events & POLLOUT) result |= PA_IO_EVENT_OUTPUT; return result; } static struct timeval poller_pa_get_current_time (void) { struct timeval tv; #ifdef _POSIX_TIMERS struct timespec tp; hard_assert (clock_gettime (CLOCK_REALTIME, &tp) != -1); tv.tv_sec = tp.tv_sec; tv.tv_usec = tp.tv_nsec / 1000; #else gettimeofday (&tv, NULL); #endif return tv; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void poller_pa_io_dispatcher (const struct pollfd *pfd, void *user_data) { pa_io_event *self = user_data; self->dispatch (self->api, self, pfd->fd, poller_pa_events_to_flags (pfd->revents), self->user_data); } static void poller_pa_io_enable (pa_io_event *self, pa_io_event_flags_t events) { struct poller_fd *fd = &self->fd; if (events) poller_fd_set (fd, poller_pa_flags_to_events (events)); else poller_fd_reset (fd); } static pa_io_event * poller_pa_io_new (pa_mainloop_api *api, int fd_, pa_io_event_flags_t events, pa_io_event_cb_t cb, void *userdata) { pa_io_event *self = xcalloc (1, sizeof *self); self->api = api; self->dispatch = cb; self->user_data = userdata; struct poller_pa *data = api->userdata; struct poller_fd *fd = &self->fd; poller_fd_init (fd, data->poller, fd_); fd->user_data = self; fd->dispatcher = poller_pa_io_dispatcher; // FIXME: under x2go PA tries to register twice for the same FD, // which fails with our curent poller implementation; // we could maintain a list of { poller_fd, listeners } structures; // or maybe we're doing something wrong, which is yet to be determined poller_pa_io_enable (self, events); LIST_PREPEND (data->io_list, self); return self; } static void poller_pa_io_free (pa_io_event *self) { if (self->free) self->free (self->api, self, self->user_data); struct poller_pa *data = self->api->userdata; poller_fd_reset (&self->fd); LIST_UNLINK (data->io_list, self); free (self); } static void poller_pa_io_set_destroy (pa_io_event *self, pa_io_event_destroy_cb_t cb) { self->free = cb; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void poller_pa_time_dispatcher (void *user_data) { pa_time_event *self = user_data; // XXX: the meaning of the time argument is undocumented, // so let's just put current Unix time in there struct timeval now = poller_pa_get_current_time (); self->dispatch (self->api, self, &now, self->user_data); } static void poller_pa_time_restart (pa_time_event *self, const struct timeval *tv) { struct poller_timer *timer = &self->timer; if (tv) { struct timeval now = poller_pa_get_current_time (); poller_timer_set (timer, (tv->tv_sec - now.tv_sec) * 1000 + (tv->tv_usec - now.tv_usec) / 1000); } else poller_timer_reset (timer); } static pa_time_event * poller_pa_time_new (pa_mainloop_api *api, const struct timeval *tv, pa_time_event_cb_t cb, void *userdata) { pa_time_event *self = xcalloc (1, sizeof *self); self->api = api; self->dispatch = cb; self->user_data = userdata; struct poller_pa *data = api->userdata; struct poller_timer *timer = &self->timer; poller_timer_init (timer, data->poller); timer->user_data = self; timer->dispatcher = poller_pa_time_dispatcher; poller_pa_time_restart (self, tv); LIST_PREPEND (data->time_list, self); return self; } static void poller_pa_time_free (pa_time_event *self) { if (self->free) self->free (self->api, self, self->user_data); struct poller_pa *data = self->api->userdata; poller_timer_reset (&self->timer); LIST_UNLINK (data->time_list, self); free (self); } static void poller_pa_time_set_destroy (pa_time_event *self, pa_time_event_destroy_cb_t cb) { self->free = cb; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void poller_pa_defer_dispatcher (void *user_data) { pa_defer_event *self = user_data; self->dispatch (self->api, self, self->user_data); } static pa_defer_event * poller_pa_defer_new (pa_mainloop_api *api, pa_defer_event_cb_t cb, void *userdata) { pa_defer_event *self = xcalloc (1, sizeof *self); self->api = api; self->dispatch = cb; self->user_data = userdata; struct poller_pa *data = api->userdata; struct poller_idle *idle = &self->idle; poller_idle_init (idle, data->poller); idle->user_data = self; idle->dispatcher = poller_pa_defer_dispatcher; poller_idle_set (idle); LIST_PREPEND (data->defer_list, self); return self; } static void poller_pa_defer_enable (pa_defer_event *self, int enable) { struct poller_idle *idle = &self->idle; if (enable) poller_idle_set (idle); else poller_idle_reset (idle); } static void poller_pa_defer_free (pa_defer_event *self) { if (self->free) self->free (self->api, self, self->user_data); struct poller_pa *data = self->api->userdata; poller_idle_reset (&self->idle); LIST_UNLINK (data->defer_list, self); free (self); } static void poller_pa_defer_set_destroy (pa_defer_event *self, pa_defer_event_destroy_cb_t cb) { self->free = cb; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void poller_pa_quit (pa_mainloop_api *api, int retval) { struct poller_pa *data = api->userdata; data->result = retval; data->running = false; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static struct pa_mainloop_api g_poller_pa_template = { .io_new = poller_pa_io_new, .io_enable = poller_pa_io_enable, .io_free = poller_pa_io_free, .io_set_destroy = poller_pa_io_set_destroy, .time_new = poller_pa_time_new, .time_restart = poller_pa_time_restart, .time_free = poller_pa_time_free, .time_set_destroy = poller_pa_time_set_destroy, .defer_new = poller_pa_defer_new, .defer_enable = poller_pa_defer_enable, .defer_free = poller_pa_defer_free, .defer_set_destroy = poller_pa_defer_set_destroy, .quit = poller_pa_quit, }; static struct pa_mainloop_api * poller_pa_new (struct poller *self) { struct poller_pa *data = xcalloc (1, sizeof *data); data->poller = self; struct pa_mainloop_api *api = xmalloc (sizeof *api); *api = g_poller_pa_template; api->userdata = data; return api; } static void poller_pa_destroy (struct pa_mainloop_api *api) { struct poller_pa *data = api->userdata; LIST_FOR_EACH (pa_io_event, iter, data->io_list) poller_pa_io_free (iter); LIST_FOR_EACH (pa_time_event, iter, data->time_list) poller_pa_time_free (iter); LIST_FOR_EACH (pa_defer_event, iter, data->defer_list) poller_pa_defer_free (iter); free (data); free (api); } /// Since our poller API doesn't care much about continuous operation, /// we need to provide that in the PulseAudio abstraction itself static int poller_pa_run (struct pa_mainloop_api *api) { struct poller_pa *data = api->userdata; data->running = true; while (data->running) poller_run (data->poller); return data->result; } // --- NUT --------------------------------------------------------------------- // More or less copied and pasted from the MPD client. This code doesn't even // deserve much love, the protocol is somehow even worse than MPD's. // // http://www.networkupstools.org/docs/developer-guide.chunked/ar01s09.html // This was written by loosely following the top comment in NUT's parseconf.c. enum nut_parser_state { NUT_STATE_START_LINE, ///< Start of a line NUT_STATE_BETWEEN, ///< Between words, expecting non-WS NUT_STATE_UNQUOTED, ///< Within unquoted word NUT_STATE_UNQUOTED_ESCAPE, ///< Dtto after a backslash NUT_STATE_QUOTED, ///< Within a quoted word NUT_STATE_QUOTED_ESCAPE, ///< Dtto after a backslash NUT_STATE_QUOTED_END ///< End of word, expecting WS }; struct nut_parser { enum nut_parser_state state; ///< Parser state struct str current_field; ///< Current field // Public: struct str_vector fields; ///< Line fields }; static void nut_parser_init (struct nut_parser *self) { self->state = NUT_STATE_START_LINE; str_init (&self->current_field); str_vector_init (&self->fields); } static void nut_parser_free (struct nut_parser *self) { str_free (&self->current_field); str_vector_free (&self->fields); } static int nut_parser_end_field (struct nut_parser *self, char c) { str_vector_add (&self->fields, self->current_field.str); str_reset (&self->current_field); if (c == '\n') { self->state = NUT_STATE_START_LINE; return 1; } self->state = NUT_STATE_BETWEEN; return 0; } /// Returns 1 if a complete line has been read, -1 on error, 0 otherwise static int nut_parser_push (struct nut_parser *self, char c) { switch (self->state) { case NUT_STATE_START_LINE: str_vector_reset (&self->fields); str_reset (&self->current_field); self->state = NUT_STATE_BETWEEN; // Fall-through case NUT_STATE_BETWEEN: if (c == '\\') self->state = NUT_STATE_UNQUOTED_ESCAPE; else if (c == '"') self->state = NUT_STATE_QUOTED; else if (c == '\n' && self->fields.len) { self->state = NUT_STATE_START_LINE; return 1; } else if (!isspace_ascii (c)) { str_append_c (&self->current_field, c); self->state = NUT_STATE_UNQUOTED; } return 0; case NUT_STATE_UNQUOTED: if (c == '\\') self->state = NUT_STATE_UNQUOTED_ESCAPE; else if (c == '"') return -1; else if (!isspace_ascii (c)) str_append_c (&self->current_field, c); else return nut_parser_end_field (self, c); return 0; case NUT_STATE_UNQUOTED_ESCAPE: str_append_c (&self->current_field, c); self->state = NUT_STATE_UNQUOTED; return 0; case NUT_STATE_QUOTED: if (c == '\\') self->state = NUT_STATE_QUOTED_ESCAPE; else if (c == '"') self->state = NUT_STATE_QUOTED_END; else str_append_c (&self->current_field, c); return 0; case NUT_STATE_QUOTED_ESCAPE: str_append_c (&self->current_field, c); self->state = NUT_STATE_QUOTED; return 0; case NUT_STATE_QUOTED_END: if (!isspace_ascii (c)) return -1; return nut_parser_end_field (self, c); } // Silence the compiler hard_assert (!"unhandled NUT parser state"); return -1; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - struct nut_line { LIST_HEADER (struct nut_line) struct str_vector fields; ///< Parsed fields from the line }; struct nut_response { struct nut_line *data; ///< Raw result data bool success; ///< Whether a general failure occured char *message; ///< Eventually an error ID string }; /// Task completion callback typedef void (*nut_client_task_cb) (const struct nut_response *response, void *user_data); struct nut_client_task { LIST_HEADER (struct nut_client_task) nut_client_task_cb callback; ///< Callback on completion void *user_data; ///< User data }; enum nut_client_state { NUT_DISCONNECTED, ///< Not connected NUT_CONNECTING, ///< Currently connecting NUT_CONNECTED ///< Connected }; struct nut_client { struct poller *poller; ///< Poller // Connection: enum nut_client_state state; ///< Connection state struct connector *connector; ///< Connection establisher int socket; ///< MPD socket struct str read_buffer; ///< Input yet to be processed struct str write_buffer; ///< Outut yet to be be sent out struct poller_fd socket_event; ///< We can read from the socket // Protocol: struct nut_parser parser; ///< Protocol parser struct nut_line *data; ///< Data from last command struct nut_line *data_tail; ///< Tail of data list bool in_list; ///< Currently within a list struct nut_client_task *tasks; ///< Task queue struct nut_client_task *tasks_tail; ///< Tail of task queue // User configuration: void *user_data; ///< User data for callbacks /// Callback after connection has been successfully established void (*on_connected) (void *user_data); /// Callback for general failures or even normal disconnection; /// the interface is reinitialized void (*on_failure) (void *user_data); }; static void nut_client_reset (struct nut_client *self); static void nut_client_destroy_connector (struct nut_client *self); static void nut_client_init (struct nut_client *self, struct poller *poller) { memset (self, 0, sizeof *self); self->poller = poller; self->socket = -1; str_init (&self->read_buffer); str_init (&self->write_buffer); nut_parser_init (&self->parser); poller_fd_init (&self->socket_event, poller, -1); } static void nut_client_free (struct nut_client *self) { // So that we don't have to repeat most of the stuff nut_client_reset (self); str_free (&self->read_buffer); str_free (&self->write_buffer); nut_parser_free (&self->parser); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void nut_client_flush_data (struct nut_client *self) { LIST_FOR_EACH (struct nut_line, iter, self->data) { str_vector_free (&iter->fields); free (iter); } self->data = self->data_tail = NULL; } /// Reinitialize the interface so that you can reconnect anew static void nut_client_reset (struct nut_client *self) { if (self->state == NUT_CONNECTING) nut_client_destroy_connector (self); if (self->socket != -1) xclose (self->socket); self->socket = -1; self->socket_event.closed = true; poller_fd_reset (&self->socket_event); str_reset (&self->read_buffer); str_reset (&self->write_buffer); self->parser.state = NUT_STATE_START_LINE; nut_client_flush_data (self); self->in_list = false; LIST_FOR_EACH (struct nut_client_task, iter, self->tasks) free (iter); self->tasks = self->tasks_tail = NULL; self->state = NUT_DISCONNECTED; } static void nut_client_fail (struct nut_client *self) { nut_client_reset (self); if (self->on_failure) self->on_failure (self->user_data); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void nut_client_quote (const char *s, struct str *output) { str_append_c (output, '"'); for (; *s; s++) { if (*s == '"' || *s == '\\') str_append_c (output, '\\'); str_append_c (output, *s); } str_append_c (output, '"'); } static bool nut_client_must_quote (const char *s) { if (!*s) return true; for (; *s; s++) if ((unsigned char) *s <= ' ' || *s == '"' || *s == '\\') return true; return false; } static void nut_client_serialize (char **commands, struct str *line) { for (; *commands; commands++) { if (line->len) str_append_c (line, ' '); if (nut_client_must_quote (*commands)) nut_client_quote (*commands, line); else str_append (line, *commands); } } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void nut_client_dispatch (struct nut_client *self, struct nut_response *response) { struct nut_client_task *task; if (!(task = self->tasks)) return; if (task->callback) task->callback (response, task->user_data); nut_client_flush_data (self); LIST_UNLINK_WITH_TAIL (self->tasks, self->tasks_tail, task); free (task); } static bool nut_client_parse_line (struct nut_client *self) { struct str reconstructed; str_init (&reconstructed); nut_client_serialize (self->parser.fields.vector, &reconstructed); print_debug ("NUT >> %s", reconstructed.str); str_free (&reconstructed); struct str_vector *fields = &self->parser.fields; hard_assert (fields->len != 0); // Lists are always dispatched as their innards (and they can be empty) if (fields->len >= 2 && !strcmp (fields->vector[0], "BEGIN") && !strcmp (fields->vector[1], "LIST")) self->in_list = true; else if (fields->len >= 2 && !strcmp (fields->vector[0], "END") && !strcmp (fields->vector[1], "LIST")) self->in_list = false; else { struct nut_line *line = xcalloc (1, sizeof *line); str_vector_init (&line->fields); str_vector_add_vector (&line->fields, fields->vector); LIST_APPEND_WITH_TAIL (self->data, self->data_tail, line); } if (!self->in_list) { struct nut_response response; memset (&response, 0, sizeof response); response.success = true; response.data = self->data; if (!strcmp (fields->vector[0], "ERR")) { response.success = false; if (fields->len < 2) return false; response.message = xstrdup (fields->vector[1]); } nut_client_dispatch (self, &response); free (response.message); } return true; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void nut_client_update_poller (struct nut_client *self) { poller_fd_set (&self->socket_event, self->write_buffer.len ? (POLLIN | POLLOUT) : POLLIN); } static bool nut_client_process_input (struct nut_client *self) { struct str *rb = &self->read_buffer; for (size_t i = 0; i < rb->len; i++) { int res = nut_parser_push (&self->parser, rb->str[i]); if (res == -1 || (res == 1 && !nut_client_parse_line (self))) return false; } str_reset (rb); return true; } static void nut_client_on_ready (const struct pollfd *pfd, void *user_data) { (void) pfd; struct nut_client *self = user_data; bool read_succeeded = socket_io_try_read (self->socket, &self->read_buffer) == SOCKET_IO_OK; // Whether or not the read was successful, we need to process all data if (!nut_client_process_input (self) || !read_succeeded || socket_io_try_write (self->socket, &self->write_buffer) != SOCKET_IO_OK) nut_client_fail (self); else nut_client_update_poller (self); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - /// Beware that delivery of the event isn't deferred and you musn't make /// changes to the interface while processing the event! static void nut_client_add_task (struct nut_client *self, nut_client_task_cb cb, void *user_data) { struct nut_client_task *task = xcalloc (1, sizeof *self); task->callback = cb; task->user_data = user_data; LIST_APPEND_WITH_TAIL (self->tasks, self->tasks_tail, task); } /// Send a command. Remember to call nut_client_add_task() to handle responses, /// unless the command generates none. static void nut_client_send_command (struct nut_client *self, const char *command, ...) ATTRIBUTE_SENTINEL; static void nut_client_send_commandv (struct nut_client *self, char **commands) { struct str line; str_init (&line); nut_client_serialize (commands, &line); print_debug ("NUT << %s", line.str); str_append_c (&line, '\n'); str_append_str (&self->write_buffer, &line); str_free (&line); nut_client_update_poller (self); } static void nut_client_send_command (struct nut_client *self, const char *command, ...) { struct str_vector v; str_vector_init (&v); va_list ap; va_start (ap, command); for (; command; command = va_arg (ap, const char *)) str_vector_add (&v, command); va_end (ap); nut_client_send_commandv (self, v.vector); str_vector_free (&v); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void nut_client_finish_connection (struct nut_client *self, int socket) { set_blocking (socket, false); self->socket = socket; self->state = NUT_CONNECTED; poller_fd_init (&self->socket_event, self->poller, self->socket); self->socket_event.dispatcher = nut_client_on_ready; self->socket_event.user_data = self; nut_client_update_poller (self); if (self->on_connected) self->on_connected (self->user_data); } static void nut_client_destroy_connector (struct nut_client *self) { if (self->connector) connector_free (self->connector); free (self->connector); self->connector = NULL; // Not connecting anymore self->state = NUT_DISCONNECTED; } static void nut_client_on_connector_failure (void *user_data) { struct nut_client *self = user_data; nut_client_destroy_connector (self); nut_client_fail (self); } static void nut_client_on_connector_connected (void *user_data, int socket, const char *host) { (void) host; struct nut_client *self = user_data; nut_client_destroy_connector (self); nut_client_finish_connection (self, socket); } static void nut_client_connect (struct nut_client *self, const char *address, const char *service) { hard_assert (self->state == NUT_DISCONNECTED); struct connector *connector = xmalloc (sizeof *connector); connector_init (connector, self->poller); self->connector = connector; connector->user_data = self; connector->on_connected = nut_client_on_connector_connected; connector->on_failure = nut_client_on_connector_failure; connector_add_target (connector, address, service); self->state = NUT_CONNECTING; } // --- Configuration ----------------------------------------------------------- static struct simple_config_item g_config_table[] = { { "mpd_address", "localhost", "MPD host or socket" }, { "mpd_service", "6600", "MPD service name or port" }, { "mpd_password", NULL, "MPD password" }, { "nut_enabled", "off", "NUT UPS status reading enabled" }, { "nut_load_thld", "50", "NUT threshold for load display" }, // This is just a hack because my UPS doesn't report that value; a more // proper way of providing this information would be by making use of the // enhanced configuration format and allowing arbitrary per-UPS overrides { "nut_load_power", NULL, "ups.realpower.nominal override" }, { NULL, NULL, NULL } }; // --- Application ------------------------------------------------------------- struct app_context { struct str_map config; ///< Program configuration Display *dpy; ///< X display handle int xkb_base_event_code; ///< Xkb base event code const char *prefix; ///< User-defined prefix struct poller poller; ///< Poller struct poller_timer time_changed; ///< Time change timer struct poller_timer make_context; ///< Start PulseAudio communication struct poller_timer refresh_rest; ///< Refresh unpollable information // Hotkeys: struct poller_fd x_event; ///< X11 event char *layout; ///< Keyboard layout // MPD: struct poller_timer mpd_reconnect; ///< Start MPD communication struct mpd_client mpd_client; ///< MPD client char *mpd_song; ///< MPD current song char *mpd_status; ///< MPD status (overrides song) // NUT: struct poller_timer nut_reconnect; ///< Start NUT communication struct nut_client nut_client; ///< NUT client struct str_map nut_ups_info; ///< Per-UPS information bool nut_success; ///< Information retrieved successfully char *nut_status; ///< NUT status // PulseAudio: pa_mainloop_api *api; ///< PulseAudio event loop proxy pa_context *context; ///< PulseAudio connection context bool failed; ///< General PulseAudio failure pa_cvolume sink_volume; ///< Current volume bool sink_muted; ///< Currently muted? struct str_vector sink_ports; ///< All sink port names char *sink_port_active; ///< Active sink port bool source_muted; ///< Currently muted? }; static void str_map_destroy (void *self) { str_map_free (self); free (self); } static void app_context_init (struct app_context *self) { memset (self, 0, sizeof *self); str_map_init (&self->config); self->config.free = free; simple_config_load_defaults (&self->config, g_config_table); if (!(self->dpy = XkbOpenDisplay (NULL, &self->xkb_base_event_code, NULL, NULL, NULL, NULL))) exit_fatal ("cannot open display"); poller_init (&self->poller); self->api = poller_pa_new (&self->poller); poller_fd_init (&self->x_event, &self->poller, ConnectionNumber (self->dpy)); mpd_client_init (&self->mpd_client, &self->poller); nut_client_init (&self->nut_client, &self->poller); str_map_init (&self->nut_ups_info); self->nut_ups_info.free = str_map_destroy; str_vector_init (&self->sink_ports); } static void app_context_free (struct app_context *self) { str_map_free (&self->config); poller_fd_reset (&self->x_event); free (self->layout); if (self->context) pa_context_unref (self->context); if (self->dpy) XCloseDisplay (self->dpy); poller_pa_destroy (self->api); poller_free (&self->poller); mpd_client_free (&self->mpd_client); free (self->mpd_song); free (self->mpd_status); nut_client_free (&self->nut_client); str_map_free (&self->nut_ups_info); str_vector_free (&self->sink_ports); free (self->sink_port_active); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static char * read_value (int dir, const char *filename, struct error **e) { int fd = openat (dir, filename, O_RDONLY); if (fd < 0) { error_set (e, "%s: %s: %s", filename, "openat", strerror (errno)); return NULL; } FILE *fp = fdopen (fd, "r"); if (!fp) { error_set (e, "%s: %s: %s", filename, "fdopen", strerror (errno)); close (fd); return NULL; } struct str s; str_init (&s); bool success = read_line (fp, &s); fclose (fp); if (!success) { error_set (e, "%s: %s", filename, "read failed"); return NULL; } return str_steal (&s); } static unsigned long read_number (int dir, const char *filename, struct error **e) { char *value; if (!(value = read_value (dir, filename, e))) return false; unsigned long number = 0; if (!xstrtoul (&number, value, 10)) error_set (e, "%s: %s", filename, "doesn't contain an unsigned number"); free (value); return number; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static char * read_battery_status (int dir, struct error **e) { char *result = NULL; struct error *error = NULL; char *status; double charge_now; double charge_full; if ((status = read_value (dir, "status", &error), error) || (charge_now = read_number (dir, "charge_now", &error), error) || (charge_full = read_number (dir, "charge_full", &error), error)) error_propagate (e, error); else result = xstrdup_printf ("%s (%u%%)", status, (unsigned) (charge_now / charge_full * 100 + 0.5)); free (status); return result; } static char * try_power_supply (int dir, struct error **e) { char *type; struct error *error = NULL; if (!(type = read_value (dir, "type", &error))) { error_propagate (e, error); return NULL; } bool is_relevant = !strcmp (type, "Battery") || !strcmp (type, "UPS"); char *result = NULL; if (is_relevant) { char *status = read_battery_status (dir, &error); if (error) error_propagate (e, error); if (status) result = xstrdup_printf ("%s %s", type, status); free (status); } free (type); return result; } static char * make_battery_status (void) { DIR *power_supply = opendir ("/sys/class/power_supply"); if (!power_supply) { print_debug ("cannot access %s: %s: %s", "/sys/class/power_supply", "opendir", strerror (errno)); return NULL; } struct dirent *entry; char *status = NULL; while (!status && (entry = readdir (power_supply))) { const char *device_name = entry->d_name; if (device_name[0] == '.') continue; int dir = openat (dirfd (power_supply), device_name, O_RDONLY); if (dir < 0) { print_error ("%s: %s: %s", device_name, "openat", strerror (errno)); continue; } struct error *error = NULL; status = try_power_supply (dir, &error); close (dir); if (error) { print_error ("%s: %s", device_name, error->message); error_free (error); } } closedir (power_supply); return status; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static char * make_time_status (char *fmt) { char buf[129] = ""; time_t now = time (NULL); struct tm *local = localtime (&now); if (local == NULL) exit_fatal ("%s: %s", "localtime", strerror (errno)); if (!strftime (buf, sizeof buf, fmt, local)) exit_fatal ("strftime == 0"); return xstrdup (buf); } #define VOLUME_PERCENT(x) (((x) * 100 + PA_VOLUME_NORM / 2) / PA_VOLUME_NORM) static char * make_volume_status (struct app_context *ctx) { if (!ctx->sink_volume.channels) return xstrdup (""); struct str s; str_init (&s); str_append_printf (&s, "%u%%", VOLUME_PERCENT (ctx->sink_volume.values[0])); if (!pa_cvolume_channels_equal_to (&ctx->sink_volume, ctx->sink_volume.values[0])) for (size_t i = 1; i < ctx->sink_volume.channels; i++) str_append_printf (&s, " / %u%%", VOLUME_PERCENT (ctx->sink_volume.values[i])); return str_steal (&s); } static void refresh_status (struct app_context *ctx) { struct str status; str_init (&status); if (ctx->prefix) str_append_printf (&status, "%s ", ctx->prefix); if (ctx->mpd_status) str_append_printf (&status, "%s ", ctx->mpd_status); else if (ctx->mpd_song) str_append_printf (&status, "%s ", ctx->mpd_song); if (ctx->failed) str_append_printf (&status, "%s ", "PA failure"); else { char *volumes = make_volume_status (ctx); str_append_printf (&status, "%s%s ", ctx->sink_muted ? "Muted " : "", volumes); free (volumes); } char *battery = make_battery_status (); if (battery) str_append_printf (&status, "%s ", battery); free (battery); if (ctx->nut_status) str_append_printf (&status, "%s ", ctx->nut_status); if (ctx->layout) str_append_printf (&status, "%s ", ctx->layout); char *times = make_time_status ("Week %V, %a %d %b %Y %H:%M %Z"); str_append (&status, times); free (times); set_dwm_status (ctx->dpy, status.str); str_free (&status); } static void on_time_changed (void *user_data) { struct app_context *ctx = user_data; refresh_status (ctx); const time_t now = time (NULL); const time_t next = (now / 60 + 1) * 60; poller_timer_set (&ctx->time_changed, (next - now) * 1000); } static void on_refresh_rest (void *user_data) { struct app_context *ctx = user_data; // We cannot use poll() on most sysfs entries, including battery charge refresh_status (ctx); poller_timer_set (&ctx->refresh_rest, 5000); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // Sometimes it's not that easy and there can be repeating entries static void mpd_vector_to_map (const struct str_vector *data, struct str_map *map) { str_map_init (map); map->key_xfrm = tolower_ascii_strxfrm; map->free = free; char *key, *value; for (size_t i = 0; i < data->len; i++) { if ((key = mpd_client_parse_kv (data->vector[i], &value))) str_map_set (map, key, xstrdup (value)); else print_debug ("%s: %s", "erroneous MPD output", data->vector[i]); } } static void mpd_on_info_response (const struct mpd_response *response, const struct str_vector *data, void *user_data) { if (!response->success) { print_debug ("%s: %s", "retrieving MPD info failed", response->message_text); return; } struct app_context *ctx = user_data; struct str_map map; mpd_vector_to_map (data, &map); free (ctx->mpd_status); ctx->mpd_status = NULL; struct str s; str_init (&s); const char *value; if ((value = str_map_find (&map, "state"))) { if (!strcmp (value, "stop")) ctx->mpd_status = xstrdup ("MPD stopped"); else if (!strcmp (value, "pause")) str_append (&s, "|| "); else str_append (&s, "|> "); } if ((value = str_map_find (&map, "title")) || (value = str_map_find (&map, "name")) || (value = str_map_find (&map, "file"))) str_append_printf (&s, "\"%s\"", value); if ((value = str_map_find (&map, "artist"))) str_append_printf (&s, " by \"%s\"", value); if ((value = str_map_find (&map, "album"))) str_append_printf (&s, " from \"%s\"", value); free (ctx->mpd_song); ctx->mpd_song = str_steal (&s); refresh_status (ctx); str_map_free (&map); } static void mpd_request_info (struct app_context *ctx) { struct mpd_client *c = &ctx->mpd_client; mpd_client_list_begin (c); mpd_client_send_command (c, "currentsong", NULL); mpd_client_send_command (c, "status", NULL); mpd_client_list_end (c); mpd_client_add_task (c, mpd_on_info_response, ctx); mpd_client_idle (c, 0); } static void mpd_on_events (unsigned subsystems, void *user_data) { struct app_context *ctx = user_data; struct mpd_client *c = &ctx->mpd_client; if (subsystems & (MPD_SUBSYSTEM_PLAYER | MPD_SUBSYSTEM_PLAYLIST)) mpd_request_info (ctx); else mpd_client_idle (c, 0); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void mpd_queue_reconnect (struct app_context *ctx) { poller_timer_set (&ctx->mpd_reconnect, 30 * 1000); } static void mpd_on_password_response (const struct mpd_response *response, const struct str_vector *data, void *user_data) { (void) data; struct app_context *ctx = user_data; struct mpd_client *c = &ctx->mpd_client; if (response->success) mpd_request_info (ctx); else { print_error ("%s: %s", "couldn't authenticate to MPD", response->message_text); mpd_client_send_command (c, "close", NULL); } } static void mpd_on_connected (void *user_data) { struct app_context *ctx = user_data; struct mpd_client *c = &ctx->mpd_client; const char *password = str_map_find (&ctx->config, "mpd_password"); if (password) { mpd_client_send_command (c, "password", password, NULL); mpd_client_add_task (c, mpd_on_password_response, ctx); } else mpd_request_info (ctx); } static void mpd_on_failure (void *user_data) { // This is also triggered both by a failed connect and a clean disconnect struct app_context *ctx = user_data; print_error ("connection to MPD failed"); mpd_queue_reconnect (ctx); } static void mpd_on_io_hook (void *user_data, bool outgoing, const char *line) { (void) user_data; if (outgoing) print_debug ("MPD << %s", line); else print_debug ("MPD >> %s", line); } static void on_mpd_reconnect (void *user_data) { struct app_context *ctx = user_data; struct mpd_client *c = &ctx->mpd_client; c->user_data = ctx; c->on_failure = mpd_on_failure; c->on_connected = mpd_on_connected; c->on_event = mpd_on_events; c->on_io_hook = mpd_on_io_hook; struct error *e = NULL; if (!mpd_client_connect (&ctx->mpd_client, str_map_find (&ctx->config, "mpd_address"), str_map_find (&ctx->config, "mpd_service"), &e)) { print_error ("%s: %s", "cannot connect to MPD", e->message); error_free (e); mpd_queue_reconnect (ctx); } } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static bool nut_common_handler (const struct nut_response *response) { if (response->success) return true; print_error ("%s: %s", "retrieving NUT info failed", response->message); return false; } static void nut_translate_status (const char *status, struct str_vector *out) { // https://github.com/networkupstools/nut/blob/master/clients/status.h if (!strcmp (status, "OL")) str_vector_add (out, "on-line"); if (!strcmp (status, "OB")) str_vector_add (out, "on battery"); if (!strcmp (status, "LB")) str_vector_add (out, "low battery"); if (!strcmp (status, "RB")) str_vector_add (out, "replace battery"); if (!strcmp (status, "CHRG")) str_vector_add (out, "charging"); if (!strcmp (status, "DISCHRG")) str_vector_add (out, "discharging"); if (!strcmp (status, "OVER")) str_vector_add (out, "overload"); if (!strcmp (status, "OFF")) str_vector_add (out, "off"); if (!strcmp (status, "TRIM")) str_vector_add (out, "voltage trim"); if (!strcmp (status, "BOOST")) str_vector_add (out, "voltage boost"); if (!strcmp (status, "BYPASS")) str_vector_add (out, "bypass"); } static char * interval_string (unsigned long seconds) { unsigned long hours = seconds / 3600; seconds %= 3600; unsigned long mins = seconds / 60; seconds %= 60; return xstrdup_printf ("%lu:%02lu:%02lu", hours, mins, seconds); } static void nut_process_ups (struct app_context *ctx, struct str_vector *ups_list, const char *ups_name, struct str_map *dict) { // Not currently interested in this kind of information; // maybe if someone had more than one UPS installed (void) ups_name; // http://www.networkupstools.org/docs/developer-guide.chunked/apas01.html const char *status = str_map_find (dict, "ups.status"); const char *charge = str_map_find (dict, "battery.charge"); const char *runtime = str_map_find (dict, "battery.runtime"); const char *load = str_map_find (dict, "ups.load"); if (!soft_assert (status && charge && runtime)) return; unsigned long runtime_sec; if (!soft_assert (xstrtoul (&runtime_sec, runtime, 10))) return; struct str_vector items; str_vector_init (&items); bool running_on_batteries = false; struct str_vector v; str_vector_init (&v); cstr_split (status, " ", true, &v); for (size_t i = 0; i < v.len; i++) { const char *status = v.vector[i]; nut_translate_status (status, &items); if (!strcmp (status, "OB")) running_on_batteries = true; } str_vector_free (&v); if (running_on_batteries || strcmp (charge, "100")) str_vector_add_owned (&items, xstrdup_printf ("%s%%", charge)); if (running_on_batteries) str_vector_add_owned (&items, interval_string (runtime_sec)); // Only show load if it's higher than the threshold so as to not distract const char *threshold = str_map_find (&ctx->config, "nut_load_thld"); unsigned long load_n, threshold_n; if (load && xstrtoul (&load_n, load, 10) && xstrtoul (&threshold_n, threshold, 10) && load_n >= threshold_n) { struct str item; str_init (&item); str_append_printf (&item, "load %s%%", load); const char *power = str_map_find (dict, "ups.realpower.nominal"); // Override if NUT cannot tell it correctly for whatever reason if (!power) power = str_map_find (&ctx->config, "nut_load_power"); // Approximation of how much electricity the perpihery actually uses unsigned long power_n; if (power && xstrtoul (&power_n, power, 10)) str_append_printf (&item, " (~%luW)", power_n * load_n / 100); str_vector_add_owned (&items, str_steal (&item)); } struct str result; str_init (&result); str_append (&result, "UPS: "); for (size_t i = 0; i < items.len; i++) { if (i) str_append (&result, "; "); str_append (&result, items.vector[i]); } str_vector_free (&items); str_vector_add_owned (ups_list, str_steal (&result)); } static void nut_on_logout_response (const struct nut_response *response, void *user_data) { if (!nut_common_handler (response)) return; struct app_context *ctx = user_data; struct str_vector ups_list; str_vector_init (&ups_list); struct str_map_iter iter; str_map_iter_init (&iter, &ctx->nut_ups_info); struct str_map *dict; while ((dict = str_map_iter_next (&iter))) nut_process_ups (ctx, &ups_list, iter.link->key, dict); free (ctx->nut_status); ctx->nut_status = NULL; if (ups_list.len) { struct str status; str_init (&status); str_append (&status, ups_list.vector[0]); for (size_t i = 1; i < ups_list.len; i++) str_append_printf (&status, " %s", ups_list.vector[0]); ctx->nut_status = str_steal (&status); } ctx->nut_success = true; str_vector_free (&ups_list); refresh_status (ctx); } static void nut_store_var (struct app_context *ctx, const char *ups_name, const char *key, const char *value) { struct str_map *map; if (!(map = str_map_find (&ctx->nut_ups_info, ups_name))) { str_map_init ((map = xcalloc (1, sizeof *map))); map->free = free; str_map_set (&ctx->nut_ups_info, ups_name, map); } str_map_set (map, key, xstrdup (value)); } static void nut_on_var_response (const struct nut_response *response, void *user_data) { if (!nut_common_handler (response)) return; struct app_context *ctx = user_data; LIST_FOR_EACH (struct nut_line, iter, response->data) { const struct str_vector *fields = &iter->fields; if (!soft_assert (fields->len >= 4 && !strcmp (fields->vector[0], "VAR"))) continue; nut_store_var (ctx, fields->vector[1], fields->vector[2], fields->vector[3]); } } static void nut_on_list_ups_response (const struct nut_response *response, void *user_data) { if (!nut_common_handler (response)) return; struct app_context *ctx = user_data; struct nut_client *c = &ctx->nut_client; // Then we list all their properties and terminate the connection LIST_FOR_EACH (struct nut_line, iter, response->data) { const struct str_vector *fields = &iter->fields; if (!soft_assert (fields->len >= 2 && !strcmp (fields->vector[0], "UPS"))) continue; nut_client_send_command (c, "LIST", "VAR", fields->vector[1], NULL); nut_client_add_task (c, nut_on_var_response, ctx); } nut_client_send_command (c, "LOGOUT", NULL); nut_client_add_task (c, nut_on_logout_response, ctx); } static void nut_on_connected (void *user_data) { struct app_context *ctx = user_data; struct nut_client *c = &ctx->nut_client; // First we list all available UPS devices nut_client_send_command (c, "LIST", "UPS", NULL); nut_client_add_task (c, nut_on_list_ups_response, ctx); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void nut_indicate_failure (struct app_context *ctx) { free (ctx->nut_status); ctx->nut_status = xstrdup ("NUT failure"); refresh_status (ctx); } static void nut_on_failure (void *user_data) { struct app_context *ctx = user_data; // This is also triggered both by a failed connect and a clean disconnect if (!ctx->nut_success) { print_error ("connection to NUT failed"); nut_indicate_failure (ctx); } } static void on_nut_reconnect (void *user_data) { struct app_context *ctx = user_data; bool want_nut = false; if (!set_boolean_if_valid (&want_nut, str_map_find (&ctx->config, "nut_enabled"))) print_error ("invalid configuration value for `%s'", "nut_enabled"); if (!want_nut) return; struct nut_client *c = &ctx->nut_client; c->user_data = ctx; c->on_failure = nut_on_failure; c->on_connected = nut_on_connected; // So that we don't have to maintain a separate timeout timer, // we keep a simple periodic reconnect timer if (c->state != NUT_DISCONNECTED) { print_error ("failed to retrieve NUT status within the interval"); nut_indicate_failure (ctx); nut_client_reset (c); } str_map_clear (&ctx->nut_ups_info); nut_client_connect (&ctx->nut_client, "localhost", "3493"); ctx->nut_success = false; poller_timer_set (&ctx->nut_reconnect, 10 * 1000); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #define DEFAULT_SOURCE "@DEFAULT_SOURCE@" #define DEFAULT_SINK "@DEFAULT_SINK@" static void on_sink_info (pa_context *context, const pa_sink_info *info, int eol, void *userdata) { (void) context; if (info && !eol) { struct app_context *ctx = userdata; ctx->sink_volume = info->volume; ctx->sink_muted = !!info->mute; str_vector_reset (&ctx->sink_ports); free (ctx->sink_port_active); ctx->sink_port_active = NULL; if (info->ports) for (struct pa_sink_port_info **iter = info->ports; *iter; iter++) str_vector_add (&ctx->sink_ports, (*iter)->name); if (info->active_port) ctx->sink_port_active = xstrdup (info->active_port->name); refresh_status (ctx); } } static void on_source_info (pa_context *context, const pa_source_info *info, int eol, void *userdata) { (void) context; if (info && !eol) { struct app_context *ctx = userdata; ctx->source_muted = !!info->mute; } } static void update_volume (struct app_context *ctx) { pa_operation_unref (pa_context_get_sink_info_by_name (ctx->context, DEFAULT_SINK, on_sink_info, ctx)); pa_operation_unref (pa_context_get_source_info_by_name (ctx->context, DEFAULT_SOURCE, on_source_info, ctx)); } static void on_event (pa_context *context, pa_subscription_event_type_t event, uint32_t index, void *userdata) { (void) context; (void) index; struct app_context *ctx = userdata; if ((event & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_CHANGE) update_volume (ctx); } static void on_subscribe_finish (pa_context *context, int success, void *userdata) { (void) context; struct app_context *ctx = userdata; if (!success) { ctx->failed = true; refresh_status (ctx); } } static void on_context_state_change (pa_context *context, void *userdata) { struct app_context *ctx = userdata; switch (pa_context_get_state (context)) { case PA_CONTEXT_FAILED: case PA_CONTEXT_TERMINATED: ctx->failed = true; refresh_status (ctx); pa_context_unref (context); ctx->context = NULL; // Retry after an arbitrary delay of 5 seconds poller_timer_set (&ctx->make_context, 5000); return; case PA_CONTEXT_READY: ctx->failed = false; refresh_status (ctx); pa_context_set_subscribe_callback (context, on_event, userdata); pa_operation_unref (pa_context_subscribe (context, PA_SUBSCRIPTION_MASK_SINK | PA_SUBSCRIPTION_MASK_SOURCE, on_subscribe_finish, userdata)); update_volume (ctx); default: return; } } static void on_make_context (void *user_data) { struct app_context *ctx = user_data; ctx->context = pa_context_new (ctx->api, PROGRAM_NAME); pa_context_set_state_callback (ctx->context, on_context_state_change, ctx); pa_context_connect (ctx->context, NULL, PA_CONTEXT_NOFLAGS, NULL); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void spawn (struct app_context *ctx, char *argv[]) { posix_spawn_file_actions_t actions; posix_spawn_file_actions_init (&actions); posix_spawn_file_actions_addclose (&actions, ConnectionNumber (ctx->dpy)); if (ctx->mpd_client.socket != -1) posix_spawn_file_actions_addclose (&actions, ctx->mpd_client.socket); if (ctx->nut_client.socket != -1) posix_spawn_file_actions_addclose (&actions, ctx->nut_client.socket); posix_spawnattr_t attr; posix_spawnattr_init (&attr); posix_spawnattr_setpgroup (&attr, 0); posix_spawnp (NULL, argv[0], &actions, &attr, argv, environ); posix_spawn_file_actions_destroy (&actions); posix_spawnattr_destroy (&attr); } #define MPD_SIMPLE(name, ...) \ static void \ on_mpd_ ## name (struct app_context *ctx, int arg) \ { \ (void) arg; \ struct mpd_client *c = &ctx->mpd_client; \ if (c->state != MPD_CONNECTED) \ return; \ mpd_client_send_command (c, __VA_ARGS__); \ mpd_client_add_task (c, NULL, NULL); \ mpd_client_idle (c, 0); \ } // XXX: pause without argument is deprecated, we can watch play state // if we want to have the toggle pause/play functionality MPD_SIMPLE (play, "pause", NULL) MPD_SIMPLE (stop, "stop", NULL) MPD_SIMPLE (prev, "previous", NULL) MPD_SIMPLE (next, "next", NULL) MPD_SIMPLE (forward, "seekcur", "+10", NULL) MPD_SIMPLE (backward, "seekcur", "-10", NULL) static void on_volume_finish (pa_context *context, int success, void *userdata) { (void) context; (void) success; (void) userdata; // Just like... whatever, man } static void on_volume_mic_mute (struct app_context *ctx, int arg) { (void) arg; if (!ctx->context) return; pa_operation_unref (pa_context_set_source_mute_by_name (ctx->context, DEFAULT_SOURCE, !ctx->source_muted, on_volume_finish, ctx)); } static void on_volume_switch (struct app_context *ctx, int arg) { (void) arg; if (!ctx->context || !ctx->sink_port_active || !ctx->sink_ports.len) return; size_t current = 0; for (size_t i = 0; i < ctx->sink_ports.len; i++) if (!strcmp (ctx->sink_port_active, ctx->sink_ports.vector[i])) current = i; pa_operation_unref (pa_context_set_sink_port_by_name (ctx->context, DEFAULT_SINK, ctx->sink_ports.vector[(current + 1) % ctx->sink_ports.len], on_volume_finish, ctx)); } static void on_volume_mute (struct app_context *ctx, int arg) { (void) arg; if (!ctx->context) return; pa_operation_unref (pa_context_set_sink_mute_by_name (ctx->context, DEFAULT_SINK, !ctx->sink_muted, on_volume_finish, ctx)); } static void on_volume_set (struct app_context *ctx, int arg) { if (!ctx->context) return; pa_cvolume volume = ctx->sink_volume; if (arg > 0) pa_cvolume_inc (&volume, (pa_volume_t) arg * PA_VOLUME_NORM / 100); else pa_cvolume_dec (&volume, (pa_volume_t) -arg * PA_VOLUME_NORM / 100); pa_operation_unref (pa_context_set_sink_volume_by_name (ctx->context, DEFAULT_SINK, &volume, on_volume_finish, ctx)); } static void on_lock (struct app_context *ctx, int arg) { (void) arg; // One of these will work char *argv_gdm[] = { "gdm-switch-user", NULL }; spawn (ctx, argv_gdm); char *argv_ldm[] = { "dm-tool", "lock", NULL }; spawn (ctx, argv_ldm); } static void on_brightness (struct app_context *ctx, int arg) { char *value = xstrdup_printf ("%d", arg); char *argv[] = { "brightness", value, NULL }; spawn (ctx, argv); free (value); } static void on_lock_group (struct app_context *ctx, int arg) { XkbLockGroup (ctx->dpy, XkbUseCoreKbd, arg); } struct { unsigned mod; KeySym keysym; void (*handler) (struct app_context *ctx, int arg); int arg; } g_keys[] = { // This key should be labeled L on normal Qwert[yz] layouts { Mod4Mask, XK_n, on_lock, 0 }, // MPD { Mod4Mask, XK_Up, on_mpd_play, 0 }, { Mod4Mask, XK_Down, on_mpd_stop, 0 }, { Mod4Mask, XK_Left, on_mpd_prev, 0 }, { Mod4Mask, XK_Right, on_mpd_next, 0 }, /* xmodmap | grep -e Alt_R -e Meta_R -e ISO_Level3_Shift -e Mode_switch */ { Mod4Mask | Mod5Mask, XK_Left, on_mpd_backward, 0 }, { Mod4Mask | Mod5Mask, XK_Right, on_mpd_forward, 0 }, // Keyboard groups { Mod4Mask, XK_F9, on_lock_group, 0 }, { Mod4Mask, XK_F10, on_lock_group, 1 }, { Mod4Mask, XK_F11, on_lock_group, 2 }, { Mod4Mask, XK_F12, on_lock_group, 3 }, // Brightness { Mod4Mask, XK_Home, on_brightness, 10 }, { Mod4Mask, XK_End, on_brightness, -10 }, { 0, XF86XK_MonBrightnessUp, on_brightness, 10 }, { 0, XF86XK_MonBrightnessDown, on_brightness, -10 }, // Volume { Mod4Mask, XK_Insert, on_volume_switch, 0 }, { Mod4Mask, XK_Delete, on_volume_mute, 0 }, { Mod4Mask, XK_Page_Up, on_volume_set, 5 }, { Mod4Mask | Mod5Mask, XK_Page_Up, on_volume_set, 1 }, { Mod4Mask, XK_Page_Down, on_volume_set, -5 }, { Mod4Mask | Mod5Mask, XK_Page_Down, on_volume_set, -1 }, { 0, XF86XK_AudioMicMute, on_volume_mic_mute, 0 }, { 0, XF86XK_AudioMute, on_volume_mute, 0 }, { 0, XF86XK_AudioRaiseVolume, on_volume_set, 5 }, { 0, XF86XK_AudioLowerVolume, on_volume_set, -5 }, }; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void on_x_keypress (struct app_context *ctx, XEvent *e) { XKeyEvent *ev = &e->xkey; unsigned unconsumed_mods; KeySym keysym; if (!XkbLookupKeySym (ctx->dpy, (KeyCode) ev->keycode, ev->state, &unconsumed_mods, &keysym)) return; for (size_t i = 0; i < N_ELEMENTS (g_keys); i++) if (g_keys[i].keysym == keysym && g_keys[i].mod == ev->state && g_keys[i].handler) g_keys[i].handler (ctx, g_keys[i].arg); } static void on_xkb_event (struct app_context *ctx, XkbEvent *ev) { int group; if (ev->any.xkb_type == XkbStateNotify) group = ev->state.group; else { XkbStateRec rec; XkbGetState (ctx->dpy, XkbUseCoreKbd, &rec); group = rec.group; } XkbDescPtr desc = XkbAllocKeyboard (); XkbGetNames (ctx->dpy, XkbGroupNamesMask, desc); free (ctx->layout); ctx->layout = NULL; if (group != 0) { char *layout = XGetAtomName (ctx->dpy, desc->names->groups[group]); ctx->layout = xstrdup (layout); XFree (layout); } XkbFreeKeyboard (desc, 0, True); refresh_status (ctx); } static void on_x_ready (const struct pollfd *pfd, void *user_data) { (void) pfd; struct app_context *ctx = user_data; XkbEvent ev; while (XPending (ctx->dpy)) { if (XNextEvent (ctx->dpy, &ev.core)) exit_fatal ("XNextEvent returned non-zero"); if (ev.type == KeyPress) on_x_keypress (ctx, &ev.core); if (ev.type == ctx->xkb_base_event_code) on_xkb_event (ctx, &ev); } } static void grab_keys (struct app_context *ctx) { unsigned ignored_locks = LockMask | XkbKeysymToModifiers (ctx->dpy, XK_Num_Lock); hard_assert (XkbSetIgnoreLockMods (ctx->dpy, XkbUseCoreKbd, ignored_locks, ignored_locks, 0, 0)); KeyCode code; Window root = DefaultRootWindow (ctx->dpy); for (size_t i = 0; i < N_ELEMENTS (g_keys); i++) if ((code = XKeysymToKeycode (ctx->dpy, g_keys[i].keysym))) XGrabKey (ctx->dpy, code, g_keys[i].mod, root, False /* ? */, GrabModeAsync, GrabModeAsync); XSelectInput (ctx->dpy, root, KeyPressMask); XSync (ctx->dpy, False); ctx->x_event.dispatcher = on_x_ready; ctx->x_event.user_data = ctx; poller_fd_set (&ctx->x_event, POLLIN); // XXX: XkbMapNotify -> XkbRefreshKeyboardMapping(), ...? XkbSelectEventDetails (ctx->dpy, XkbUseCoreKbd, XkbNamesNotify, XkbAllNamesMask, XkbGroupNamesMask); XkbSelectEventDetails (ctx->dpy, XkbUseCoreKbd, XkbStateNotify, XkbAllStateComponentsMask, XkbGroupStateMask); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void poller_timer_init_and_set (struct poller_timer *self, struct poller *poller, poller_timer_fn cb, void *user_data) { poller_timer_init (self, poller); self->dispatcher = cb; self->user_data = user_data; poller_timer_set (self, 0); } int main (int argc, char *argv[]) { g_log_message_real = log_message_custom; static const struct opt opts[] = { { 'd', "debug", NULL, 0, "run in debug mode" }, { 'h', "help", NULL, 0, "display this help and exit" }, { 'V', "version", NULL, 0, "output version information and exit" }, { 'w', "write-default-cfg", "FILENAME", OPT_OPTIONAL_ARG | OPT_LONG_ONLY, "write a default configuration file and exit" }, { 0, NULL, NULL, 0, NULL } }; struct opt_handler oh; opt_handler_init (&oh, argc, argv, opts, NULL, "Set root window name."); int c; while ((c = opt_handler_get (&oh)) != -1) switch (c) { case 'd': g_debug_mode = true; break; case 'h': opt_handler_usage (&oh, stdout); exit (EXIT_SUCCESS); case 'V': printf (PROGRAM_NAME " " PROGRAM_VERSION "\n"); exit (EXIT_SUCCESS); case 'w': call_simple_config_write_default (optarg, g_config_table); exit (EXIT_SUCCESS); default: print_error ("wrong options"); opt_handler_usage (&oh, stderr); exit (EXIT_FAILURE); } argc -= optind; argv += optind; opt_handler_free (&oh); // We don't need to retrieve exit statuses of anything, avoid zombies struct sigaction sa; sa.sa_flags = SA_RESTART | SA_NOCLDWAIT; sigemptyset (&sa.sa_mask); sa.sa_handler = SIG_IGN; if (sigaction (SIGCHLD, &sa, NULL) == -1) print_error ("%s: %s", "sigaction", strerror (errno)); struct app_context ctx; app_context_init (&ctx); ctx.prefix = argc > 1 ? argv[1] : NULL; struct error *e = NULL; if (!simple_config_update_from_file (&ctx.config, &e)) exit_fatal ("%s", e->message); poller_timer_init_and_set (&ctx.time_changed, &ctx.poller, on_time_changed, &ctx); poller_timer_init_and_set (&ctx.make_context, &ctx.poller, on_make_context, &ctx); poller_timer_init_and_set (&ctx.refresh_rest, &ctx.poller, on_refresh_rest, &ctx); poller_timer_init_and_set (&ctx.mpd_reconnect, &ctx.poller, on_mpd_reconnect, &ctx); poller_timer_init_and_set (&ctx.nut_reconnect, &ctx.poller, on_nut_reconnect, &ctx); grab_keys (&ctx); poller_pa_run (ctx.api); app_context_free (&ctx); return 0; }