keventd: add udev rules engine

Transform keventd from a power-supply monitor + basic hotplug handler into
a full udev-compatible device manager.

Rules engine (rules.c):
- Full .rules file parser covering all udev key types: ACTION, KERNEL,
  SUBSYSTEM, DEVPATH, ENV, ATTR, SYSCTL, TAG, RESULT, PROGRAM, TEST,
  parent-chain KERNELS/SUBSYSTEMS/ATTRS/DRIVERS, and more
- Pattern matching: plain string, fnmatch glob, and pipe-separated alternatives
- Operators: ==, !=, =, +=, -=, :=
- Assignments: NAME=, MODE=, OWNER=, GROUP=, SYMLINK+=, ENV{k}=, TAG+=, RUN+=
- IMPORT{program|file|builtin|parent|cmdline|db}=
- PROGRAM= with stdout capture for subsequent RESULT== matching
- GOTO=/LABEL= flow control
- Loads *.rules from /lib/udev/rules.d, /run/udev/rules.d, /etc/udev/rules.d
  and an optional extra directory (-r DIR); reloads on SIGHUP

Builtin framework (builtin.c):
- kmod:     load module by MODALIAS or explicit alias
- hwdb:     match device against *.hwdb text files in udev hwdb dirs; builds
	    correct lookup key per subsystem — evdev:input:b*v*p*e* for input,
	    usb:v*p* for USB, raw modalias for PCI/platform
- path_id:  build stable ID_PATH / ID_PATH_TAG from sysfs topology (PCI, USB,
	    ATA, NVMe, platform, ACPI, virtio)
- usb_id:   read idVendor/idProduct/bcdDevice/serial from sysfs; look up
	    ID_VENDOR_FROM_DATABASE and ID_MODEL_FROM_DATABASE from usb.ids
	    (hwdata package) when available; silent fallback when absent
- input_id: classify input devices (keyboard, mouse, joystick, touchscreen,
	    touchpad) from evdev capability bitmasks in sysfs
- net_id:   generate predictable names — MAC-based enx<mac> and PCI-slot-based
	    enp<bus>s<dev>[f<func>]
- blkid:    probe filesystem type, UUID, and label via libblkid; sets ID_FS_*
	    and ID_PART_TABLE_* properties

Network interface renaming (uevent.c):
- netdev_add() renames interfaces via SIOCSIFNAME when a NAME= rule matched,
  then sets the Finit dev/ condition on the final name; and any setup using
  persistent interface naming via udev rules

Device node and symlink improvements (uevent.c):
- NAME=, MODE=, OWNER=, GROUP= overrides from matched rules applied at
  mknod/chown time, falling back to the built-in permission table
- SYMLINK+= links from rules applied alongside built-in by-id/by-path links

Device property database (udevdb.c):
- Persist per-device E:/S:/I: records to /run/udev/data/ on ADD/CHANGE,
  delete on REMOVE; IMPORT{db}= restores saved properties into event env

Build:
- libblkid (util-linux) is now required for keventd

Signed-off-by: Joachim Wiberg <troglobit@gmail.com>

keventd/keventd.h

@@ -29,11 +29,29 @@
 #else
 # include <lite/queue.h>	/* BSD sys/queue.h API */
 #endif
+#include <stdint.h>
+#include <stdio.h>
 #include <sys/types.h>
 
 /* Maximum uevent buffer size (kernel uses 8192 internally) */
 #define UEVENT_BUFFER_SIZE  8192
 
