/* Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
#include <assert.h>
#include <libudev.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <regex.h>
#include <syslog.h>

#include "cras_system_state.h"
#include "cras_types.h"
#include "cras_util.h"
#include "cras_checksum.h"

struct udev_callback_data {
	struct udev_monitor *mon;
	struct udev *udev;
	int fd;
};

static unsigned is_action(const char *desired, const char *actual)
	__attribute__((nonnull(1)));

/* Matches Alsa sound device entries generated by udev.  For
 * example:
 *
 *   /devices/pci0000:00/0000:00:1b.0/sound/card1/pcmC1D0p
 *
 * We want to be able to extract:
 *
 *   o The card number
 *   o The device number
 *   o If it's 'playback' (p) or 'capture' (c). (It may not be both.)
 *
 * Given the example above, the following matches should occur:
 *
 *
 *   |                        A                           |
 *                                                   BBCCCD
 *   /devices/pci0000:00/0000:00:1b.0/sound/card1/pcmC1D10p
 *
 * A: The whole regex will be matched.
 * B: The card.
 * C: The device.
 * D: 'p' (playback) or 'c' (capture)
 *
 * The order of the offsets in the 'pmatch' buffer does not appear
 * to match with the documentation:
 *
 *     Each rm_so element that is not -1 indicates the start
 *     offset of the next largest substring match within the
 *     string.
 *
 * But are, instead, filled in the same order presented in the
 * string.  To alleviate possible issudes, the 'C' (card) and 'D'
 * (device) identifying characters are included in the result.
 */
static const char pcm_regex_string[] = "^.*pcm(C[0-9]+)(D[0-9]+)([pc])";
static regex_t pcm_regex;

/* Card regex is similar to above, but only has one field -- the card. The
 * format is the same with the exception of the leaf node being of the form:
 *
 *  /devices/...../card0
 *
 * Where 0 is the card number and the only thing we care about in
 * this case.
 */

static const char card_regex_string[] = "^.*/card([0-9]+)";
static regex_t card_regex;

static char const *const subsystem = "sound";
static const unsigned int MAX_DESC_NAME_LEN = 256;

static unsigned is_action(const char *desired, const char *actual)
{
	return actual != NULL && strcmp(desired, actual) == 0;
}

static unsigned is_action_change(const char *action)
{
	return is_action("change", action);
}

static unsigned is_action_remove(const char *action)
{
	return is_action("remove", action);
}

static unsigned is_internal_bus(const char *bus)
{
	return (bus != NULL &&
		(strcmp(bus, "pci") == 0 || strcmp(bus, "platform") == 0));
}

static unsigned is_external_bus(const char *bus)
{
	return (bus != NULL && (strcmp(bus, "usb") == 0));
}

static unsigned is_internal_device(struct udev_device *dev)
{
	struct udev_device *parent = udev_device_get_parent(dev);
	while (parent != NULL) {
		const char *name = udev_device_get_subsystem(parent);

		if (name != NULL) {
			if (is_external_bus(name))
				return 0;
			else if (is_internal_bus(name))
				return 1;
		}
		parent = udev_device_get_parent(parent);
	}
	return 0;
}

static unsigned is_card_device(struct udev_device *dev, unsigned *internal,
			       unsigned *card_number, const char **sysname)
{
	regmatch_t m[2];
	const char *devpath = udev_device_get_devpath(dev);

	if (devpath != NULL &&
	    regexec(&card_regex, devpath, ARRAY_SIZE(m), m, 0) == 0) {
		*sysname = udev_device_get_sysname(dev);
		*internal = is_internal_device(dev);
		*card_number = (unsigned)atoi(&devpath[m[1].rm_so]);
		return 1;
	}

	return 0;
}

static void set_factory_default(unsigned card_number)
{
	static const char alsactl[] = "/usr/sbin/alsactl";
	static const char asound_state[] = "/etc/asound.state";
	char cmd_buf[128];
	struct stat stat_buf;
	int r;

	if (stat(asound_state, &stat_buf) == 0) {
		syslog(LOG_INFO, "%s: init card '%u' to factory default",
		       __FUNCTION__, card_number);
		r = snprintf(cmd_buf, ARRAY_SIZE(cmd_buf),
			     "%s --file %s restore %u", alsactl, asound_state,
			     card_number);
		cmd_buf[ARRAY_SIZE(cmd_buf) - 1] = '\0';
		r = system(cmd_buf);
		if (r != 0)
			syslog(LOG_ERR,
			       "%s: failed to init card '%d' "
			       "to factory default.  Failure: %d.  Command: %s",
			       __FUNCTION__, card_number, r, cmd_buf);
	}
}

