path: root/stat.c

/*
 * Copyright (C) 2005-2007 Andre Noll <maan@systemlinux.org>
 *
 * Licensed under the GPL v2. For licencing details see COPYING.
 */

/**
 *  \file stat.c functions used for sending/receiving the status of para_server
 *  and para_audiod
 */
#include "para.h"
#include "close_on_fork.h"
#include "list.h"
#include "error.h"
#include "string.h"
#include "fd.h"

/** the maximal number of simultaneous connections */
#define MAX_STAT_CLIENTS 50

/**
 * describes a status client of para_audiod
 *
 * There's one such structure per audiod client that sent the 'stat' command.
 *
 * A status client is identified by its file descriptor.  para_audiod
 * keeps a list of connected status clients.
 */
struct stat_client {
	/** the stat client's file descriptor */
	int fd;
	/** bitmask of those status items the client is interested in */
	long unsigned item_mask;
	/** its entry in the list of stat clients */
	struct list_head node;
};

static struct list_head client_list;
static int initialized;
static int num_clients;

/**
 * the list of all status items sent by para_server/para_audiod
 */
const char *status_item_list[NUM_STAT_ITEMS] = {
	[SI_STATUS_BAR] = "status_bar",
	[SI_STATUS] = "status",
	[SI_NUM_PLAYED] = "num_played",

	[SI_MTIME] = "mtime",
	[SI_LENGTH_MIN] = "length_min",
	[SI_LENGTH_SEC] = "length_sec",

	[SI_FILE_SIZE] = "file_size",
	[SI_STATUS_FLAGS] = "status_flags",
	[SI_FORMAT] = "format",

	[SI_SCORE] = "score",
	[SI_AUDIO_INFO1] = "audio_file_info1",
	[SI_AUDIO_INFO2] = "audio_file_info2",

	[SI_AUDIO_INFO3] = "audio_file_info3",
	[SI_DBINFO1] = "dbinfo1",
	[SI_DBINFO2] = "dbinfo2",

	[SI_DBINFO3] = "dbinfo3",
	[SI_DECODER_FLAGS] = "decoder_flags",
	[SI_AUDIOD_STATUS] = "audiod_status",

	[SI_PLAY_TIME] = "play_time",
	[SI_UPTIME] = "uptime",
	[SI_OFFSET] = "offset",

	[SI_LENGTH] = "length",
	[SI_STREAM_START] = "stream_start",
	[SI_CURRENT_TIME] = "current_time",

	[SI_AUDIOD_UPTIME] = "audiod_uptime",
	[SI_SELECTOR] = "dbtool"
};

static void dump_stat_client_list(void)
{
	struct stat_client *sc;

	if (!initialized)
		return;
	list_for_each_entry(sc, &client_list, node)
		PARA_INFO_LOG("stat client on fd %d\n", sc->fd);
}
/**
 * add a status client to the list
 *
 * \param fd the file descriptor of the client
 * \param mask bitfield of status items for this client
 *
 * Only those status items having the bit set in \a mask will be
 * sent to the client.
 *
 * \return Positive value on success, or -E_TOO_MANY_CLIENTS if
 * the number of connected clients exceeds #MAX_STAT_CLIENTS.
 */
int stat_client_add(int fd, long unsigned mask)
{
	struct stat_client *new_client;

	if (num_clients >= MAX_STAT_CLIENTS) {
		PARA_ERROR_LOG("maximal number of stat clients (%d) exceeded\n",
			MAX_STAT_CLIENTS);
		return -E_TOO_MANY_CLIENTS;
	}
	if (!initialized) {
		INIT_LIST_HEAD(&client_list);
		initialized = 1;
	}
	PARA_INFO_LOG("adding client on fd %d\n", fd);
	new_client = para_malloc(sizeof(struct stat_client));
	new_client->fd = fd;
	new_client->item_mask = mask;
	para_list_add(&new_client->node, &client_list);
	dump_stat_client_list();
	num_clients++;
	return 1;
}
/**
 * write a message to all connected status clients
 *
 * \param msg a \p NULL terminated buffer
 * \param itemnum The number of the status item of \a msg
 *
 * On write errors, remove the status client from the client list and close its
 * file descriptor.
 */
