event.c File Reference

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <dirent.h>
#include <ctype.h>
#include <regex.h>
#include <signal.h>
#include "acpid.h"

Go to the source code of this file.

Classes
struct	rule
struct	rule_list
Defines
#define	RULE_REGEX_FLAGS   (REG_EXTENDED | REG_ICASE | REG_NOSUB | REG_NEWLINE)
#define	NTRIES   100
Functions
static void	enlist_rule (struct rule_list *list, struct rule *r)
static void	delist_rule (struct rule_list *list, struct rule *r)
static struct rule *	new_rule (void)
static void	free_rule (struct rule *r)
static void	lock_rules (void)
static void	unlock_rules (void)
static sigset_t *	signals_handled (void)
static struct rule *	parse_file (const char *file)
static struct rule *	parse_client (int client)
static int	do_cmd_rule (struct rule *r, const char *event)
static int	do_client_rule (struct rule *r, const char *event)
static int	safe_write (int fd, const char *buf, int len)
static char *	parse_cmd (const char *cmd, const char *event)
static int	check_escapes (const char *str)
static int	path_is_dir (const char *path)
int	acpid_read_conf (const char *confdir)
int	acpid_cleanup_rules (void)
int	acpid_add_client (int clifd, const char *origin)
int	acpid_handle_event (const char *event)
Variables
static struct rule_list	cmd_list
static struct rule_list	client_list

---

Define Documentation

#define NTRIES   100

Definition at line 599 of file event.c. Referenced by safe_write().

#define RULE_REGEX_FLAGS   (REG_EXTENDED | REG_ICASE | REG_NOSUB | REG_NEWLINE)

Definition at line 41 of file event.c. Referenced by parse_client(), and parse_file().

---

Function Documentation

int acpid_add_client (  int  clifd, const char *  origin )

Definition at line 313 of file event.c. References acpid_log(), enlist_rule(), rule::origin, and parse_client(). Referenced by main(). { struct rule *r; int nrules = 0; acpid_log("client connected from %s\n", origin); r = parse_client(clifd); if (r) { r->origin = strdup(origin); enlist_rule(&client_list, r); nrules++; } acpid_log("%d client rule%s loaded\n", nrules, (nrules == 1)?"":"s"); return 0; }

int acpid_cleanup_rules (  void   )

Definition at line 157 of file event.c. References acpid_debug, acpid_log(), rule::action, delist_rule(), free_rule(), rule_list::head, lock_rules(), rule::next, and unlock_rules(). Referenced by clean_exit(), and reload_conf(). { struct rule *p; struct rule *next; lock_rules(); if (acpid_debug >= 3) { acpid_log("DBG: cleaning up rules\n"); } /* tell our clients to buzz off */ p = client_list.head; while (p) { next = p->next; delist_rule(&client_list, p); close(p->action.fd); free_rule(p); p = next; } /* clear out our conf rules */ p = cmd_list.head; while (p) { next = p->next; delist_rule(&cmd_list, p); free_rule(p); p = next; } unlock_rules(); return 0; }

int acpid_handle_event (  const char *  event  )

Definition at line 443 of file event.c. References acpid_debug, acpid_log(), do_client_rule(), do_cmd_rule(), rule::event, rule_list::head, lock_rules(), rule::next, rule::origin, rule::RULE_CLIENT, rule::RULE_CMD, rule::type, and unlock_rules(). Referenced by main(). { struct rule *p; int nrules = 0; struct rule_list *ar[] = { &client_list, &cmd_list, NULL }; struct rule_list **lp; /* make an event be atomic wrt known signals */ lock_rules(); /* scan each rule list for any rules that care about this event */ for (lp = ar; *lp; lp++) { struct rule_list *l = *lp; p = l->head; while (p) { /* the list can change underneath us */ struct rule *pnext = p->next; if (!regexec(p->event, event, 0, NULL, 0)) { /* a match! */ if (acpid_debug) { acpid_log("DBG: rule from %s matched\n", p->origin); } nrules++; if (p->type == RULE_CMD) { do_cmd_rule(p, event); } else if (p->type == RULE_CLIENT) { do_client_rule(p, event); } else { acpid_log("unknown rule type: %d\n", p->type); } } else { if (acpid_debug >= 3) { acpid_log("DBG: rule from %s did not " "match\n", p->origin); } } p = pnext; } } unlock_rules(); if (acpid_debug) { acpid_log("DBG: %d total rule%s matched\n", nrules, (nrules == 1)?"":"s"); } return 0; }

