alight.c

/*
 * SPDX-License-Identifier: GPL-3.0-or-later
 * Copyright (C) 2026 Maika Namuo
 */

#include <dirent.h>
#include <err.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifndef SYSFS
#define SYSFS "/sys/class/backlight"
#endif

enum { NAME_LEN = 256, TYPE_LEN = 32, LINE_LEN = 64 };

struct light {
	char name[NAME_LEN], type[TYPE_LEN];
	long now, max;
};

static int fail(int error) {
	errno = error ? error : EIO;
	return -1;
}

static int usage(FILE *out, int code) {
	fputs("usage: alight [-d DEVICE] [N|+N|-N]\n"
	      "       alight -l\n"
	      "       alight -h\n", out);
	return code;
}

static long clamp(long value, long min, long max) {
	return value < min ? min : value > max ? max : value;
}

static long percent(long raw, long max) {
	return (long)((long double)clamp(raw, 0, max) * 100 / max + 0.5L);
}

static long raw_percent(long value, long max) {
	return max / 100 * value + (max % 100 * value + 50) / 100;
}

static long target_raw(const struct light *light, long adjustment,
                       char operation) {
	long max = light->max;
	long now = clamp(light->now, 0, max);
	long delta = raw_percent(adjustment < 0 ? -adjustment : adjustment, max);

	if (operation != '+' && operation != '-')
		return delta;
	if (adjustment > 0)
		return delta > max - now ? max : now + delta;
	return delta > now ? 0 : now - delta;
}

static int valid_name(const char *name) {
	return *name && strcmp(name, ".") && strcmp(name, "..") &&
	       strlen(name) < NAME_LEN && !strchr(name, '/');
}

static FILE *open_attr(const char *dev, const char *attr, const char *mode) {
	char path[sizeof SYSFS + NAME_LEN + sizeof "/max_brightness"];

	snprintf(path, sizeof path, "%s/%s/%s", SYSFS, dev, attr);
	return fopen(path, mode);
}

static int close_as(FILE *file, int error) {
	if (fclose(file) && !error)
		error = errno ? errno : EIO;
	return error ? fail(error) : 0;
}

static int read_attr(const char *dev, const char *attr, char *buf, int len) {
	FILE *file = open_attr(dev, attr, "r");
	char *newline;
	int error = 0;

	if (!file)
		return -1;
	errno = 0;
	if (!fgets(buf, len, file))
		error = ferror(file) ? (errno ? errno : EIO) : EINVAL;
	else if ((newline = strchr(buf, '\n')))
		*newline = 0;
	else if (!feof(file))
		error = ENAMETOOLONG;
	return close_as(file, error);
}

static int parse_number(const char *text, long *value) {
	char *end;

	errno = 0;
	if ((unsigned char)*text <= ' ')
		return fail(EINVAL);
	*value = strtol(text, &end, 10);
	return errno || end == text || *end ? fail(errno ? errno : EINVAL) : 0;
}

static int read_number(const char *dev, const char *attr, long *value) {
	char buf[LINE_LEN];

	if (read_attr(dev, attr, buf, sizeof buf) || parse_number(buf, value))
		return -1;
	return *value < 0 ? fail(EINVAL) : 0;
}

static int write_brightness(const char *dev, long value) {
	FILE *file = open_attr(dev, "brightness", "w");
	int error = 0;

	if (!file)
		return -1;
	errno = 0;
	if (fprintf(file, "%ld\n", value) < 0)
		error = errno ? errno : EIO;
	return close_as(file, error);
}

static int type_rank(const char *type) {
	return !strcmp(type, "firmware") ? 0 :
	       !strcmp(type, "platform") ? 1 : !strcmp(type, "raw") ? 2 : 3;
}

static int load_light(struct light *light, const char *name) {
	if (!valid_name(name))
		return fail(EINVAL);
	strcpy(light->name, name);
	if (read_number(name, "max_brightness", &light->max))
		return -1;
	if (light->max <= 0)
		return fail(EINVAL);
	if (read_number(name, "brightness", &light->now))
		return -1;
	if (read_attr(name, "type", light->type, sizeof light->type))
		strcpy(light->type, "unknown");
	return 0;
}

static int better_light(const struct light *a, const struct light *b) {
	int a_rank = type_rank(a->type), b_rank = type_rank(b->type);

	return a_rank < b_rank ||
	       (a_rank == b_rank && strcmp(a->name, b->name) < 0);
}

static void scan_lights(struct light *best) {
	DIR *dir = opendir(SYSFS);
	struct dirent *entry;
	struct light light;
	int found = 0;

	if (!dir)
		err(1, "%s", SYSFS);
	for (errno = 0; (entry = readdir(dir)); errno = 0) {
		if (load_light(&light, entry->d_name))
			continue;
		if (!best)
			printf("%s\t%ld%%\t%ld/%ld\t%s\n", light.name,
			       percent(light.now, light.max), light.now, light.max,
			       light.type);
		else if (!found || better_light(&light, best))
			*best = light;
		found = 1;
	}
	if (errno || closedir(dir))
		err(1, "%s", SYSFS);
	if (!found)
		errx(1, "no backlight in %s", SYSFS);
}

int main(int argc, char **argv) {
	struct light light;
	long adjustment = 0;
	const char *device = getenv("ALIGHT_DEVICE"), *value_arg = NULL;
	int list = 0, device_arg = 0;

	for (int i = 1; i < argc; i++) {
		const char *arg = argv[i];
		char option = *arg == '-' && arg[1] && !arg[2] ? arg[1] : 0;

		if (option == 'h')
			return usage(stdout, 0);
		if (option == 'l')
			list = 1;
		else if (option == 'd') {
			if (++i == argc)
				return usage(stderr, 2);
			device = argv[i];
			device_arg = 1;
		} else if (value_arg)
			return usage(stderr, 2);
		else
			value_arg = arg;
	}
	if (list) {
		if (value_arg || device_arg)
			return usage(stderr, 2);
		scan_lights(NULL);
		return 0;
	}
	if (value_arg && parse_number(value_arg, &adjustment))
		return usage(stderr, 2);
	adjustment = clamp(adjustment, -100, 100);
	if (!device_arg && (!device || !*device))
		scan_lights(&light);
	else if (load_light(&light, device))
		err(1, "%s", device);
	if (!value_arg)
		printf("%ld\n", percent(light.now, light.max));
	else if (write_brightness(
	             light.name, target_raw(&light, adjustment, *value_arg)))
		err(1, "%s/brightness", light.name);
	return 0;
}