Merge pull request #51 from troglobit/configure-with-udev

Add --with-udev[=PATH] to configure script, for non-SUID root operation

Makefile.am

 doc_DATA       = README.md LICENSE CHANGELOG
 EXTRA_DIST     = README.md LICENSE CHANGELOG
 
+if UDEV
+udev_DATA      = 90-backlight.rules
+EXTRA_DIST    += $(top_srcdir)/90-backlight.rules
+endif
+
 #
 # Target to run when building a release
 #

README.md

 
 ### Permissions
 
-**Optional:** Instead of SUID root you can set up udev rules to manage
-   sysfs permissions, you may skip the `make install` step and instead
-   copy the file `90-backlight.rules` to `/etc/udev/rules.d/`:
+Optionally, instead of the classic SUID root mode of operation, udev
+rules can be set up to manage the kernel sysfs permissions.  Use the
+configure script to enable this mode of operation:
 
+    ./configure --with-udev && make
+    sudo make install
+
+This installs the file `90-backlight.rules` into `/lib/udev/rules.d/`.
+If your udev rules are located elsewhere, use `--with-udev=PATH`.
 
-    ACTION=="add", SUBSYSTEM=="backlight", RUN+="/bin/chgrp video /sys/class/backlight/%k/brightness"
-    ACTION=="add", SUBSYSTEM=="backlight", RUN+="/bin/chmod g+w /sys/class/backlight/%k/brightness"
+Note, in this mode `light` runs unpriviliged, so the `/etc/light`
+directory (for cached settings) is not used, instead the per-user
+specific `~/.cache/light` is used.
 
 
 Origin & References

configure.ac

 AC_PROG_INSTALL
 AC_HEADER_STDC
 
+AC_ARG_WITH([udev],
+	AS_HELP_STRING([--with-udev@<:@=PATH@:>@], [use udev instead of SUID root, optional rules.d path]),
+	[udev=$withval], [udev=no])
+
+AC_MSG_CHECKING(for udev rules.d)
+AS_IF([test "x$udev" != "xno"], [
+	AS_IF([test "x$udev" = "xyes"], [
+		udevdir="\${prefix}/lib/udev/rules.d"
+	],[
+		udevdir="$udev"
+	])
+	AC_SUBST(udevdir)
+	AC_MSG_RESULT([$udevdir])
+],[
+	AC_MSG_RESULT([disabled, classic SUID root mode])
+])
+
+# Allow classic SUID root behavior if udev rule is not used
+AM_CONDITIONAL(UDEV,    [test "x$udev" != "xno"])
+AM_CONDITIONAL(CLASSIC, [test "x$udev"  = "xno"])
+
 AC_OUTPUT

src/Makefile.am

 bin_PROGRAMS   = light
 light_SOURCES  = main.c light.c light.h helpers.c helpers.h
-light_CPPFLAGS = -I../include -D_XOPEN_SOURCE=500
+light_CPPFLAGS = -I../include -D_GNU_SOURCE
 light_CFLAGS   = -W -Wall -Wextra -std=gnu99 -Wno-type-limits
 
+if CLASSIC
 install-exec-hook:
 	chmod 4755 $(DESTDIR)$(bindir)/light
+endif

src/helpers.h

 
 #define LIGHT_LOG(lvl, fp, fmt, args...)				\
 	if (light_loglevel >= lvl)					\
