autocd/autocd-3.02.12b/auto_cd.c

/*
 * Copyright (c) 2002, 2003 MATPOCKuH.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/types.h>
#include <sys/cdio.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/wait.h>
#include <sys/param.h>
#include <sys/ucred.h>
#include <sys/mount.h>
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <fstab.h>
#include <unistd.h>
#include <pwd.h>
#include <grp.h>
#include <signal.h>
#include <stdarg.h>
#include <ctype.h>
#include <sysexits.h>

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#ifdef HAVE_SYS_CDRIO_H
#include <sys/cdrio.h>
#endif

#include "settings.h"
#include "mqueue.h"
#include "logger.h"
#include "acd.h"
#include "version.h"

#define autocd_opendev(_dev) (_dev->dev = _dev->dev == -1 ?\
    open(_dev->device, O_RDONLY) : _dev->dev)

typedef struct {
    void *next;
    void *prev;
    char *device, *mnt_point, *mnt_fstype, *mnt_opts;
    int dev, ejected, disabled;
#ifdef HAVE_SYS_CDRIO_H
    int locked_speed;
#endif
    int first_audio_track, last_audio_track;
    u_int cdid;
    struct cd_sub_channel_info sub_channel_info;
    struct ioc_toc_header toc_header;
    struct cd_toc_entry toc_entry[MAXTRACKS];
    struct ioc_read_subchannel read_subchannel;
    struct ioc_read_toc_entry read_toc_entry;
    struct ioc_play_msf play_msf;
} device_t;

typedef struct {
    void *next;
    void *prev;
    int fd;
    device_t *device;
} client_t;

typedef struct {
    void *next;
    void *prev;
    u_int cdid;
    struct ioc_play_msf play_msf;
} saved_msf_t;

typedef int handler_t(client_t *);
typedef int handler_wp_t(client_t *, char *);

int autocd_close(client_t *);
int autocd_cdid(client_t *);
int autocd_disable(client_t *);
int autocd_die(client_t *);
int autocd_eject(client_t *);
int autocd_enable(client_t *);
int autocd_help(client_t *);
int autocd_info(client_t *);
int autocd_listdevices(client_t *);
int autocd_listsaved(client_t *);
int autocd_load(client_t *);
int autocd_next(client_t *);
int autocd_play(client_t *);
int autocd_pause(client_t *);
int autocd_previous(client_t *);
int autocd_closeclient(client_t *);
int autocd_stat(client_t *);
int autocd_save(client_t *);
int autocd_stop(client_t *);
int autocd_version(client_t *);
int autocd_volume(client_t *);
int autocd_changedevice(client_t *, char *);
int autocd_play_with_params(client_t *, char *);
#ifdef HAVE_SYS_CDRIO_H
int autocd_speed(client_t *, char *);
int autocd_lockspeed(client_t *, char *);
#endif
int autocd_changevolume(client_t *, char *);

struct {
    char *cmd, *params;
    handler_t *handler;
    int need_opendev;
    int need_disc;
    int need_play;
} cmds[] = {
    {"Close", NULL, &autocd_close, 1, 0, 0},
    {"CDid", NULL, &autocd_cdid, 0, 1, 0},
    {"Disable", NULL, &autocd_disable, 0, 0, 0},
    {"DIE", NULL, &autocd_die, 0, 0, 0},
    {"Eject", NULL, &autocd_eject, 0, 0, 0},
    {"Enable", NULL, &autocd_enable, 0, 0, 0},
    {"Help", NULL, &autocd_help, 0, 0, 0},
    {"Info", NULL, &autocd_info, 0, 1, 0},
    {"List", NULL, &autocd_listdevices, 0, 0, 0},
    {"LISTSaved", NULL, &autocd_listsaved, 0, 0, 0},
    {"LOad", NULL, &autocd_load, 1, 1, 0},
    {"Next", NULL, &autocd_next, 1, 1, 1},
    {"Play", NULL, &autocd_play, 1, 1, 0},
    {"PAuse", NULL, &autocd_pause, 1, 1, 1},
    {"PRevious", NULL, &autocd_previous, 1, 1, 1},
    {"Quit", NULL, &autocd_closeclient, 0, 0, 0},
    {"Status", NULL, &autocd_stat, 0, 0, 0},
    {"SAve", NULL, &autocd_save, 0, 1, 1},
    {"STOp", NULL, &autocd_stop, 1, 1, 1},
    {"Version", NULL, &autocd_version, 0, 0, 0},
    {"VOlume", NULL, &autocd_volume, 1, 0, 0},
    {"Device", "device", (handler_t *) &autocd_changedevice, 0, 0, 0},
#ifdef HAVE_SYS_CDRIO_H
    {"Lockspeed", "speed", (handler_t *) &autocd_lockspeed, 0, 0, 0},
#endif
    {"Play", "first_track [last_track]",
	(handler_t *) &autocd_play_with_params, 1, 1, 0},
#ifdef HAVE_SYS_CDRIO_H
    {"Speed", "speed", (handler_t *) &autocd_speed, 1, 0, 0},
#endif
    {"Volume", "[+|-]volume", (handler_t *) &autocd_changevolume, 1, 0, 0},
    {NULL, NULL, NULL, 0, 0, 0}
};

mq_queue_t *devices, *clients, *saved_msfs;
fd_set read_fds;

uid_t socket_owner = SOCKET_OWNER;
gid_t socket_group = SOCKET_GROUP;
mode_t socket_mode = SOCKET_MODE;
int socket_fd, dont_close_while_playing = 0;

char *audio_status[] =
    {"invalid",
	NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
	NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
	"playing", "paused", "completed",
	"error", "no status"};

static volatile sig_atomic_t nobreak = 1;

/*
 * dbprog_sum
 *      Convert an integer to its text string representation, and
 *      compute its checksum.  Used by dbprog_discid to derive the
 *      disc ID.
 *
 * Args:
 *      n - The integer value.
 *
 * Return:
 *      The integer checksum.
 */
