FIND_PATH(ubox_include_dir NAMES libubox/usock.h)
FIND_PATH(ubus_include_dir NAMES libubus.h)
-INCLUDE_DIRECTORIES(${ubox_include_dir} ${ubus_include_dir})
+FIND_PATH(udebug_include_dir NAMES udebug.h)
+INCLUDE_DIRECTORIES(${ubox_include_dir} ${ubus_include_dir} ${udebug_include_dir})
FIND_LIBRARY(ubox NAMES ubox)
FIND_LIBRARY(ubus NAMES ubus)
FIND_LIBRARY(blobmsg_json NAMES blobmsg_json)
FIND_LIBRARY(json NAMES json json-c)
+FIND_LIBRARY(udebug NAMES udebug)
-SET(LIBS ${ubox} ${ubus} ${blobmsg_json} ${json} resolv)
+SET(LIBS ${ubox} ${ubus} ${blobmsg_json} ${json} resolv ${udebug})
IF(DEBUG)
ADD_DEFINITIONS(-DDEBUG -g3)
#include <netinet/in.h>
#include <arpa/nameser.h>
+#include <udebug.h>
#include <libubus.h>
#include <libubox/uloop.h>
int cfg_proto = 0;
int cfg_no_subnet = 0;
+static struct udebug ud;
+static struct udebug_buf udb;
+static bool udebug_enabled;
+
+static void
+umdns_udebug_vprintf(const char *format, va_list ap)
+{
+ if (!udebug_enabled)
+ return;
+
+ udebug_entry_init(&udb);
+ udebug_entry_vprintf(&udb, format, ap);
+ udebug_entry_add(&udb);
+}
+
+void umdns_udebug_printf(const char *format, ...)
+{
+ va_list ap;
+
+ va_start(ap, format);
+ umdns_udebug_vprintf(format, ap);
+ va_end(ap);
+}
+
+void umdns_udebug_set_enabled(bool val)
+{
+ static const struct udebug_buf_meta meta = {
+ .name = "umdns_log",
+ .format = UDEBUG_FORMAT_STRING,
+ };
+
+ if (udebug_enabled == val)
+ return;
+
+ udebug_enabled = val;
+ if (!val) {
+ udebug_buf_free(&udb);
+ udebug_free(&ud);
+ return;
+ }
+
+ udebug_init(&ud);
+ udebug_auto_connect(&ud, NULL);
+ udebug_buf_init(&udb, 1024, 64 * 1024);
+ udebug_buf_add(&ud, &udb, &meta);
+}
+
static void
signal_shutdown(int signal)
{
static struct ubus_auto_conn conn;
static struct blob_buf b;
+static struct ubus_subscriber udebug_sub;
static int
umdns_reload(struct ubus_context *ctx, struct ubus_object *obj,
.n_methods = ARRAY_SIZE(umdns_methods),
};
+static struct blob_attr *
+find_attr(struct blob_attr *attr, const char *name, enum blobmsg_type type)
+{
+ struct blobmsg_policy policy = { name, type };
+ struct blob_attr *ret;
+
+ if (!attr)
+ return NULL;
+
+ blobmsg_parse_attr(&policy, 1, &ret, attr);
+
+ return ret;
+}
+
+static void
+umdns_udebug_config_cb(struct blob_attr *data)
+{
+ enum {
+ CFG_ATTR_ENABLED,
+ __CFG_ATTR_MAX
+ };
+ static const struct blobmsg_policy policy[__CFG_ATTR_MAX] = {
+ [CFG_ATTR_ENABLED] = { "enabled", BLOBMSG_TYPE_STRING },
+ };
+ struct blob_attr *tb[__CFG_ATTR_MAX];
+ bool en;
+
+ data = find_attr(data, "service", BLOBMSG_TYPE_TABLE);
+ data = find_attr(data, "umdns", BLOBMSG_TYPE_TABLE);
+ if (!data)
+ return;
+
+ blobmsg_parse_attr(policy, __CFG_ATTR_MAX, tb, data);
+ if (!tb[CFG_ATTR_ENABLED])
+ return;
+
+ en = !!atoi(blobmsg_get_string(tb[CFG_ATTR_ENABLED]));
+ umdns_udebug_set_enabled(en);
+}
+
+static int
+umdns_udebug_notify_cb(struct ubus_context *ctx, struct ubus_object *obj,
+ struct ubus_request_data *req, const char *method,
+ struct blob_attr *msg)
+{
+ umdns_udebug_config_cb(msg);
+
+ return 0;
+}
+
+static void
+umdns_udebug_req_cb(struct ubus_request *req, int type, struct blob_attr *msg)
+{
+ umdns_udebug_config_cb(msg);
+}
+
+static bool
+umdns_udebug_sub_cb(struct ubus_context *ctx, struct ubus_subscriber *sub,
+ const char *path)
+{
+ return !strcmp(path, "udebug");
+}
+
+
static void
ubus_connect_handler(struct ubus_context *ctx)
{
+ uint32_t id;
int ret;
ret = ubus_add_object(ctx, &umdns_object);
if (ret)
fprintf(stderr, "Failed to add object: %s\n", ubus_strerror(ret));
+
+ udebug_sub.cb = umdns_udebug_notify_cb;
+ udebug_sub.new_obj_cb = umdns_udebug_sub_cb;
+ ubus_register_subscriber(&conn.ctx, &udebug_sub);
+ if (ubus_lookup_id(&conn.ctx, "udebug", &id) == 0) {
+ ubus_subscribe(&conn.ctx, &udebug_sub, id);
+ ubus_invoke(&conn.ctx, id, "get_config", NULL, umdns_udebug_req_cb, NULL, 1000);
+ }
}
void
#include <time.h>
#define DBG(level, fmt, ...) do { \
+ umdns_udebug_printf("[%d] [%s:%d] " fmt, level, __func__, __LINE__, ## __VA_ARGS__); \
if (debug >= level) \
fprintf(stderr, "mdnsd: %s (%d): " fmt, __func__, __LINE__, ## __VA_ARGS__); \
} while (0)
extern uint32_t rand_time_delta(uint32_t t);
extern time_t monotonic_time(void);
+void umdns_udebug_set_enabled(bool val);
+void umdns_udebug_printf(const char *format, ...);
+
#endif