tarina

daemon.c (10023B)

---

 /*
  *  Advanced Linux Sound Architecture Control Program
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
  *
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
  *   the Free Software Foundation; either version 2 of the License, or
  *   (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *   GNU General Public License for more details.
  *
  *   You should have received a copy of the GNU General Public License
  *   along with this program; if not, write to the Free Software
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  *
  */
 
 #include "aconfig.h"
 #include "version.h"
 #include <getopt.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <assert.h>
 #include <errno.h>
 #include <signal.h>
 #include <time.h>
 #include <poll.h>
 #include <alsa/asoundlib.h>
 #include "alsactl.h"
 
 struct id_list {
 	snd_ctl_elem_id_t **list;
 	int size;
 };
 
 struct card {
 	int index;
 	int pfds;
 	snd_ctl_t *handle;
 	struct id_list whitelist;
 	struct id_list blacklist;
 };
 
 static int quit = 0;
 static int rescan = 0;
 static int save_now = 0;
 
 static void signal_handler_quit(int sig)
 {
 	quit = 1;
 	signal(sig, signal_handler_quit);
 }
 
 static void signal_handler_save_and_quit(int sig)
 {
 	quit = save_now = 1;
 	signal(sig, signal_handler_quit);
 }
 
 static void signal_handler_rescan(int sig)
 {
 	rescan = 1;
 	signal(sig, signal_handler_rescan);
 }
 
 static void free_list(struct id_list *list)
 {
 	int i;
 
 	for (i = 0; i < list->size; i++)
 		free(list->list[i]);
 	free(list->list);
 }
 
 static void card_free(struct card **card)
 {
 	struct card *c = *card;
 
 	free_list(&c->blacklist);
 	free_list(&c->whitelist);
 	if (c->handle)
 		snd_ctl_close(c->handle);
 	free(c);
 	*card = NULL;
 }
 
 static void add_card(struct card ***cards, int *count, const char *cardname)
 {
 	struct card *card, **cc;
 	int i, index, findex;
 	char device[16];
 
 	index = snd_card_get_index(cardname);
 	if (index < 0)
 		return;
 	for (i = 0, findex = -1; i < *count; i++) {
 		if ((*cards)[i] == NULL) {
 			findex = i;
 		} else {
 			if ((*cards)[i]->index == index)
 				return;
 		}
 	}
 	card = calloc(1, sizeof(*card));
 	if (card == NULL)
 		return;
 	card->index = index;
 	sprintf(device, "hw:%i", index);
 	if (snd_ctl_open(&card->handle, device, SND_CTL_READONLY|SND_CTL_NONBLOCK) < 0) {
 		card_free(&card);
 		return;
 	}
 	card->pfds = snd_ctl_poll_descriptors_count(card->handle);
 	if (card->pfds < 0) {
 		card_free(&card);
 		return;
 	}
 	if (snd_ctl_subscribe_events(card->handle, 1) < 0) {
 		card_free(&card);
 		return;
 	}
 	if (findex >= 0) {
 		(*cards)[findex] = card;
 	} else {
 		cc = realloc(*cards, sizeof(void *) * (*count + 1));
 		if (cc == NULL) {
 			card_free(&card);
 			return;
 		}
 		cc[*count] = card;
 		*count = *count + 1;
 		*cards = cc;
 	}
 }
 
 static void add_cards(struct card ***cards, int *count)
 {
 	int card = -1;
 	char cardname[16];
 
 	while (1) {
 		if (snd_card_next(&card) < 0)
 			break;
 		if (card < 0)
 			break;
 		if (card >= 0) {
 			sprintf(cardname, "%i", card);
 			add_card(cards, count, cardname);
 		}
 	}
 }
 
 static int compare_ids(snd_ctl_elem_id_t *id1, snd_ctl_elem_id_t *id2)
 {
 	if (id1 == NULL || id2 == NULL)
 		return 0;
 	return snd_ctl_elem_id_get_interface(id1) == snd_ctl_elem_id_get_interface(id2) &&
 	       snd_ctl_elem_id_get_index(id1) == snd_ctl_elem_id_get_index(id2) &&
 	       strcmp(snd_ctl_elem_id_get_name(id1), snd_ctl_elem_id_get_name(id2)) == 0 &&
 	       snd_ctl_elem_id_get_device(id1) == snd_ctl_elem_id_get_device(id2) &&
 	       snd_ctl_elem_id_get_subdevice(id1) == snd_ctl_elem_id_get_subdevice(id2);
 }
 
 static int in_list(struct id_list *list, snd_ctl_elem_id_t *id)
 {
 	int i;
 	snd_ctl_elem_id_t *id1;
 
 	for (i = 0; i < list->size; i++) {
 		id1 = list->list[i];
 		if (id1 == NULL)
 			continue;
 		if (compare_ids(id, id1))
 			return 1;
 	}
 	return 0;
 }
 
 static void remove_from_list(struct id_list *list, snd_ctl_elem_id_t *id)
 {
 	int i;
 
 	for (i = 0; i < list->size; i++) {
 		if (compare_ids(id, list->list[i])) {
 			free(list->list[i]);
 			list->list[i] = NULL;
 		}
 	}
 }
 
 static void add_to_list(struct id_list *list, snd_ctl_elem_id_t *id)
 {
 	snd_ctl_elem_id_t *id1;
 	snd_ctl_elem_id_t **n;
 	int i;
 
 	if (snd_ctl_elem_id_malloc(&id1))
 		return;
 	snd_ctl_elem_id_copy(id1, id);
 	for (i = 0; i < list->size; i++) {
 		if (list->list[i] == NULL) {
 			list->list[i] = id1;
 			return;
 		}
 	}
 	n = realloc(list->list, sizeof(void *) * (list->size + 1));
 	if (n == NULL)
 		return;
 	n[list->size] = id1;
 	list->size++;
 	list->list = n;
 }
 
 static int check_lists(struct card *card, snd_ctl_elem_id_t *id)
 {
 	snd_ctl_elem_info_t *info;
 	snd_ctl_elem_info_alloca(&info);
 
 	if (in_list(&card->blacklist, id))
 		return 0;
 	if (in_list(&card->whitelist, id))
 		return 1;
 	snd_ctl_elem_info_set_id(info, id);
 	if (snd_ctl_elem_info(card->handle, info) < 0)
 		return 0;
 	if (snd_ctl_elem_info_is_writable(info) ||
 	    snd_ctl_elem_info_is_tlv_writable(info)) {
 		add_to_list(&card->whitelist, id);
 		return 1;
 	} else {
 		add_to_list(&card->blacklist, id);
 		return 0;
 	}
 }
 
 static int card_events(struct card *card)
 {
 	int res = 0;
 	snd_ctl_event_t *ev;
 	snd_ctl_event_type_t type;
 	unsigned int mask;
 	snd_ctl_elem_id_t *id;
 	snd_ctl_event_alloca(&ev);
 	snd_ctl_elem_id_alloca(&id);
 
 	while (snd_ctl_read(card->handle, ev) == 1) {
 		type = snd_ctl_event_get_type(ev);
 		if (type != SND_CTL_EVENT_ELEM)
 			continue;
 		mask = snd_ctl_event_elem_get_mask(ev);
 		snd_ctl_event_elem_get_id(ev, id);
 		if (mask == SND_CTL_EVENT_MASK_REMOVE) {
 			remove_from_list(&card->whitelist, id);
 			remove_from_list(&card->blacklist, id);
 			continue;
 		}
 		if (mask & SND_CTL_EVENT_MASK_INFO) {
 			remove_from_list(&card->whitelist, id);
 			remove_from_list(&card->blacklist, id);
 		}
 		if (mask & (SND_CTL_EVENT_MASK_VALUE|
 			    SND_CTL_EVENT_MASK_ADD|
 			    SND_CTL_EVENT_MASK_TLV)) {
 			if (check_lists(card, id))
 				res = 1;
 		}
 	}
 	return res;
 }
 
 static long read_pid_file(const char *pidfile)
 {
 	int fd, err;
 	char pid_txt[12];
 
 	fd = open(pidfile, O_RDONLY);
 	if (fd >= 0) {
 		err = read(fd, pid_txt, 11);
 		if (err != 11)
 			err = err < 0 ? -errno : -EIO;
 		close(fd);
 		pid_txt[11] = '\0';
 		return atol(pid_txt);
 	} else {
 		return -errno;
 	}
 }
 
 static int write_pid_file(const char *pidfile)
 {
 	int fd, err;
 	char pid_txt[12];
 
 	sprintf(pid_txt, "%10li\n", (long)getpid());
 	fd = open(pidfile, O_WRONLY|O_CREAT|O_EXCL, 0600);
 	if (fd >= 0) {
 		err = write(fd, pid_txt, 11);
 		if (err != 11) {
 			err = err < 0 ? -errno : -EIO;
 			unlink(pidfile);
 		} else {
 			err = 0;
 		}
 		close(fd);
 	} else {
 		err = -errno;
 	}
 	return err;
 }
 
 int state_daemon_kill(const char *pidfile, const char *cmd)
 {
 	long pid;
 	int sig = SIGHUP;
 
 	if (cmd == NULL) {
 		error("Specify kill command (quit, rescan or save_and_quit)");
 		return -EINVAL;
 	}
 	if (strcmp(cmd, "rescan") == 0)
 		sig = SIGUSR1;
 	else if (strcmp(cmd, "save_and_quit") == 0)
 		sig = SIGUSR2;
 	else if (strcmp(cmd, "quit") == 0)
 		sig = SIGTERM;
 	if (sig == SIGHUP) {
 		error("Unknown kill command '%s'", cmd);
 		return -EINVAL;
 	}
 	pid = read_pid_file(pidfile);
 	if (pid > 0) {
 		if (kill(pid, sig) >= 0)
 			return 0;
 		return -errno;
 	}
 	return 0;
 }
 
 static int check_another_instance(const char *pidfile)
 {
 	long pid;
 
 	pid = read_pid_file(pidfile);
 	if (pid >= 0) {
 		/* invoke new card rescan */
 		if (kill(pid, SIGUSR1) >= 0) {
 			usleep(1000);
 			pid = read_pid_file(pidfile);
 			if (pid >= 0)
 				return 1;
 		}
 	}
 	return 0;
 }
 
 int state_daemon(const char *file, const char *cardname, int period,
 		 const char *pidfile)
 {
 	int count = 0, pcount, psize = 0, i, j, k, changed = 0;
 	time_t last_write, now;
 	unsigned short revents;
 	struct card **cards = NULL;
 	struct pollfd *pfd = NULL, *pfdn;
 
 	if (check_another_instance(pidfile))
 		return 0;
 	rescan = 1;
 	signal(SIGABRT, signal_handler_quit);
 	signal(SIGTERM, signal_handler_quit);
 	signal(SIGINT, signal_handler_quit);
 	signal(SIGUSR1, signal_handler_rescan);
 	signal(SIGUSR2, signal_handler_save_and_quit);
 	write_pid_file(pidfile);
 	time(&last_write);
 	while (!quit || save_now) {
 		if (save_now)
 			goto save;
 		if (rescan) {
 			if (cardname) {
 				add_card(&cards, &count, cardname);
 			} else {
 				add_cards(&cards, &count);
 			}
 			snd_config_update_free_global();
 			rescan = 0;
 		}
 		for (i = pcount = 0; i < count; i++) {
 			if (cards[i] == NULL)
 				continue;
 			pcount += cards[i]->pfds;
 		}
 		if (pcount > psize) {
 			pfdn = realloc(pfd, sizeof(struct pollfd) * pcount);
 			if (pfdn) {
 				psize = pcount;
 				pfd = pfdn;
 			} else {
 				error("No enough memory...");
 				goto out;
 			}
 		}
 		for (i = j = 0; i < count; i++) {
 			if (cards[i] == NULL)
 				continue;
 			k = snd_ctl_poll_descriptors(cards[i]->handle, pfd + j, pcount - j);
 			if (k != cards[i]->pfds) {
 				error("poll prepare failed: %i", k);
 				goto out;
 			}
 			j += k;
 		}
 		i = poll(pfd, j, (period / 2) * 1000);
 		if (i < 0 && errno == EINTR)
 			continue;
 		if (i < 0) {
 			error("poll failed: %s", strerror(errno));
 			break;
 		}
 		time(&now);
 		for (i = j = 0; i < count; i++) {
 			if (cards[i] == NULL)
 				continue;
 			k = snd_ctl_poll_descriptors_revents(cards[i]->handle,
 					pfd + j, cards[i]->pfds, &revents);
 			if (k < 0) {
 				error("poll post failed: %i\n", k);
 				goto out;
 			}
 			j += cards[i]->pfds;
 			if (revents & (POLLERR|POLLNVAL)) {
 				card_free(&cards[i]);
 			} else if (revents & POLLIN) {
 				if (card_events(cards[i])) {
 					/* delay the write */
 					if (!changed)
 						last_write = now;
 					changed = 1;
 				}
 			}
 		}
 		if ((now - last_write >= period && changed) || save_now) {
 save:
 			changed = save_now = 0;
 			save_state(file, cardname);
 		}
 	}
 out:
 	free(pfd);
 	remove(pidfile);
 	if (cards) {
 		for (i = 0; i < count; i++)
 			card_free(&cards[i]);
 		free(cards);
 	}
 	return 0;
 }