static inline void udev_delay_for_alsa()
{
	/* Provide a small delay so that the udev message can
	 * propogate throughout the whole system, and Alsa can set up
	 * the new device.  Without a small delay, an error of the
	 * form:
	 *
	 *    Fail opening control hw:?
	 *
	 * will be produced by cras_alsa_card_create().
	 */
	usleep(125000); /* 0.125 second */
}

/* Reads the "descriptors" file of the usb device and returns the
 * checksum of the contents. Returns 0 if the file can not be read */
static uint32_t calculate_desc_checksum(struct udev_device *dev)
{
	char path[MAX_DESC_NAME_LEN];
	struct stat stat_buf;
	int fd;
	unsigned char *buf = NULL;
	int buf_size = 0;
	int read_size;
	ssize_t n;
	uint32_t result;

	if (snprintf(path, sizeof(path), "%s/descriptors",
		     udev_device_get_syspath(dev)) >= sizeof(path)) {
		syslog(LOG_ERR, "failed to build path");
		return 0;
	}

	if (stat(path, &stat_buf) < 0) {
		syslog(LOG_ERR, "failed to stat file %s: %s", path,
		       strerror(errno));
		return 0;
	}

	fd = open(path, O_RDONLY);
	if (fd < 0) {
		syslog(LOG_ERR, "failed to open file %s: %s", path,
		       strerror(errno));
		return 0;
	}

	read_size = 0;
	while (read_size < stat_buf.st_size) {
		if (read_size == buf_size) {
			if (buf_size == 0)
				buf_size = 256;
			else
				buf_size *= 2;
			uint8_t *new_buf = realloc(buf, buf_size);
			if (new_buf == NULL) {
				syslog(LOG_ERR, "no memory to read file %s",
				       path);
				goto bail;
			}
			buf = new_buf;
		}
		n = read(fd, buf + read_size, buf_size - read_size);
		if (n == 0)
			break;
		if (n < 0) {
			syslog(LOG_ERR, "failed to read file %s", path);
			goto bail;
		}
		read_size += n;
	}

	close(fd);
	result = crc32_checksum(buf, read_size);
	free(buf);
	return result;
bail:
	close(fd);
	free(buf);
	return 0;
}

static void fill_usb_card_info(struct cras_alsa_card_info *card_info,
			       struct udev_device *dev)
{
	const char *sysattr;
	struct udev_device *parent_dev =
		udev_device_get_parent_with_subsystem_devtype(dev, "usb",
							      "usb_device");
	if (!parent_dev)
		return;

	sysattr = udev_device_get_sysattr_value(parent_dev, "idVendor");
	if (sysattr)
		card_info->usb_vendor_id = strtol(sysattr, NULL, 16);
	sysattr = udev_device_get_sysattr_value(parent_dev, "idProduct");
	if (sysattr)
		card_info->usb_product_id = strtol(sysattr, NULL, 16);
	sysattr = udev_device_get_sysattr_value(parent_dev, "serial");
	if (sysattr) {
		strncpy(card_info->usb_serial_number, sysattr,
			USB_SERIAL_NUMBER_BUFFER_SIZE - 1);
		card_info->usb_serial_number[USB_SERIAL_NUMBER_BUFFER_SIZE - 1] =
			'\0';
	}

	card_info->usb_desc_checksum = calculate_desc_checksum(parent_dev);

	syslog(LOG_INFO,
	       "USB card: vendor:%04x, product:%04x, serial num:%s, "
	       "checksum:%08x",
	       card_info->usb_vendor_id, card_info->usb_product_id,
	       card_info->usb_serial_number, card_info->usb_desc_checksum);
}