-		fprintf(fp, "%s:%d:" fmt, __FILE__, __LINE__, ##args)
+		fprintf(fp, "%s:%d:" fmt "\n", __FILE__, __LINE__, ##args)
 
 #define LIGHT_NOTE(fmt, args...) LIGHT_LOG(LIGHT_NOTE_LEVEL,  stdout, "NOTE:" fmt, ##args)
 #define LIGHT_WARN(fmt, args...) LIGHT_LOG(LIGHT_WARN_LEVEL,  stderr, "WARN:" fmt, ##args)

src/light.c

 #include "light.h"
 
+#include <libgen.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 	return true;
 }
 
+static int mkpath(char *dir, mode_t mode)
+{
+	struct stat sb;
+
+	if (!dir) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	if (!stat(dir, &sb))
+		return 0;
+
+	mkpath(dirname(strdupa(dir)), mode);
+
+	return mkdir(dir, mode);
+}
+
 bool light_initialize(int argc, char **argv)
 {
 	light_cmd_t mode;
 	int rc;
 
+	/* Classic SUID root mode or new user based cache files */
+	if (geteuid() == 0)
+		snprintf(ctx.prefix, sizeof(ctx.prefix), "%s", "/etc/light");
+	else
+		snprintf(ctx.prefix, sizeof(ctx.prefix), "%s/.cache/light", getenv("HOME"));
+
 	light_defaults();
 	if (!light_parse_args(argc, argv)) {
 		LIGHT_ERR("could not parse arguments");
 	if (mode == LIGHT_PRINT_HELP || mode == LIGHT_PRINT_VERSION || mode == LIGHT_LIST_CTRL)
 		return true;
 
+	/* Make sure we have a valid cache directory for all files */
 	if (mode == LIGHT_SAVE || (mode == LIGHT_SET && ctx.field == LIGHT_MIN_CAP)) {
-		/* Make sure we have a valid /etc/light directory, as well as mincap and save */
-		char const *const dirs[5] =
-		    { "/etc/light", "/etc/light/mincap", "/etc/light/save", "/etc/light/mincap/kbd",
-			"/etc/light/save/kbd"
+		const char *dirs[5] = {
+			"/mincap/kbd", "/save/kbd", NULL
 		};
-		char const *const *dir = dirs;
+		char path[strlen(ctx.prefix) + 20];
+		int i;
+
+		for (i = 0; dirs[i]; i++) {
+			snprintf(path, sizeof(path), "%s%s", ctx.prefix, dirs[i]);
 
-		while (dir < dirs + 5) {
-			rc = mkdir(*dir, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
+			rc = mkpath(path, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
 			if (rc && errno != EEXIST) {
 				LIGHT_ERR("'%s' does not exist and could not be created,"
-					  " make sure this application is run as root.", *dir);
+					  " make sure this application is run as root.", path);
 				return false;
 			}
-			++dir;
 		}
 	}
 
 			break;
 
 		case LIGHT_MIN_CAP:
-			val = snprintf(path, PATH_MAX, "/etc/light/mincap/%s", controller);
+			val = snprintf(path, PATH_MAX, "%s/mincap/%s", ctx.prefix, controller);
 			break;
 
 		case LIGHT_SAVERESTORE:
-			val = snprintf(path, PATH_MAX, "/etc/light/save/%s", controller);
+			val = snprintf(path, PATH_MAX, "%s/save/%s", ctx.prefix, controller);
 			break;
 		}
 	} else {
 			break;
 
 		case LIGHT_MIN_CAP:
-			val = snprintf(path, PATH_MAX, "/etc/light/mincap/kbd/%s", controller);
+			val = snprintf(path, PATH_MAX, "%s/mincap/kbd/%s", ctx.prefix, controller);
 			break;
 
 		case LIGHT_SAVERESTORE:
-			val = snprintf(path, PATH_MAX, "/etc/light/save/kbd/%s", controller);
+			val = snprintf(path, PATH_MAX, "%s/save/kbd/%s", ctx.prefix, controller);
 			break;
 		}
 	}
 		if (!light_ctrl_get_brightness_maxPath(controller, &path))
 			return false;
 		if (!light_file_is_readable(path)) {
-			LIGHT_WARN
-			    ("could not open controller max brightness file for reading, so controller is not accessible");
+			LIGHT_WARN("could not open controller max brightness "
+				   "file for reading, so controller is not accessible");
 			free(path);
 			return false;
 		}
 	if (!light_ctrl_get_brightnessPath(controller, &path))
 		return false;
 
-	if (ctx.cmd != LIGHT_GET &&
+	if (ctx.cmd != LIGHT_GET && ctx.cmd != LIGHT_SAVE &&
 	    ctx.field != LIGHT_MIN_CAP && !light_file_is_writable(path)) {
 		LIGHT_WARN("could not open controller brightness file for writing, so controller is not accessible");
 		free(path);
 		return false;
 	}
 
-	LIGHT_NOTE("saving brightness %lu (raw) to save file\n", val);
+	LIGHT_NOTE("saving brightness %lu (raw) to save file %s\n", val, path);
 	if (!light_file_write_val(path, val)) {
 		LIGHT_ERR("could not write to save/restore file");
 		free(path);
 		return false;
 	}
 
-	LIGHT_NOTE("restoring brightness from saved file");
+	LIGHT_NOTE("restoring brightness from saved file %s", path);
 	if (!light_file_read_val(path, &val)) {
 		LIGHT_ERR("could not read saved value");
 		free(path);

src/light.h

 } light_val_mode_t;
 
 typedef struct {
+	/* Cache file prefix */
+	char               prefix[NAME_MAX + 1];
+
 	/* Which controller to use */
-	light_ctrl_mode_t ctrl;
-	char              ctrl_name[NAME_MAX + 1];
+	light_ctrl_mode_t  ctrl;
+	char               ctrl_name[NAME_MAX + 1];
 
 	/* What to do with the controller */
 	light_cmd_t        cmd;