int
dbprog_sum(int n)
{
    char buf[12], *p;
    int ret = 0;

    /* For backward compatibility this algorithm must not change */
    sprintf(buf, "%u", n);
    for (p = buf; *p != '\0'; p++)
	ret += (*p - '0');

    return(ret);
}

/*
 * dbprog_discid
 *      Compute a magic disc ID based on the number of tracks,
 *      the length of each track, and a checksum of the string
 *      that represents the offset of each track.
 *
 * Args:
 *      s - Pointer to the curstat_t structure.
 *
 * Return:
 *      The integer disc ID.
 */
u_int
dbprog_discid(device_t *device)
{
    int i, ntr, t = 0, n = 0;

    ntr = device->toc_header.ending_track -
	device->toc_header.starting_track + 1;

    /* For backward compatibility this algorithm must not change */
    for (i = 0; i < ntr; i++) {
#define TC_MM(a) device->toc_entry[a].addr.msf.minute
#define TC_SS(a) device->toc_entry[a].addr.msf.second
	n += dbprog_sum((TC_MM(i) * 60) + TC_SS(i));

	t += ((TC_MM(i+1) * 60) + TC_SS(i+1)) - ((TC_MM(i) * 60) + TC_SS(i));
    }

    return((n % 0xff) << 24 | t << 8 | ntr);
}

void
autocd_init()
{
    devices = mq_makequeue(sizeof(device_t));
    clients = mq_makequeue(sizeof(client_t));
    saved_msfs = mq_makequeue(sizeof(saved_msf_t));
    FD_ZERO(&read_fds);
}

void
autocd_setsocketpath(const char *spath)
{
    if(socket_path != SOCKET_PATH)
	free(socket_path);

    socket_path = strdup(spath);
}

int
autocd_setsocketowner(const char *owner)
{
    if(sscanf(owner, "%i", &socket_owner) == 0) {
	struct passwd *passwd;

	if(!(passwd = getpwnam(owner))) {
	    logger("Failed to get uid for %s: %s\n", owner, strerror(errno));
	    return -1;
	}

	socket_owner = passwd->pw_uid;

	endpwent();
    }

    return 0;
}

int
autocd_setsocketgroup(const char *group)
{
    if(sscanf(group, "%i", &socket_group) == 0) {
	struct group *gr;

	if(!(gr = getgrnam(group))) {
	    logger("Failed to get gid for %s: %s\n", group, strerror(errno));
	    return -1;
	}

	socket_group = gr->gr_gid;

	endgrent();
    }

    return 0;
}

int
autocd_setsocketmode(const char *mode)
{
    unsigned int tmp;

    sscanf(mode, "%o", &tmp);
    socket_mode = tmp;

    return 0;
}

int
autocd_initdevice(char *device)
{
    device_t *tmp;
    struct stat st;
    char *dev;

    if(device[0] != '/')
	asprintf(&dev, "/dev/%s", device);
    else
	dev = strdup(device);

    if(stat(dev, &st) == -1) {
	logger("Failed to use device %s: %s\n", dev, strerror(errno));
	free(dev);
	return -1;
    }

    if(!(st.st_mode & S_IFBLK) && !(st.st_mode & S_IFCHR)) {
	logger("%s is not a character or block special file\n", dev);
	free(dev);
	return -1;
    }

    tmp = malloc(sizeof(device_t));
    bzero(tmp, sizeof(*tmp));

    tmp->read_subchannel.address_format = CD_MSF_FORMAT;
    tmp->read_subchannel.data_format = CD_CURRENT_POSITION;
    tmp->read_subchannel.data_len = sizeof(struct cd_sub_channel_info);
    tmp->read_subchannel.data = &tmp->sub_channel_info;

    tmp->read_toc_entry.address_format = CD_MSF_FORMAT;
    tmp->read_toc_entry.starting_track = 1;
    tmp->read_toc_entry.data_len = sizeof(tmp->toc_entry);
    tmp->read_toc_entry.data = tmp->toc_entry;

    if((tmp->dev = open(dev, O_RDONLY)) == -1) {
	if((errno != ENXIO) && (errno != EIO) && (errno != ENODEV)) {
	    logger("Failed to open device %s: %s\n", dev, strerror(errno));
	    free(dev);
	    free(tmp);
	    return -1;
	}
    } else {
	if(ioctl(tmp->dev, CDIOCREADSUBCHANNEL, &tmp->read_subchannel) == -1) {
	    if((errno != EBUSY) && (errno != EIO) && (errno != ENXIO)) {
		logger("Failed to use device %s: %s\n", dev, strerror(errno));
		free(dev);
		free(tmp);
		return -1;
	    }
	}

	close(tmp->dev);
	tmp->dev = -1;
    }

    if(geteuid()) {
	logger("Not running from root. Automount disabled for %s.\n", dev);
	tmp->mnt_point = NULL;
    } else {
	struct fstab *fstab;

	if(!(fstab = getfsspec(dev))) {
	    tmp->mnt_point = NULL;
	    tmp->mnt_fstype = FSTYPE;
	   tmp->mnt_opts = MNTOPTS;
	} else {
	    tmp->mnt_point = strdup(fstab->fs_file);
	    tmp->mnt_fstype = strdup(fstab->fs_vfstype);
	    tmp->mnt_opts = strdup(fstab->fs_mntops);
	}

	endfsent();
    }

    tmp->device = dev;
    tmp->ejected = 1;
    tmp->disabled = 0;

#ifdef HAVE_SYS_CDRIO_H
    tmp->locked_speed = 0;
#endif

    mq_addrecord(devices, (mq_record_t *) tmp);

    return 0;
}