int acpid_read_conf (  const char *  confdir  )

Definition at line 99 of file event.c. References acpid_log(), enlist_rule(), lock_rules(), parse_file(), path_is_dir(), and unlock_rules(). Referenced by main(), and reload_conf(). { DIR *dir; struct dirent *dirent; char *file = NULL; int nrules = 0; lock_rules(); dir = opendir(confdir); if (!dir) { acpid_log("ERR: opendir(%s): %s\n", confdir, strerror(errno)); unlock_rules(); return -1; } /* scan all the files */ while ((dirent = readdir(dir))) { int len; struct rule *r; if (dirent->d_name[0] == '.') continue; /* skip dotfiles */ len = strlen(dirent->d_name) + strlen(confdir) + 2; file = (char *)malloc(len); if (!file) { acpid_log("ERR: malloc(): %s\n", strerror(errno)); unlock_rules(); return -1; } snprintf(file, len, "%s/%s", confdir, dirent->d_name); if (path_is_dir(file)) { free(file); continue; /* skip subdirs */ } r = parse_file(file); if (r) { enlist_rule(&cmd_list, r); nrules++; } free(file); } closedir(dir); unlock_rules(); acpid_log("%d rule%s loaded\n", nrules, (nrules == 1)?"":"s"); return 0; }

static int check_escapes (  const char *  str  )  [static]

Definition at line 669 of file event.c. References acpid_log(). Referenced by parse_file(). { const char *p; int r = 0; p = str; while (*p) { /* found an escape */ if (*p == '%') { p++; if (!*p) { acpid_log("invalid escape at EOL\n"); return -1; } else if (*p != '%' && *p != 'e') { acpid_log("invalid escape \"%%%c\"\n", *p); r = -1; } } p++; } return r; }

static void delist_rule (  struct rule_list *  list, struct rule *  r )  [static]

Definition at line 381 of file event.c. References rule_list::head, rule::next, rule::prev, and rule_list::tail. Referenced by acpid_cleanup_rules(), and do_client_rule(). { if (r->next) { r->next->prev = r->prev; } else { list->tail = r->prev; } if (r->prev) { r->prev->next = r->next; } else { list->head = r->next;; } r->next = r->prev = NULL; }

static int do_client_rule (  struct rule *  r, const char *  event )  [static]

Definition at line 580 of file event.c. References acpid_log(), rule::action, delist_rule(), rule::origin, and safe_write(). Referenced by acpid_handle_event(). { int r; int client = rule->action.fd; acpid_log("notifying client %s\n", rule->origin); r = safe_write(client, event, strlen(event)); if (r < 0 && errno == EPIPE) { /* closed */ acpid_log("client has disconnected\n"); delist_rule(&client_list, rule); return -1; } safe_write(client, "\n", 1); return 0; }

static int do_cmd_rule (  struct rule *  r, const char *  event )  [static]

Definition at line 533 of file event.c. References acpid_log(), rule::action, parse_cmd(), and signals_handled(). Referenced by acpid_handle_event(). { pid_t pid; int status; const char *action; pid = fork(); switch (pid) { case -1: acpid_log("ERR: fork(): %s\n", strerror(errno)); return -1; case 0: /* child */ /* parse the commandline, doing any substitutions needed */ action = parse_cmd(rule->action.cmd, event); acpid_log("executing action \"%s\"\n", action); /* reset signals */ signal(SIGHUP, SIG_DFL); signal(SIGTERM, SIG_DFL); signal(SIGINT, SIG_DFL); signal(SIGQUIT, SIG_DFL); signal(SIGPIPE, SIG_DFL); sigprocmask(SIG_UNBLOCK, signals_handled(), NULL); acpid_log("BEGIN HANDLER MESSAGES\n"); execl("/bin/sh", "/bin/sh", "-c", action, NULL); /* should not get here */ acpid_log("ERR: execl(): %s\n", strerror(errno)); exit(EXIT_FAILURE); } /* parent */ waitpid(pid, &status, 0); acpid_log("END HANDLER MESSAGES\n"); if (WIFEXITED(status)) { acpid_log("action exited with status %d\n", WEXITSTATUS(status)); } else if (WIFSIGNALED(status)) { acpid_log("action exited on signal %d\n", WTERMSIG(status)); } else { acpid_log("action exited with status %d\n", status); } return 0; }

