aboutsummaryrefslogtreecommitdiffstats
path: root/package/hotplug2/patches
diff options
context:
space:
mode:
Diffstat (limited to 'package/hotplug2/patches')
-rw-r--r--package/hotplug2/patches/100-env_memleak.patch63
-rw-r--r--package/hotplug2/patches/110-static_worker.patch20
-rw-r--r--package/hotplug2/patches/120-sysfs_path_fix.patch14
-rw-r--r--package/hotplug2/patches/130-cancel_download_fix.patch18
-rw-r--r--package/hotplug2/patches/140-worker_fork_fix.patch56
-rw-r--r--package/hotplug2/patches/150-force_fork_slow.patch21
-rw-r--r--package/hotplug2/patches/160-event_block_fix.patch200
-rw-r--r--package/hotplug2/patches/170-non_fatal_include.patch21
8 files changed, 413 insertions, 0 deletions
diff --git a/package/hotplug2/patches/100-env_memleak.patch b/package/hotplug2/patches/100-env_memleak.patch
new file mode 100644
index 000000000..28a3e2510
--- /dev/null
+++ b/package/hotplug2/patches/100-env_memleak.patch
@@ -0,0 +1,63 @@
+--- a/action.c
++++ b/action.c
+@@ -31,6 +31,30 @@ static void action_dumb(const struct set
+ }
+
+ /**
++ * Creates a "key=value" string from the given key and value
++ *
++ * @1 Key
++ * @2 Value
++ *
++ * Returns: Newly allocated string in "key=value" form
++ *
++ */
++static char* alloc_env(const char *key, const char *value) {
++ size_t keylen, vallen;
++ char *combined;
++
++ keylen = strlen(key);
++ vallen = strlen(value) + 1;
++
++ combined = xmalloc(keylen + vallen + 1);
++ memcpy(combined, key, keylen);
++ combined[keylen] = '=';
++ memcpy(&combined[keylen + 1], value, vallen);
++
++ return combined;
++}
++
++/**
+ * Choose what action should be taken according to passed settings.
+ *
+ * @1 Hotplug settings
+@@ -41,16 +65,25 @@ static void action_dumb(const struct set
+ */
+ void action_perform(struct settings_t *settings, struct uevent_t *event) {
+ int i;
++ char **env;
++
++ env = xmalloc(sizeof(char *) * event->env_vars_c);
++
++ for (i = 0; i < event->env_vars_c; i++) {
++ env[i] = alloc_env(event->env_vars[i].key, event->env_vars[i].value);
++ putenv(env[i]);
++ }
+
+- for (i = 0; i < event->env_vars_c; i++)
+- setenv(event->env_vars[i].key, event->env_vars[i].value, 1);
+-
+ if (settings->dumb == 0) {
+ ruleset_execute(&settings->rules, event, settings);
+ } else {
+ action_dumb(settings, event);
+ }
+
+- for (i = 0; i < event->env_vars_c; i++)
++ for (i = 0; i < event->env_vars_c; i++) {
+ unsetenv(event->env_vars[i].key);
++ free(env[i]);
++ }
++
++ free(env);
+ }
diff --git a/package/hotplug2/patches/110-static_worker.patch b/package/hotplug2/patches/110-static_worker.patch
new file mode 100644
index 000000000..3a5181f74
--- /dev/null
+++ b/package/hotplug2/patches/110-static_worker.patch
@@ -0,0 +1,20 @@
+--- a/common.mak
++++ b/common.mak
+@@ -1,7 +1,7 @@
+ # vim:set sw=8 nosta:
+
+ COPTS=-Os -Wall -g
+-LDFLAGS=-g -ldl
++LDFLAGS=-g
+
+ CFLAGS=$(COPTS)
+ FPIC=-fPIC
+--- a/Makefile
++++ b/Makefile
+@@ -40,5 +40,6 @@ ifdef STATIC_WORKER
+ CFLAGS += -DSTATIC_WORKER=1
+ else
+ CFLAGS += $(FPIC)
++ LDFLAGS += -ldl
+ endif
+
diff --git a/package/hotplug2/patches/120-sysfs_path_fix.patch b/package/hotplug2/patches/120-sysfs_path_fix.patch
new file mode 100644
index 000000000..0903057c7
--- /dev/null
+++ b/package/hotplug2/patches/120-sysfs_path_fix.patch
@@ -0,0 +1,14 @@
+--- a/rules/command.c
++++ b/rules/command.c
+@@ -374,9 +374,9 @@ RULES_COMMAND_F(cmd_firmware) {
+ if (firmware == NULL)
+ return -1;
+
+- if (snprintf(sysfs_path_loading, PATH_MAX, "/sysfs%s/loading", devpath) >= PATH_MAX)
++ if (snprintf(sysfs_path_loading, PATH_MAX, "/sys%s/loading", devpath) >= PATH_MAX)
+ return -1;
+- if (snprintf(sysfs_path_data, PATH_MAX, "/sysfs%s/data", devpath) >= PATH_MAX)
++ if (snprintf(sysfs_path_data, PATH_MAX, "/sys%s/data", devpath) >= PATH_MAX)
+ return -1;
+ if (snprintf(firmware_path, PATH_MAX, "%s/%s", argv[0], firmware) >= PATH_MAX)
+ return -1;
diff --git a/package/hotplug2/patches/130-cancel_download_fix.patch b/package/hotplug2/patches/130-cancel_download_fix.patch
new file mode 100644
index 000000000..c94000dcc
--- /dev/null
+++ b/package/hotplug2/patches/130-cancel_download_fix.patch
@@ -0,0 +1,18 @@
+--- a/rules/command.c
++++ b/rules/command.c
+@@ -385,13 +385,13 @@ RULES_COMMAND_F(cmd_firmware) {
+
+ infp = fopen(firmware_path, "r");
+ if (infp == NULL) {
+- echo_to_file(sysfs_path_loading, "0\n", 2);
++ echo_to_file(sysfs_path_loading, "-1\n", 2);
+ return -1;
+ }
+ outfp = fopen(sysfs_path_data, "w");
+ if (outfp == NULL) {
+ fclose(infp);
+- echo_to_file(sysfs_path_loading, "0\n", 2);
++ echo_to_file(sysfs_path_loading, "-1\n", 2);
+ return -1;
+ }
+
diff --git a/package/hotplug2/patches/140-worker_fork_fix.patch b/package/hotplug2/patches/140-worker_fork_fix.patch
new file mode 100644
index 000000000..eaf3c5c36
--- /dev/null
+++ b/package/hotplug2/patches/140-worker_fork_fix.patch
@@ -0,0 +1,56 @@
+--- a/action.c
++++ b/action.c
+@@ -39,7 +39,7 @@ static void action_dumb(const struct set
+ * Returns: Newly allocated string in "key=value" form
+ *
+ */
+-static char* alloc_env(const char *key, const char *value) {
++char* alloc_env(const char *key, const char *value) {
+ size_t keylen, vallen;
+ char *combined;
+
+--- a/action.h
++++ b/action.h
+@@ -12,5 +12,6 @@
+ #include "settings.h"
+
+ void action_perform(struct settings_t *, struct uevent_t *);
++char* alloc_env(const char *, const char *);
+ #endif /* ifndef ACTION_H */
+
+--- a/workers/worker_fork.c
++++ b/workers/worker_fork.c
+@@ -380,6 +380,7 @@ static void worker_fork_deinit(void *in_
+
+
+ static int worker_fork_process(void *in_ctx, struct uevent_t *uevent) {
++ char **env;
+ int i;
+ struct worker_fork_child_t *child;
+ struct worker_fork_ctx_t *ctx = in_ctx;
+@@ -406,6 +407,12 @@ static int worker_fork_process(void *in_
+ * No child process is currently available.
+ */
+ if (child == NULL) {
++ env = xmalloc(sizeof(char *) * uevent->env_vars_c);
++ for (i = 0; i < uevent->env_vars_c; i++) {
++ env[i] = alloc_env(uevent->env_vars[i].key, uevent->env_vars[i].value);
++ putenv(env[i]);
++ }
++
+ /*
+ * Are the matching rules trivial enough that we
+ * can execute them in the main process?
+@@ -421,6 +428,12 @@ static int worker_fork_process(void *in_
+ */
+ if (ctx->children_count < ctx->max_children)
+ child = worker_fork_spawn(ctx);
++
++ for (i = 0; i < uevent->env_vars_c; i++) {
++ unsetenv(uevent->env_vars[i].key);
++ free(env[i]);
++ }
++ free(env);
+ }
+
+ /*
diff --git a/package/hotplug2/patches/150-force_fork_slow.patch b/package/hotplug2/patches/150-force_fork_slow.patch
new file mode 100644
index 000000000..47101f56b
--- /dev/null
+++ b/package/hotplug2/patches/150-force_fork_slow.patch
@@ -0,0 +1,21 @@
+--- a/workers/worker_fork.c
++++ b/workers/worker_fork.c
+@@ -396,7 +396,7 @@ static int worker_fork_process(void *in_
+ worker_fork_update_children(ctx);
+
+ child = NULL;
+- for (i = 0; i < ctx->children_count; i++) {
++ for (i = 0; i < ctx->children_count && i < ctx->max_children; i++) {
+ if (ctx->children[i]->busy == 0) {
+ child = ctx->children[i];
+ break;
+@@ -426,7 +426,8 @@ static int worker_fork_process(void *in_
+ /*
+ * We have to fork off a new child.
+ */
+- if (ctx->children_count < ctx->max_children)
++ if (ctx->children_count < ctx->max_children ||
++ (ruleset_flags(&ctx->settings->rules, uevent) & FLAG_SLOW))
+ child = worker_fork_spawn(ctx);
+
+ for (i = 0; i < uevent->env_vars_c; i++) {
diff --git a/package/hotplug2/patches/160-event_block_fix.patch b/package/hotplug2/patches/160-event_block_fix.patch
new file mode 100644
index 000000000..ac7e79ab1
--- /dev/null
+++ b/package/hotplug2/patches/160-event_block_fix.patch
@@ -0,0 +1,200 @@
+--- a/uevent.c
++++ b/uevent.c
+@@ -132,6 +132,8 @@ struct uevent_t *uevent_dup(const struct
+
+ dest = xmalloc(sizeof(struct uevent_t));
+ dest->action = src->action;
++ dest->seqnum = src->seqnum;
++ dest->action_str = strdup(src->action_str);
+ dest->env_vars_c = src->env_vars_c;
+ dest->env_vars = xmalloc(sizeof(struct env_var_t) * dest->env_vars_c);
+ dest->plain_s = src->plain_s;
+--- a/workers/worker_fork.c
++++ b/workers/worker_fork.c
+@@ -1,6 +1,69 @@
+ #include "worker_fork.h"
+
+ static struct worker_fork_ctx_t *global_ctx;
++static struct worker_fork_uevent_t *uevent_list;
++
++static void worker_fork_uevent_free(struct worker_fork_uevent_t *node) {
++ uevent_free(node->uevent);
++ free(node);
++}
++
++static void worker_fork_uevent_add(void *in_ctx, struct uevent_t *uevent) {
++ char **env;
++ int i;
++ struct worker_fork_ctx_t *ctx = in_ctx;
++ struct worker_fork_uevent_t *node, *walker;
++
++ node = malloc(sizeof (struct worker_fork_uevent_t));
++ node->uevent = uevent_dup(uevent);
++ node->next = NULL;
++
++ if (!uevent_list) uevent_list = node;
++ else {
++ /*
++ * Put events that need to fork first and in reverse order
++ */
++ env = xmalloc(sizeof(char *) * node->uevent->env_vars_c);
++ for (i = 0; i < node->uevent->env_vars_c; i++) {
++ env[i] = alloc_env(node->uevent->env_vars[i].key, node->uevent->env_vars[i].value);
++ putenv(env[i]);
++ }
++ if (ruleset_flags(&ctx->settings->rules, uevent) & FLAG_SLOW) {
++ node->next = uevent_list;
++ uevent_list = node;
++ }
++ else {
++ for (walker = uevent_list; walker->next; walker = walker->next);
++ walker->next = node;
++ }
++ for (i = 0; i < node->uevent->env_vars_c; i++) {
++ unsetenv(node->uevent->env_vars[i].key);
++ free(env[i]);
++ }
++ free(env);
++ }
++}
++
++static void worker_fork_uevent_del(struct worker_fork_uevent_t *node) {
++ struct worker_fork_uevent_t *walker;
++
++ if (node == uevent_list) {
++ uevent_list = node->next;
++ }
++ else {
++ for (walker = uevent_list; walker->next; walker = walker->next)
++ if (walker->next == node) walker->next = node->next;
++ }
++ worker_fork_uevent_free(node);
++}
++
++static void worker_fork_uevent_empty(void) {
++ struct worker_fork_uevent_t *walker;
++
++ if (!uevent_list) return;
++ for (walker = uevent_list; walker->next; walker = walker->next) worker_fork_uevent_free(walker);
++ uevent_list = NULL;
++}
+
+ /**
+ * Destroys data structures related to the given child ID (not PID).
+@@ -315,6 +378,8 @@ static void *worker_fork_init(struct set
+ struct worker_fork_ctx_t *ctx;
+ PRINTFUNC();
+
++ uevent_list = NULL;
++
+ ctx = malloc(sizeof(struct worker_fork_ctx_t));
+ ctx->children = NULL;
+ ctx->children_count = 0;
+@@ -376,6 +441,7 @@ static void worker_fork_deinit(void *in_
+ free(ctx->children);
+ free(ctx);
+ global_ctx = NULL;
++ worker_fork_uevent_empty();
+ }
+
+
+@@ -384,15 +450,26 @@ static int worker_fork_process(void *in_
+ int i;
+ struct worker_fork_child_t *child;
+ struct worker_fork_ctx_t *ctx = in_ctx;
++ struct worker_fork_uevent_t *node, *walker;
++ event_seqnum_t seqnum;
++
++ worker_fork_uevent_add(ctx, uevent);
++ walker = uevent_list;
+
+ /*
+- * A big loop, because if we fail to process the event,
++ * A big loop, because if we fail to process the events,
+ * we don't want to give up.
+ *
+ * TODO: Decide if we want to limit the number of attempts
+ * or set a time limit before reporting terminal failure.
+ */
+ do {
++ /*
++ * If more events are waiting, return to receive them
++ */
++ if (!seqnum_get(&seqnum) && seqnum > uevent->seqnum) break;
++
++ node = walker;
+ worker_fork_update_children(ctx);
+
+ child = NULL;
+@@ -407,9 +484,9 @@ static int worker_fork_process(void *in_
+ * No child process is currently available.
+ */
+ if (child == NULL) {
+- env = xmalloc(sizeof(char *) * uevent->env_vars_c);
+- for (i = 0; i < uevent->env_vars_c; i++) {
+- env[i] = alloc_env(uevent->env_vars[i].key, uevent->env_vars[i].value);
++ env = xmalloc(sizeof(char *) * node->uevent->env_vars_c);
++ for (i = 0; i < node->uevent->env_vars_c; i++) {
++ env[i] = alloc_env(node->uevent->env_vars[i].key, node->uevent->env_vars[i].value);
+ putenv(env[i]);
+ }
+
+@@ -418,8 +495,11 @@ static int worker_fork_process(void *in_
+ * can execute them in the main process?
+ */
+ if (ctx->always_fork == 0 && ctx->settings->dumb == 0 &&
+- (ruleset_flags(&ctx->settings->rules, uevent) & FLAG_MASK_SLOW) == 0) {
+- action_perform(ctx->settings, uevent);
++ (ruleset_flags(&ctx->settings->rules, node->uevent) & FLAG_MASK_SLOW) == 0) {
++ action_perform(ctx->settings, node->uevent);
++ walker = walker->next;
++ worker_fork_uevent_del(node);
++ if (walker) continue;
+ break;
+ }
+
+@@ -427,11 +507,11 @@ static int worker_fork_process(void *in_
+ * We have to fork off a new child.
+ */
+ if (ctx->children_count < ctx->max_children ||
+- (ruleset_flags(&ctx->settings->rules, uevent) & FLAG_SLOW))
++ (ruleset_flags(&ctx->settings->rules, node->uevent) & FLAG_SLOW))
+ child = worker_fork_spawn(ctx);
+
+- for (i = 0; i < uevent->env_vars_c; i++) {
+- unsetenv(uevent->env_vars[i].key);
++ for (i = 0; i < node->uevent->env_vars_c; i++) {
++ unsetenv(node->uevent->env_vars[i].key);
+ free(env[i]);
+ }
+ free(env);
+@@ -442,9 +522,14 @@ static int worker_fork_process(void *in_
+ */
+ if (child != NULL) {
+ child->busy = 1;
+- if (!worker_fork_relay_event(child->event_fd, uevent));
+- break;
+- child->busy = 0;
++ if (worker_fork_relay_event(child->event_fd, node->uevent)) {
++ child->busy = 0;
++ continue;
++ }
++ walker = walker->next;
++ worker_fork_uevent_del(node);
++ if (walker) continue;
++ break;
+ }
+
+ /*
+--- a/workers/worker_fork.h
++++ b/workers/worker_fork.h
+@@ -35,4 +35,9 @@ struct worker_fork_ctx_t {
+ struct settings_t *settings;
+ };
+
++struct worker_fork_uevent_t {
++ struct uevent_t *uevent;
++ struct worker_fork_uevent_t *next;
++};
++
+ #endif
diff --git a/package/hotplug2/patches/170-non_fatal_include.patch b/package/hotplug2/patches/170-non_fatal_include.patch
new file mode 100644
index 000000000..0b8e85283
--- /dev/null
+++ b/package/hotplug2/patches/170-non_fatal_include.patch
@@ -0,0 +1,21 @@
+Index: hotplug2-201/parser/parser.c
+===================================================================
+--- hotplug2-201.orig/parser/parser.c 2009-12-09 19:44:13.000000000 +0100
++++ hotplug2-201/parser/parser.c 2011-02-08 18:06:44.681213713 +0100
+@@ -1,5 +1,7 @@
+ #include "parser.h"
+
++#include <errno.h>
++
+ /*
+ * Grammar:
+ * input => directive // TOKEN_ROOTKW
+@@ -578,7 +580,7 @@
+ ctx.lexer.fp = fopen(filename, "r");
+ if (ctx.lexer.fp == NULL) {
+ parser_clear(&ctx);
+- return -1;
++ return (errno == ENOENT) ? 0 : -1;
+ }
+ ctx.lexer.filename = strdup(filename);
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-24 15:53:32 +0000