int
autocd_noclose()
{
    dont_close_while_playing = 1;

    return 0;
}

int
autocd_set_mnt_point(const char *mnt_point)
{
    device_t *d;

    if(geteuid()) {
	logger("Not running from root. Mount is not avaible.\n");
	return -1;
    }

    if(!(d = (device_t *) mq_gettail(devices))) {
	logger("Strange call autocd_set_mnt_point()\n");
	return -1;
    }

    if(d->mnt_point)
	free(d->mnt_point);

    d->mnt_point = strdup(mnt_point);

    return 0;
}

int
autocd_set_mnt_fstype(const char *mnt_fstype)
{
    device_t *d;

    if(!(d = (device_t *) mq_gettail(devices))) {
	logger("Strange call autocd_set_mnt_fstype()\n");
	return -1;
    }

    if(!d->mnt_point) {
	logger("No mount point for %s. fstype ignored.\n", d->device);
	return -1;
    }

    if(d->mnt_fstype != FSTYPE)
	free(d->mnt_fstype);

    d->mnt_fstype = strdup(mnt_fstype);

    return 0;
}

int
autocd_set_mnt_opts(const char *mnt_opts)
{
    device_t *d;

    if(!(d = (device_t *) mq_gettail(devices))) {
	logger("Strange call autocd_set_mnt_opts()\n");
	return -1;
    }

    if(!d->mnt_point) {
	logger("No mount point for %s. Mount options ignored.\n", d->device);
	return -1;
    }

    if(d->mnt_opts != MNTOPTS)
	free(d->mnt_opts);

    d->mnt_opts = strdup(mnt_opts);

    return 0;
}