static void enlist_rule (  struct rule_list *  list, struct rule *  r )  [static]

Definition at line 368 of file event.c. References rule_list::head, rule::next, rule::prev, and rule_list::tail. Referenced by acpid_add_client(), and acpid_read_conf(). { r->next = r->prev = NULL; if (!list->head) { list->head = list->tail = r; } else { list->tail->next = r; r->prev = list->tail; list->tail = r; } }

static void free_rule (  struct rule *  r  )  [static]

Definition at line 420 of file event.c. References rule::action, rule::event, rule::origin, rule::RULE_CMD, and rule::type. Referenced by acpid_cleanup_rules(), parse_client(), and parse_file(). { if (r->type == RULE_CMD) { if (r->action.cmd) { free(r->action.cmd); } } if (r->origin) { free(r->origin); } if (r->event) { regfree(r->event); free(r->event); } free(r); }

static void lock_rules (  void   )  [static]

Definition at line 511 of file event.c. References acpid_debug, acpid_log(), and signals_handled(). Referenced by acpid_cleanup_rules(), acpid_handle_event(), and acpid_read_conf(). { if (acpid_debug >= 4) { acpid_log("DBG: blocking signals for rule lock\n"); } sigprocmask(SIG_BLOCK, signals_handled(), NULL); }

static struct rule * new_rule (  void   )  [static]

Definition at line 399 of file event.c. References acpid_log(), and rule::RULE_NONE. Referenced by parse_client(), and parse_file(). { struct rule *r; r = malloc(sizeof(*r)); if (!r) { acpid_log("ERR: malloc(): %s\n", strerror(errno)); return NULL; } r->type = RULE_NONE; r->origin = NULL; r->event = NULL; r->action.cmd = NULL; r->prev = r->next = NULL; return r; }

static struct rule * parse_client (  int  client  )  [static]

Definition at line 333 of file event.c. References acpid_log(), rule::action, rule::event, free_rule(), new_rule(), rule::RULE_CLIENT, RULE_REGEX_FLAGS, and rule::type. Referenced by acpid_add_client(). { struct rule *r; int rv; /* make a new rule */ r = new_rule(); if (!r) { return NULL; } r->type = RULE_CLIENT; r->action.fd = client; r->event = malloc(sizeof(regex_t)); if (!r) { acpid_log("ERR: malloc(): %s\n", strerror(errno)); free_rule(r); return NULL; } rv = regcomp(r->event, ".*", RULE_REGEX_FLAGS); if (rv) { char buf[128]; regerror(rv, r->event, buf, sizeof(buf)); acpid_log("ERR: regcomp(): %s\n", buf); free_rule(r); return NULL; } return r; }

static char * parse_cmd (  const char *  cmd, const char *  event )  [static]

Definition at line 634 of file event.c. References acpid_debug, and acpid_log(). Referenced by do_cmd_rule(). { static char buf[4096]; int i; const char *p; p = cmd; i = 0; memset(buf, 0, sizeof(buf)); while (i < (sizeof(buf)-1)) { if (*p == '%') { p++; if (*p == 'e') { /* handle an event expansion */ int size = sizeof(buf) - i; size = snprintf(buf+i, size, "%s", event); i += size; p++; continue; } } if (!*p) { break; } buf[i++] = *p++; } if (acpid_debug >= 2) { acpid_log("DBG: expanded \"%s\" -> \"%s\"\n", cmd, buf); } return buf; }

static struct rule * parse_file (  const char *  file  )  [static]