+/* Capacity of the generic env store on struct uevent */
+#define UEVENT_ENV_MAX  64
+
+/* Maximum TAG+= entries per device event */
+#define UEVENT_TAG_MAX  16
+
+/* Maximum SYMLINK+= and RUN+= entries set by the rules engine */
+#define RULE_SYMLINK_MAX  8
+#define RULE_RUN_MAX      8
+
+/* RUN{type} subtypes — also used in struct rule_ctx below */
+typedef enum {
+	RUN_PROGRAM = 0,	/* execute external program */
+	RUN_BUILTIN,		/* call builtin function */
+} run_type_t;
+
 /* Uevent actions from kernel */
 typedef enum {
 	ACT_UNKNOWN = 0,
@@ -47,9 +65,36 @@ typedef enum {
 	ACT_UNBIND,
 } uevent_action_t;
 
+/*
+ * Rule-applied permissions and context, set by the rules engine.
+ * Zero-initialised means "nothing set by rules", fall back to built-in table.
+ */
+struct rule_ctx {
+	/* Device permissions */
+	mode_t  mode;
+	uid_t   uid;
+	gid_t   gid;
+	int     has_mode;
+	int     has_owner;
+	int     has_group;
+	int     final_mode;		/* := operator locks against further overrides */
+	int     final_owner;
+	int     final_group;
+	/* NAME= override for device node path (heap-allocated) */
+	char   *name;
+	/* SYMLINK+= accumulator (heap-allocated strings) */
+	int     nsymlinks;
+	char   *symlinks[RULE_SYMLINK_MAX];
+	/* RUN+= command list (heap-allocated strings, executed post-event) */
+	int     nruncmds;
+	char   *run_cmds[RULE_RUN_MAX];
+	run_type_t run_types[RULE_RUN_MAX];
+};
+
 /*
  * Parsed uevent structure.
- * Pointers are into the receive buffer, zero-copy.
+ * Named field pointers point into the receive buffer (zero-copy).
+ * The env store holds all KEY=VALUE pairs plus any rule-set variables.
  */
 struct uevent {
 	uevent_action_t  action;
@@ -63,6 +108,23 @@ struct uevent {
 	char            *firmware;	/* firmware file name request */
 	char            *seqnum;	/* kernel sequence number */
 	char            *driver;	/* driver name */
+
+	/* Generic env store: all KEY=VALUE from the netlink buffer + rule-set vars */
+	int     nenv;
+	char   *env_key[UEVENT_ENV_MAX];
+	char   *env_val[UEVENT_ENV_MAX];
+	uint8_t env_key_alloc[UEVENT_ENV_MAX];	/* 1 if heap-allocated, 0 if buf ptr */
+	uint8_t env_val_alloc[UEVENT_ENV_MAX];
+
+	/* PROGRAM= output, stored for subsequent RESULT== matching */
+	char   *result;
+
+	/* TAG+= accumulator */
+	int     ntags;
+	char   *tags[UEVENT_TAG_MAX];
+
+	/* Rule-applied permissions from the rules engine */
+	struct rule_ctx applied;
 };
 
 /* Tracked symlink for cleanup on device removal */
@@ -73,19 +135,28 @@ struct dev_symlink {
 };
 
 /* Function prototypes - uevent.c */
-int             uevent_parse    (char *buf, size_t len, struct uevent *ev);
+void            rule_ctx_free    (struct rule_ctx *ctx);
+
+int             uevent_parse     (char *buf, size_t len, struct uevent *ev);
 const char     *uevent_action_str(uevent_action_t action);
+const char     *uevent_sysname   (const struct uevent *ev);
 
-int             devnode_add     (struct uevent *ev);
-int             devnode_del     (struct uevent *ev);
+const char     *uevent_getenv    (const struct uevent *ev, const char *key);
+int             uevent_setenv    (struct uevent *ev, const char *key, const char *val);
+void            uevent_env_free  (struct uevent *ev);
 
-int             symlink_add     (struct uevent *ev);
-int             symlink_del     (struct uevent *ev);
+int             devnode_add      (struct uevent *ev);
+int             devnode_del      (struct uevent *ev);
+int             netdev_add       (struct uevent *ev);
 
-int             firmware_load   (struct uevent *ev);
-int             modprobe_load   (const char *modalias);
+int             symlink_add      (struct uevent *ev);
+int             symlink_del      (struct uevent *ev);
+void            symlink_write_db (const char *devpath, FILE *fp);
 
-int             coldplug        (void);
+int             firmware_load    (struct uevent *ev);
+int             modprobe_load    (const char *modalias);
+
+int             coldplug         (void);
 
 #endif /* FINIT_KEVENTD_H_ */