proc.c

/*
 *  proc.c - ACPI daemon proc filesystem interface
 *
 *  Portions Copyright (C) 2000 Andrew Henroid
 *  Portions Copyright (C) 2001 Sun Microsystems
 *  Portions Copyright (C) 2004 Tim Hockin (thockin@hockin.org)
 *
 *  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 <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#include "acpid.h"
#include "log.h"
#include "event.h"
#include "connection_list.h"
#include "libc_compat.h"

#include "proc.h"

const char *eventfile = ACPID_EVENTFILE;

static char *read_line(int fd);

static void
process_proc(int fd)
{
	char *event;

	/* read an event */
	event = read_line(fd);

	/* if we're locked, don't process the event */
	if (locked()) {
		if (logevents  &&  event != NULL) {
			acpid_log(LOG_INFO,
				"lockfile present, not processing "
				"event \"%s\"", event);
		}
		return;
	}

	/* handle the event */
	if (event) {
		if (logevents) {
			acpid_log(LOG_INFO,
			          "procfs received event \"%s\"", event);
		}
		acpid_handle_event(event);
		if (logevents) {
			acpid_log(LOG_INFO,
				"procfs completed event \"%s\"", event);
		}
	} else if (errno == EPIPE) {
		acpid_log(LOG_WARNING,
			"events file connection closed");
		exit(EXIT_FAILURE);
	} else {
		static int nerrs;
		if (++nerrs >= ACPID_MAX_ERRS) {
			acpid_log(LOG_ERR,
				"too many errors reading "
				"events file - aborting");
			exit(EXIT_FAILURE);
		}
	}
}

int
open_proc()
{
	int fd;
	struct connection c;
	
	/* O_CLOEXEC: Make sure scripts we exec() (in event.c) don't get our file 
       descriptors. */
	fd = open(eventfile, O_RDONLY | O_CLOEXEC);
	if (fd < 0) {
		if (errno == ENOENT) {
			acpid_log(LOG_DEBUG, "Deprecated %s was not found.  "
				"Trying netlink and the input layer...", eventfile);
		} else {
			acpid_log(LOG_ERR, "can't open %s: %s (%d)", eventfile, 
				strerror(errno), errno);
		}
		return -1;
		
	}
	acpid_log(LOG_DEBUG, "proc fs opened successfully");

	/* add a connection to the list */
	c.fd = fd;
	c.process = process_proc;
	c.pathname = NULL;
	c.kybd = 0;

	if (add_connection(&c) < 0) {
		close(fd);
		acpid_log(LOG_ERR, "can't add connection for %s", eventfile);
		return -1;
	}

	return 0;
}

/*
 * This depends on fixes in linux ACPI after 2.4.8
 */
#define BUFLEN 1024
static char *
read_line(int fd)
{
	static char buf[BUFLEN];
	int i = 0;
	int r;
	int searching = 1;

	while (searching) {
		memset(buf+i, 0, BUFLEN-i);

		/* only go to BUFLEN-1 so there will always be a 0 at the end */
		while (i < BUFLEN-1) {
			r = TEMP_FAILURE_RETRY(read(fd, buf+i, 1));
			if (r < 0) {
				/* we should do something with the data */
				acpid_log(LOG_ERR, "read(): %s",
					strerror(errno));
				return NULL;
			} else if (r == 0) {
				/* signal this in an almost standard way */
				errno = EPIPE;
				return NULL;
			} else if (r == 1) {
				/* scan for a newline */
				if (buf[i] == '\n') {
					searching = 0;
					buf[i] = '\0';
					break;
				}
				i++;
			}
		}
		if (i >= BUFLEN - 1)
			break;
	}

	return buf;
}

#if 0
/* This version leaks memory.  The above version is simpler and leak-free. */
/* Downside is that the above version always uses 1k of RAM. */
/*
 * This depends on fixes in linux ACPI after 2.4.8
 */
#define MAX_BUFLEN	1024
static char *
read_line(int fd)
{
	static char *buf;
	int buflen = 64;
	int i = 0;
	int r;
	int searching = 1;

	while (searching) {
		/* ??? This memory is leaked since it is never freed */
		buf = realloc(buf, buflen);
		if (!buf) {
			acpid_log(LOG_ERR, "malloc(%d): %s",
				buflen, strerror(errno));
			return NULL;
		}
		memset(buf+i, 0, buflen-i);

		while (i < buflen) {
			r = read(fd, buf+i, 1);
			if (r < 0 && errno != EINTR) {
				/* we should do something with the data */
				acpid_log(LOG_ERR, "read(): %s",
					strerror(errno));
				return NULL;
			} else if (r == 0) {
				/* signal this in an almost standard way */
				errno = EPIPE;
				return NULL;
			} else if (r == 1) {
				/* scan for a newline */
				if (buf[i] == '\n') {
					searching = 0;
					buf[i] = '\0';
					break;
				}
				i++;
			}
		}
		if (buflen >= MAX_BUFLEN) {
			break;
		} 
		buflen *= 2;
	}

	return buf;
}
#endif