Definition at line 193 of file event.c. References acpid_debug, acpid_log(), rule::action, check_escapes(), rule::event, free_rule(), new_rule(), rule::origin, rule::RULE_CMD, RULE_REGEX_FLAGS, and rule::type. Referenced by acpid_read_conf(). { FILE *fp; char buf[512]; int line = 0; struct rule *r; if (acpid_debug) { acpid_log("DBG: parsing conf file %s\n", file); } fp = fopen(file, "r"); if (!fp) { acpid_log("ERR: fopen(%s): %s\n", file, strerror(errno)); return NULL; } /* make a new rule */ r = new_rule(); if (!r) { fclose(fp); return NULL; } r->type = RULE_CMD; r->origin = strdup(file); if (!r->origin) { acpid_log("ERR: strdup(): %s\n", strerror(errno)); free_rule(r); fclose(fp); return NULL; } /* read each line */ while (!feof(fp)) { char *p = buf; char key[64]; char val[512]; int n; line++; memset(key, 0, sizeof(key)); memset(val, 0, sizeof(val)); if (fgets(buf, sizeof(buf)-1, fp) == NULL) { continue; } /* skip leading whitespace */ while (*p && isspace((int)*p)) { p++; } /* blank lines and comments get ignored */ if (!*p || *p == '#') { continue; } /* quick parse */ n = sscanf(p, "%63[^=\n]=%255[^\n]", key, val); if (n != 2) { acpid_log("can't parse %s at line %d\n", file, line); continue; } if (acpid_debug >= 3) { acpid_log("DBG: key=\"%s\" val=\"%s\"\n", key, val); } /* handle the parsed line */ if (!strcasecmp(key, "event")) { int rv; r->event = malloc(sizeof(regex_t)); if (!r) { acpid_log("ERR: malloc(): %s\n", strerror(errno)); free_rule(r); fclose(fp); return NULL; } rv = regcomp(r->event, val, RULE_REGEX_FLAGS); if (rv) { char buf[128]; regerror(rv, r->event, buf, sizeof(buf)); acpid_log("ERR: regcomp(): %s\n", buf); free_rule(r); fclose(fp); return NULL; } } else if (!strcasecmp(key, "action")) { if (check_escapes(val) < 0) { acpid_log("ERR: can't load file %s\n", file); free_rule(r); fclose(fp); return NULL; } r->action.cmd = strdup(val); if (!r->action.cmd) { acpid_log("ERR: strdup(): %s\n", strerror(errno)); free_rule(r); fclose(fp); return NULL; } } else { acpid_log("unknown option '%s' in %s at line %d\n", key, file, line); continue; } } if (!r->event || !r->action.cmd) { if (acpid_debug) { acpid_log("DBG: skipping incomplete file %s\n", file); } free_rule(r); return NULL; } fclose(fp); return r; }

static int path_is_dir (  const char *  path  )  [static]

Definition at line 84 of file event.c. References acpid_log(). Referenced by acpid_read_conf(). { struct stat s; if (stat(path, &s)) { acpid_log("ERR: stat(\"%s\"): %s\n", path, strerror(errno)); return 0; } return S_ISDIR(s.st_mode); }

static int safe_write (  int  fd, const char *  buf, int  len )  [static]

Definition at line 601 of file event.c. References acpid_debug, acpid_log(), and NTRIES. Referenced by do_client_rule(). { int r; int ttl = 0; int ntries = NTRIES; do { r = write(fd, buf+ttl, len-ttl); if (r < 0) { if (errno != EAGAIN && errno != EINTR) { /* a legit error */ return r; } ntries--; } else if (r > 0) { /* as long as we make forward progress, reset ntries */ ntries = NTRIES; ttl += r; } } while (ttl < len && ntries); if (!ntries) { /* crap */ if (acpid_debug >= 2) { acpid_log("uh-oh! safe_write() timed out\n"); } return r; } return ttl; }

static sigset_t * signals_handled (  void   )  [static]

Definition at line 497 of file event.c. Referenced by do_cmd_rule(), lock_rules(), and unlock_rules(). { static sigset_t sigset; sigemptyset(&sigset); sigaddset(&sigset, SIGHUP); sigaddset(&sigset, SIGTERM); sigaddset(&sigset, SIGQUIT); sigaddset(&sigset, SIGINT); return &sigset; }

static void unlock_rules (  void   )  [static]

Definition at line 520 of file event.c. References acpid_debug, acpid_log(), and signals_handled(). Referenced by acpid_cleanup_rules(), acpid_handle_event(), and acpid_read_conf(). { if (acpid_debug >= 4) { acpid_log("DBG: unblocking signals for rule lock\n"); } sigprocmask(SIG_UNBLOCK, signals_handled(), NULL); }

---

Variable Documentation

struct rule_list client_list [static]

Definition at line 62 of file event.c.

struct rule_list cmd_list [static]

Definition at line 61 of file event.c.

---

© sourcejam.com 2005-2008