void stat_client_write(const char *msg, int itemnum)
{
	struct stat_client *sc, *tmp;
	size_t len = strlen(msg);
	struct timeval tv = {0 , 0};

	if (!initialized || !len)
		return;
	list_for_each_entry_safe(sc, tmp, &client_list, node) {
		int fd = sc->fd, ret;
		fd_set wfds;

		if (!((1 << itemnum) & sc->item_mask))
			continue;
		FD_ZERO(&wfds);
		FD_SET(fd, &wfds);
//		PARA_DEBUG_LOG("%s: p=%lx\n", __func__, (long)p);
		ret = para_select(fd + 1, NULL, &wfds, &tv);
		if (ret > 0) {
			ret = write(fd, msg, len);
			PARA_DEBUG_LOG("dumped %s to fd %d, ret = %d\n", msg, fd, ret);
			if (ret == len )
				continue;
		}
		/* write error or fd not ready for writing */
		close(fd);
		num_clients--;
		PARA_INFO_LOG("deleting client on fd %d\n", fd);
		list_del(&sc->node);
		free(sc);
		dump_stat_client_list();
	}
	PARA_DEBUG_LOG("%d client(s)\n", num_clients);
}


/**
 * check if string is a known status item.
 *
 * \param item buffer containing the text to check
 *
 * \return If \a item is a valid status item, the number of that status item is
 * returned. Otherwise, this function returns \p -E_UNKNOWN_STAT_ITEM.
 */
int stat_item_valid(const char *item)
{
	int i;
	if (!item || !*item) {
	PARA_ERROR_LOG("%s\n", "no item");
		return -E_UNKNOWN_STAT_ITEM;
	}
	FOR_EACH_STAT_ITEM(i)
		if (!strcmp(status_item_list[i], item))
			return i;
	return -E_UNKNOWN_STAT_ITEM;
}

/**
 * check if line starts with known status item.
 *
 * \param line buffer containing the line
 *
 * \return If the beginning of \a line matches any paraslash status item and is
 * followed by a colon, the number of that status item is returned. Otherwise,
 * this function returns \p -E_UNKNOWN_STAT_ITEM.
 */
int stat_line_valid(const char *line)
{
	int i;
	size_t line_len;

	if (!line || !*line)
		return -E_UNKNOWN_STAT_ITEM;
	line_len = strlen(line);
	FOR_EACH_STAT_ITEM(i) {
		const char *s = status_item_list[i];
		size_t item_len = strlen(s);

		if (line_len > item_len && line[item_len] == ':' &&
				!strncmp(line, s, item_len))
			return i;
	}
	return -E_UNKNOWN_STAT_ITEM;
}

/**
 * call a custom function for each complete line
 *
 * \param buf the buffer containing data seperated by newlines
 * \param n the number of bytes in \a buf
 * \param line_handler the custom function
 *
 * If \a line_handler is \p NULL, return number of complete lines in buf.
 * Otherwise, call \a line_handler for each complete line.  The rest of the
 * buffer (last chunk containing incomplete line is moved to the beginning of
 * the buffer.
 *
 * \return If line_handler is not NULL, this function returns the number
 * of bytes not handled to \a line_handler.
 */
size_t for_each_line(char *buf, size_t n, void (*line_handler)(char *))
{
	char *start = buf, *end;
	size_t num_lines = 0, bytes_left = n;

//	PARA_INFO_LOG("buf: %s", buf);
	while (bytes_left) {
		char *next_null;
		char *next_cr;

		next_cr = memchr(start, '\n', bytes_left);
		next_null = memchr(start, '\0', bytes_left);
		if (!next_cr && !next_null)
			break;
		if (next_cr && next_null) {
			end = next_cr < next_null? next_cr : next_null;
		} else if (next_null) {
			end = next_null;
		} else
			end = next_cr;
		num_lines++;
		if (line_handler) {
			*end = '\0';
//			PARA_INFO_LOG("calling line handler: %s\n", start);
			line_handler(start);
		}
		start = ++end;
		bytes_left = buf + n - start;
	}
	if (!line_handler)
		return num_lines;
	if (bytes_left && bytes_left != n)
		memmove(buf, start, bytes_left);
	return bytes_left;
}