int
autocd_initsocket()
{
    struct sockaddr_un unix_addr;
    struct stat st;
    int fd;

    if(stat(socket_path, &st)) {
	if(errno != ENOENT) {
	    logger("Failed to create socket: %s\n", strerror(errno));
	    return -1;
	}
    } else {
	if((st.st_mode & S_IFSOCK) != S_IFSOCK) {
	    logger("Failed to create socket: %s is not socket\n", socket_path);
	    return -1;
	}

	if((fd = acd_connect()) == -1) {
	    if(errno != ECONNREFUSED) {
		logger("Failed to connect to another daemon: %s\n",
		    strerror(errno));
		return -1;
	    }
	} else {
	    logger("Found running copy of daemon\n");
	    close(fd);
	    return -1;
	}

	if(unlink(socket_path) == -1) {
	    logger("Failed to remove stale socket: %s\n", strerror(errno));
	    return -1;
	}

	logger("Removed stale socket.\n");
    }

    if((socket_fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
	return -1;

    memset(&unix_addr, 0, sizeof(unix_addr));
    unix_addr.sun_family = AF_UNIX;
    strncpy(unix_addr.sun_path, socket_path, sizeof(unix_addr.sun_path));
    unix_addr.sun_len = sizeof(unix_addr.sun_len) +
	sizeof(unix_addr.sun_family) + strlen(unix_addr.sun_path) + 1;

    if(bind(socket_fd, (struct sockaddr *) &unix_addr, unix_addr.sun_len) < 0) {
	logger("Failed to create socket: %s\n", strerror(errno));
	close(socket_fd);
	unlink(socket_path);
	return -1;
    }

    if(listen(socket_fd, 5) < 0) {
	logger("Failed to create socket: %s\n", strerror(errno));
	close(socket_fd);
	unlink(socket_path);
	return -1;
    }

    if(!geteuid()) {
	chown(socket_path, socket_owner, socket_group);
    }

    chmod(socket_path, socket_mode);

    FD_SET(socket_fd, &read_fds);

    return 0;
}

void
autocd_accept()
{
    int fd;
    client_t *client;
    struct sockaddr_un unix_addr;
    size_t len;

    len = sizeof(unix_addr);
    if ((fd = accept(socket_fd, (struct sockaddr *) &unix_addr, &len)) < 0) {
	logger("accept() failed: %s\n", strerror(errno));
	return;
    }

    client = (client_t *) mq_addnewrecord(clients);
    client->fd = fd;
    client->device = (device_t *) mq_gethead(devices);

    FD_SET(fd, &read_fds);
}

int
autocd_play_msf(device_t *device)
{
    if(ioctl(device->dev, CDIOCPLAYMSF, &device->play_msf) == -1) {
	logger("CDIOCPLAYMSF failed: %s\n", strerror(errno));
	return -1;
    }

    device->sub_channel_info.header.audio_status = CD_AS_PLAY_IN_PROGRESS;

    return 0;
}

int
autocd_playtracks(device_t *device, int ftrack, int ltrack)
{
    union msf_lba *msf_lba;

    msf_lba = &device->toc_entry[ftrack - 1].addr;
    device->play_msf.start_m = msf_lba->msf.minute;
    device->play_msf.start_s = msf_lba->msf.second;
    device->play_msf.start_f = msf_lba->msf.frame;

    msf_lba = &device->toc_entry[ltrack].addr;
    device->play_msf.end_m = msf_lba->msf.minute;
    device->play_msf.end_s = msf_lba->msf.second;
    device->play_msf.end_f = msf_lba->msf.frame;

    return autocd_play_msf(device);
}

void
autocd_closedev(device_t *device)
{
    if(device->dev == -1)
	return;

    if(dont_close_while_playing &&
	((device->sub_channel_info.header.audio_status ==
	    CD_AS_PLAY_IN_PROGRESS) ||
	(device->sub_channel_info.header.audio_status == CD_AS_PLAY_PAUSED)))
	return;

    close(device->dev);
    device->dev = -1;
}

void
autocd_doinsert(device_t *device)
{
    device->read_toc_entry.data_len =
	(device->toc_header.ending_track + 1) * sizeof(struct cd_toc_entry);

    if(ioctl(device->dev, CDIOREADTOCENTRYS, &device->read_toc_entry) == -1) {
	logger("CDIOREADTOCENTRYS failed: %s\n", strerror(errno));
	return;
    }

    for(device->first_audio_track = 1;
	(device->toc_entry[device->first_audio_track - 1].control & 4) &&
	(device->first_audio_track < device->toc_header.ending_track);
	device->first_audio_track++);

    for(device->last_audio_track = device->toc_header.ending_track;
	(device->toc_entry[device->last_audio_track - 1].control & 4) &&
	(device->first_audio_track < device->last_audio_track);
	device->last_audio_track--);

    if(device->toc_entry[device->first_audio_track - 1].control & 4) {
	if(device->mnt_point) {
	    int status;

	    autocd_closedev(device);

	    switch(fork()) {
	    case 0:
		execl(MOUNT, MOUNT, "-o", device->mnt_opts,
		    "-t", device->mnt_fstype,
		    device->device, device->mnt_point, NULL);


		logger("Can't run "MOUNT": %s\n", strerror(errno));

		exit(EX_OSERR);

	    case -1:
		logger("fork() failed: %s\n", strerror(errno));
		break;

	    default:
		wait(&status);
	    }

	    autocd_opendev(device);
	}
    } else {
	if(device->sub_channel_info.header.audio_status !=
	    CD_AS_PLAY_IN_PROGRESS) {
	    autocd_playtracks(device,
		device->first_audio_track, device->last_audio_track);
	}
    }

    device->cdid = dbprog_discid(device);

#ifdef HAVE_SYS_CDRIO_H
    if(device->locked_speed != 0)
	if(ioctl(device->dev, CDRIOCREADSPEED, &device->locked_speed) == -1)
	    device->locked_speed = 0;
#endif

}

void
autocd_checkdevice(device_t *dev)
{
    if(dev->disabled)
	return;

    if(autocd_opendev(dev) == -1) {
	dev->ejected = 1;
	return;
    }

    if(ioctl(dev->dev, CDIOCREADSUBCHANNEL, &dev->read_subchannel) == -1) {
	dev->ejected = 1;
    } else {
	if(ioctl(dev->dev, CDIOREADTOCHEADER, &dev->toc_header) == -1) {
	    dev->ejected = 1;
	} else {
	    if(dev->ejected) {
		dev->ejected = 0;
		bzero(&dev->play_msf, sizeof(dev->play_msf));
		autocd_doinsert(dev);
	    }
	}
    }

    autocd_closedev(dev);
}

void
autocd_vcprintf(client_t *client, char *fmt, va_list ap)
{
    char *buf;

    vasprintf(&buf, fmt, ap);
    write(client->fd, buf, strlen(buf));
    free(buf);
}

void
autocd_cprintf(client_t *client, char *fmt, ...)
{
    va_list ap;

    va_start(ap, fmt);
    autocd_vcprintf(client, fmt, ap);
    va_end(ap);
}

void
autocd_ERROR(client_t *client, char *fmt, ...)
{
    va_list ap;

    va_start(ap, fmt);
    vlogger(fmt, ap);
    autocd_vcprintf(client, fmt, ap);
    va_end(ap);
}

int
autocd_eject(client_t *client)
{
    device_t *device = client->device;
    int rc = 0;

    if(!geteuid()) {
	int i, size;
	struct statfs *fs;

	size = sizeof(struct statfs) * (i = getfsstat(NULL, 0, MNT_NOWAIT));
	fs = malloc(size);
	getfsstat(fs, size, MNT_NOWAIT);

	for(; i; i--) {
	    if(!strcmp(device->device, fs[i - 1].f_mntfromname)) {
		if(unmount(fs[i - 1].f_mntonname, 0) == -1) {
		    autocd_ERROR(client, "ERROR: unmount() failed: %s\n",
			strerror(errno));
		    return -2;
		}
		break;
	    }
	}

	free(fs);
    }

    if(autocd_opendev(client->device) == -1)
	return -1;

    if(ioctl(device->dev, CDIOCALLOW) == -1)
	logger("ioctl(CDIOCALLOW) failed: %s\n", strerror(errno));

    if(ioctl(device->dev, CDIOCEJECT) == -1) {
	autocd_ERROR(client, "ERROR: ioctl(CDIOCEJECT) failed: %s\n",
	    strerror(errno));
	rc = -2;
    }

    autocd_closedev(client->device);

    return rc;
}

int
autocd_pause(client_t *client)
{
    device_t *device = client->device;
    int rcode = 0;

    switch(device->sub_channel_info.header.audio_status) {
    case CD_AS_PLAY_IN_PROGRESS:
	rcode = ioctl(device->dev, CDIOCPAUSE);
	break;

    case CD_AS_PLAY_PAUSED:
	rcode = ioctl(device->dev, CDIOCRESUME);
	break;
    }

    if(rcode == -1)
	return -1;

    return 0;
}

int
autocd_stop(client_t *client)
{
    device_t *device = client->device;

    if(ioctl(device->dev, CDIOCSTOP) == -1)
	return -1;

    return 0;
}

int
autocd_close(client_t *client)
{
    device_t *device = client->device;

    if(ioctl(device->dev, CDIOCALLOW) == -1)
	logger("ioctl(CDIOCALLOW) failed: %s\n", strerror(errno));

    if(ioctl(device->dev, CDIOCCLOSE) == -1)
	return -1;

    return 0;
}

int
autocd_stat(client_t *client)
{
    struct cd_sub_channel_info *s_ch_info = &client->device->sub_channel_info;
    u_char audiostatus = s_ch_info->header.audio_status;

    if(client->device->disabled) {
	autocd_cprintf(client, "Device disabled\n");
	return 0;
    }

    if(client->device->ejected) {
	autocd_cprintf(client, "No current status info available\n");
	return 0;
    }

    autocd_cprintf(client,
	"Audio status = %i<%s>, current track = %i,\
 current position = %i:%02i.%02i\n",
	audiostatus,
	audiostatus <= CD_AS_NO_STATUS ? audio_status[audiostatus] : NULL,
	s_ch_info->what.position.track_number,
	s_ch_info->what.position.reladdr.msf.minute,
	s_ch_info->what.position.reladdr.msf.second,
	s_ch_info->what.position.reladdr.msf.frame);

    return 0;
}

int
autocd_info(client_t *client)
{
    device_t *dev = client->device;
    int i, ftrack, ltrack;
    int trackb, tracke, len;
    char slen[11], blen[9], stype[8];

    autocd_cprintf(client,
	"Starting track = %i, ending track = %i, TOC size = %i bytes\n\
track     start  duration   block  length   type\n\
-------------------------------------------------\n",
	ftrack = dev->toc_header.starting_track,
	ltrack = dev->toc_header.ending_track, dev->toc_header.len);

    trackb = tracke = 75 * (60 * dev->toc_entry[0].addr.msf.minute +
	dev->toc_entry[0].addr.msf.second) +
	dev->toc_entry[0].addr.msf.frame;

    for(i = 0; i <= ltrack; i++) {
	if(dev->toc_entry[i].track != MAXTRACKS) {
	    len = (tracke = 75 * (60 * dev->toc_entry[i + 1].addr.msf.minute +
		dev->toc_entry[i + 1].addr.msf.second) +
		dev->toc_entry[i + 1].addr.msf.frame) - trackb;
	    snprintf(slen, sizeof(slen), "%4i:%02i.%02i",
		len / (75 * 60), (len / 75) % 60, len % 75);
	    snprintf(blen, sizeof(blen), "%8i", len);
	    snprintf(stype, sizeof(stype), "%7s",
		(dev->toc_entry[i].control & 4) ? "data" : "audio");
	} else {
	    snprintf(slen, sizeof(slen), "%10s", "-");
	    snprintf(blen, sizeof(blen), "%8s", "-");
	    snprintf(stype, sizeof(stype), "%7s", "-");
	}

	autocd_cprintf(client,
	    "%5i%4i:%02i.%02i%s%8i%s%s\n",
	    dev->toc_entry[i].track,
	    dev->toc_entry[i].addr.msf.minute,
	    dev->toc_entry[i].addr.msf.second,
	    dev->toc_entry[i].addr.msf.frame,
	    slen, trackb - 2 * 75, blen, stype);

	trackb = tracke;
    }

    return 0;
}

int
autocd_play(client_t *client)
{
    device_t *device = client->device;

    if(autocd_playtracks(device,
	device->first_audio_track, device->last_audio_track) == -1)
	return -1;

    return 0;
}

int
autocd_next(client_t *client)
{
    device_t *device = client->device;
    u_char track;

    if((track = device->sub_channel_info.what.position.track_number) >=
	device->last_audio_track) {
	autocd_cprintf(client, "ERROR: this is last track\n");
	return -2;
    }

    device->play_msf.start_m = device->toc_entry[track].addr.msf.minute;
    device->play_msf.start_s = device->toc_entry[track].addr.msf.second;
    device->play_msf.start_f = device->toc_entry[track].addr.msf.frame;

    if(autocd_play_msf(device) == -1)
	return -1;

    return 0;
}

int
autocd_previous(client_t *client)
{
    device_t *device = client->device;
    int track;

    if((track = device->sub_channel_info.what.position.track_number - 2) <
	(device->first_audio_track - 1)) {
	autocd_cprintf(client, "ERROR: this is first track\n");
	return -2;
    }

    device->play_msf.start_m = device->toc_entry[track].addr.msf.minute;
    device->play_msf.start_s = device->toc_entry[track].addr.msf.second;
    device->play_msf.start_f = device->toc_entry[track].addr.msf.frame;

    if(autocd_play_msf(device) == -1)
	return -1;

    return 0;
}

int
autocd_play_with_params(client_t *client, char *params)
{
    device_t *device = client->device;
    int ftrack, ltrack;
    char *param2;

    if(!isdigit(params[0])) {
	autocd_cprintf(client, "ERROR: invalid parameters for play\n");
	return -2;
    }

    if((param2 = strchr(params, ' '))) {
	param2++[0] = 0;
	sscanf(param2, "%i", &ltrack);
    } else
	ltrack = device->last_audio_track;

    sscanf(params, "%i", &ftrack);

    if(autocd_playtracks(device, ftrack, ltrack) == -1)
	return -1;

    return 0;
}

int
autocd_volume(client_t *client)
{
    device_t *device = client->device;
    struct ioc_vol volume;

    if(ioctl(device->dev, CDIOCGETVOL, &volume) == -1)
	return -1;

    autocd_cprintf(client, "Left volume = %i, right volume = %i\n",
	volume.vol[0], volume.vol[1]);

    return 0;
}

int
autocd_changevolume(client_t *client, char *params)
{
    device_t *device = client->device;
    struct ioc_vol volume;
    char *s;

    if(params[0] != '+' && params[0] != '-') {
	if((s = strchr(params, ':')) == NULL) {
	    volume.vol[0] = volume.vol[1] = atoi(params);
	} else {
	    s[0] = 0;
	    volume.vol[0] = atoi(params);
	    volume.vol[1] = atoi(++s);
	}
    } else {
	int offset[2];

	if(ioctl(device->dev, CDIOCGETVOL, &volume) == -1)
	    return -1;

	if((s = strchr(params, ':')) == NULL) {
	    offset[0] = offset[1] = atoi(params);
	} else {
	    s[0] = 0;
	    offset[0] = atoi(params);
	    offset[1] = atoi(++s);
	}

	if((offset[0] + (int)volume.vol[0]) > 255)
	    offset[0] = 255 - volume.vol[0];

	if((offset[0] + (int)volume.vol[0]) < 0)
	    offset[0] = - (int)volume.vol[0];

	if((offset[1] + (int)volume.vol[1]) > 255)
	    offset[1] = 255 - volume.vol[1];

	if((offset[1] + (int)volume.vol[1]) < 0)
	    offset[1] = - (int)volume.vol[1];

	volume.vol[0] += offset[0];
	volume.vol[1] += offset[1];
    }

    if(ioctl(device->dev, CDIOCSETVOL, &volume) == -1)
	return -1;

    return 0;
}

#ifdef HAVE_SYS_CDRIO_H
int
autocd_speed(client_t *client, char *params)
{
    device_t *device = client->device;
    int speed;

    speed = atoi(params);

    if(speed <= 0)
	speed = CDR_MAX_SPEED;

    if(ioctl(device->dev, CDRIOCREADSPEED, &speed) == -1)
	return -1;

    return 0;
}

int
autocd_lockspeed(client_t *client, char *params)
{
    device_t *device = client->device;
    int speed;

    speed = atoi(params);

    if(speed <= 0 || speed > CDR_MAX_SPEED)
	speed = CDR_MAX_SPEED;

    device->locked_speed = speed == CDR_MAX_SPEED ? 0 : speed;

    if(!device->ejected)
	if(autocd_opendev(device) != -1) {
	    if(ioctl(device->dev, CDRIOCREADSPEED, &speed) == -1) {
		autocd_closedev(device);
		device->locked_speed = 0;
		return -1;
	    }
	    autocd_closedev(device);
	}

    return 0;
}
#endif

int
autocd_listdevices(client_t *client)
{
    device_t *device;
    int i;

    for(device = (device_t *)mq_gethead(devices), i = 0; device;
	device = device->next, i++) {
	autocd_cprintf(client, "%i %s\n", i, device->device);
    }

    return 0;
}

int
autocd_listsaved(client_t *client)
{
    saved_msf_t *msf;

    autocd_cprintf(client, "cdid\t\tposition\n");

    for(mq_resetcurrent(saved_msfs);
	(msf = (saved_msf_t *) mq_nextrecord(saved_msfs));) {
	autocd_cprintf(client, "%08x\t%2i:%02i.%02i - %2i:%02i.%02i\n",
	    msf->cdid, msf->play_msf.start_m, msf->play_msf.start_s,
	    msf->play_msf.start_f, msf->play_msf.end_m, msf->play_msf.end_s,
	    msf->play_msf.end_f);
    }

    return 0;
}

int
autocd_changedevice(client_t *client, char *dev)
{
    int i;
    device_t *device = NULL;

    if(sscanf(dev, "%i", &i) == 0) {
	for(device = (device_t *)mq_gethead(devices);
	    device; device = device->next)
	    if(!strcmp(device->device, dev))
		break;
    } else {
	for(device = (device_t *)mq_gethead(devices);
	    device && i; i--, device = device->next);
    }

    if(!device) {
	autocd_ERROR(client, "ERROR: no such device: %s\n", dev);
	return -2;
    }

    client->device = device;

    return 0;
}

int
autocd_cdid(client_t *client)
{
    autocd_cprintf(client, "%08x\n", client->device->cdid);

    return 0;
}

int
autocd_disable(client_t *client)
{
    client->device->disabled = 1;

    return 0;
}

int
autocd_enable(client_t *client)
{
    client->device->disabled = 0;

    return 0;
}

int
autocd_die(client_t *client)
{
    uid_t my_euid, client_euid;
    gid_t client_egid;

    if(getpeereid(client->fd, &client_euid, &client_egid) < 0)
	return -1;

    my_euid = geteuid();

    if((client_euid != 0) && (client_euid != my_euid)) {
	autocd_ERROR(client, "ERROR: permission denied\n");
	return -2;
    }

    nobreak = 0;

    return 0;
}

int
autocd_help(client_t *client)
{
    int i;

    for(i = 0; cmds[i].cmd; i++) {
	if(cmds[i].params)
	    autocd_cprintf(client, "%s %s\n", cmds[i].cmd, cmds[i].params);
	else
	    autocd_cprintf(client, "%s\n", cmds[i].cmd);
    }

    return 0;
}

int
autocd_version(client_t *client)
{
    autocd_cprintf(client, "%s\n", ver_getversionstring());

    return 0;
}

int
autocd_save(client_t *client)
{
    device_t *device = client->device;
    saved_msf_t *msf;

    for(mq_resetcurrent(saved_msfs);
	(msf = (saved_msf_t *) mq_nextrecord(saved_msfs));) {
	if(device->cdid == msf->cdid)
	    break;
    }

    if(!msf)
	msf = (saved_msf_t *)mq_addnewrecord(saved_msfs);

    msf->play_msf.start_m =
	device->sub_channel_info.what.position.absaddr.msf.minute;
    msf->play_msf.start_s =
	device->sub_channel_info.what.position.absaddr.msf.second;
    msf->play_msf.start_f =
	device->sub_channel_info.what.position.absaddr.msf.frame;
    msf->cdid = device->cdid;

    msf->play_msf.end_m = device->play_msf.end_m;
    msf->play_msf.end_s = device->play_msf.end_s;
    msf->play_msf.end_f = device->play_msf.end_f;

    return 0;
}

int
autocd_load(client_t *client)
{
    device_t *device = client->device;
    saved_msf_t *msf;

    for(mq_resetcurrent(saved_msfs);
	(msf = (saved_msf_t *) mq_nextrecord(saved_msfs));) {
	if(device->cdid == msf->cdid) {
	    device->play_msf = msf->play_msf;

	    mq_removecurrent(saved_msfs);

	    if(autocd_play_msf(device) == -1)
		return -1;

	    return 0;
	}
    }

    autocd_ERROR(client, "ERROR: no saved position for cdid = %u\n",
	device->cdid);
    return -2;
}

int
autocd_closeclient(client_t *client)
{
    int fd;

    if(((client_t *) mq_getcurrent(clients)) != client) {
	logger("Strange autocd_closeclient() call\n");
	return -1;
    }

    fd = client->fd;
    FD_CLR(fd, &read_fds);
    close(fd);

    mq_removecurrent(clients);

    return -2;
}

void
autocd_execmd(char *cmd)
{
    client_t *client;
    char *params;
    int slen, i;

    client = (client_t *)mq_getcurrent(clients);

    slen = strlen(cmd);

    if((params = strchr(cmd, ' '))) {
	params[0] = 0;
	slen = params++ - cmd;
    }

    for(i = 0; cmds[i].cmd; i++) {
	if(!strncasecmp(cmd, cmds[i].cmd, slen)) {
	    int rcode;

	    if((params == NULL) != (cmds[i].params == NULL))
		continue;

	    if(cmds[i].need_disc) {
		if(client->device->ejected) {
		    autocd_cprintf(client, "ERROR: no disc in drive\n");
		    return;
		}

		if(cmds[i].need_play) {
		    u_char audio_status =
			client->device->sub_channel_info.header.audio_status;

		    if(audio_status != CD_AS_PLAY_IN_PROGRESS &&
			audio_status != CD_AS_PLAY_PAUSED) {
			autocd_cprintf(client,
			    "ERROR: no playing in progress\n");
			return;
		    }
		}
	    }

	    if(cmds[i].need_opendev) {
		if(autocd_opendev(client->device) == -1) {
		    autocd_cprintf(client, "ERROR: %s\n", strerror(errno));
		    return;
		}
	    }

	    if(params) {
		handler_wp_t *handler = (handler_wp_t *)(*cmds[i].handler);
		rcode = (*handler)(client, params);
	    } else {
		rcode = (*cmds[i].handler)(client);
	    }

	    switch(rcode) {
	    case -1:
		autocd_cprintf(client, "ERROR: %s\n", strerror(errno));
		break;

	    case 0:
		autocd_cprintf(client, "OK\n");
		break;
	    }

	    if(cmds[i].need_opendev)
		autocd_closedev(client->device);

	    return;
	}
    }

    autocd_ERROR(client, "ERROR: unknown command: %s\n", cmd);
}

void
autocd_serveclient()
{
    client_t *client;
    int i, begin, len, fd;
    char buf[BUFSIZE];

    fd = (client = (client_t *) mq_getcurrent(clients))->fd;

    if(!(len = read(fd, buf, sizeof(buf) - sizeof(char)))) {
	autocd_closeclient(client);
	return;
    }

    while((len > 0) && ((buf[len - 1] == 13) || (buf[len - 1] == 10)))
	len--;
    buf[len] = 0;

    if(!len)
	return;

    for(begin = i = 0; i < len; i++) {
	if((buf[i] == 13) || (buf[i] == 10)) {
	    buf[i] = 0;
	    autocd_execmd(buf + begin);

	    for(i++; (i < len) && ((buf[i] == 13) || (buf[i] == 10)); i++);

	    begin = i;
	}
    }

    if(begin != i)
	autocd_execmd(buf + begin);
}

void
autocd_loop()
{
    device_t *dev;
    fd_set fds;
    struct timeval tv = {1, 0};
    client_t *client;

    for(mq_resetcurrent(devices);
    (dev = (device_t *) mq_nextrecord(devices));) {
	autocd_checkdevice(dev);

	if(dev->sub_channel_info.header.audio_status ==
	    CD_AS_PLAY_IN_PROGRESS) {
		union msf_lba *msf_lba;

		msf_lba = &dev->toc_entry[dev->first_audio_track].addr;
		dev->play_msf.start_m = msf_lba->msf.minute;
		dev->play_msf.start_s = msf_lba->msf.second;
		dev->play_msf.start_f = msf_lba->msf.frame;

		msf_lba = &dev->toc_entry[dev->last_audio_track].addr;
		dev->play_msf.end_m = msf_lba->msf.minute;
		dev->play_msf.end_s = msf_lba->msf.second;
		dev->play_msf.end_f = msf_lba->msf.frame;
	}
    }

    while(nobreak) {
	int rcode;

	fds = read_fds;

	if((rcode = select(FD_SETSIZE, &fds, NULL, NULL, &tv)) < 0) {
	    if(errno != EINTR) {
		logger("select() failed: %s\n", strerror(errno));
		break;
	    }
	    rcode = 0;
	}

	for(mq_resetcurrent(devices);
	    (dev = (device_t *) mq_nextrecord(devices));)
	    autocd_checkdevice(dev);

	if(rcode == 0)
	    continue;

	if(FD_ISSET(socket_fd, &fds)) {
	    autocd_accept();
	}

	for(mq_resetcurrent(clients);
	    (client = (client_t *) mq_nextrecord(clients));) {
	    if(FD_ISSET(client->fd, &fds)) {
		autocd_serveclient();
	    }
	}
    }

    close(socket_fd);
    unlink(socket_path);

    for(mq_resetcurrent(clients);
	(client = (client_t *) mq_nextrecord(clients));)
	autocd_closeclient(client);

    exit(EX_OK);
}

void
sigterm_handler()
{
    nobreak = 0;
}

int
autocd_daemon()
{
    if(daemon(0, 1) == -1) {
	logger("daemon() failed: %s\n", strerror(errno));
	return -1;
    }

    set_daemon_mode("autocd");

    signal(SIGHUP, SIG_IGN);
    signal(SIGTERM, &sigterm_handler);
    signal(SIGINT, &sigterm_handler);

    autocd_loop();

    return 0;
}