static void device_add_alsa(struct udev_device *dev, const char *sysname,
			    unsigned card, unsigned internal)
{
	struct cras_alsa_card_info card_info;
	memset(&card_info, 0, sizeof(card_info));

	udev_delay_for_alsa();
	card_info.card_index = card;
	if (internal) {
		card_info.card_type = ALSA_CARD_TYPE_INTERNAL;
	} else {
		card_info.card_type = ALSA_CARD_TYPE_USB;
		fill_usb_card_info(&card_info, dev);
	}

	cras_system_add_alsa_card(&card_info);
}

void device_remove_alsa(const char *sysname, unsigned card)
{
	udev_delay_for_alsa();
	cras_system_remove_alsa_card(card);
}

static int udev_sound_initialized(struct udev_device *dev)
{
	/* udev will set SOUND_INITALIZED=1 for the main card node when the
	 * system has already been initialized, i.e. when cras is restarted
	 * on an already running system.
	 */
	const char *s;

	s = udev_device_get_property_value(dev, "SOUND_INITIALIZED");
	if (s)
		return 1;

	return 0;
}

static void change_udev_device_if_alsa_device(struct udev_device *dev)
{
	/* If the device, 'dev' is an alsa device, add it to the set of
	 * devices available for I/O.  Mark it as the active device.
	 */
	unsigned internal;
	unsigned card_number;
	const char *sysname;

	if (is_card_device(dev, &internal, &card_number, &sysname) &&
	    udev_sound_initialized(dev) &&
	    !cras_system_alsa_card_exists(card_number)) {
		if (internal)
			set_factory_default(card_number);
		device_add_alsa(dev, sysname, card_number, internal);
	}
}

static void remove_device_if_card(struct udev_device *dev)
{
	unsigned internal;
	unsigned card_number;
	const char *sysname;

	if (is_card_device(dev, &internal, &card_number, &sysname))
		device_remove_alsa(sysname, card_number);
}

static void enumerate_devices(struct udev_callback_data *data)
{
	struct udev_enumerate *enumerate = udev_enumerate_new(data->udev);
	struct udev_list_entry *dl;
	struct udev_list_entry *dev_list_entry;

	udev_enumerate_add_match_subsystem(enumerate, subsystem);
	udev_enumerate_scan_devices(enumerate);
	dl = udev_enumerate_get_list_entry(enumerate);

	udev_list_entry_foreach(dev_list_entry, dl)
	{
		const char *path = udev_list_entry_get_name(dev_list_entry);
		struct udev_device *dev =
			udev_device_new_from_syspath(data->udev, path);

		change_udev_device_if_alsa_device(dev);
		udev_device_unref(dev);
	}
	udev_enumerate_unref(enumerate);
}

static void udev_sound_subsystem_callback(void *arg, int revents)
{
	struct udev_callback_data *data = (struct udev_callback_data *)arg;
	struct udev_device *dev;

	dev = udev_monitor_receive_device(data->mon);
	if (dev) {
		const char *action = udev_device_get_action(dev);

		if (is_action_change(action))
			change_udev_device_if_alsa_device(dev);
		else if (is_action_remove(action))
			remove_device_if_card(dev);
		udev_device_unref(dev);
	} else
		syslog(LOG_WARNING,
		       "%s (internal error): "
		       "No device obtained",
		       __FUNCTION__);
}

static void compile_regex(regex_t *regex, const char *str)
{
	int r = regcomp(regex, str, REG_EXTENDED);
	assert(r == 0);
}

static struct udev_callback_data udev_data;
void cras_udev_start_sound_subsystem_monitor()
{
	int r;

	udev_data.udev = udev_new();
	assert(udev_data.udev != NULL);
	udev_data.mon = udev_monitor_new_from_netlink(udev_data.udev, "udev");

	udev_monitor_filter_add_match_subsystem_devtype(udev_data.mon,
							subsystem, NULL);
	udev_monitor_enable_receiving(udev_data.mon);
	udev_data.fd = udev_monitor_get_fd(udev_data.mon);

	r = cras_system_add_select_fd(udev_data.fd,
				      udev_sound_subsystem_callback, &udev_data,
				      POLLIN);
	assert(r == 0);
	compile_regex(&pcm_regex, pcm_regex_string);
	compile_regex(&card_regex, card_regex_string);

	enumerate_devices(&udev_data);
}

void cras_udev_stop_sound_subsystem_monitor()
{
	udev_unref(udev_data.udev);
	regfree(&pcm_regex);
	regfree(&card_regex);
}