#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <stdarg.h>
#include <stdbool.h>
+#include <inttypes.h>
#include <assert.h>
#include <glib-object.h>
}
rc = decode_tag_size(&head->size, tag_size, buf+len, n-len);
- if (head->size == 0)
+ if (rc == 0 && head->size == 0)
return 0;
len += rc;
g_value_set_ulong(&val, unpack_32_le(priv->buf+len));
g_object_set_property(G_OBJECT(uo), head->prop_name, &val);
break;
+ case PROPERTY_BOOLEAN:
+ g_value_init(&val, G_TYPE_BOOLEAN);
+ g_value_set_boolean(&val, head->tag_msb);
+ g_object_set_property(G_OBJECT(uo), head->prop_name, &val);
+ break;
case PROPERTY_OBJECT:
rc = decode_object_property(uo, &val, len);
if (rc != 0)
return 0;
}
+/*
+ * Get the full hierarchical object name for an export, used for diagnostics.
+ * Currently, this does not include the package name (which is actually
+ * required for this to be a "full" name) as it's not yet passed to the
+ * deserialize method.
+ *
+ * Returns a buffer allocated by malloc on success, or NULL on failure.
+ */
+static char *get_obj_fullname(const struct upkg_export *e)
+{
+ size_t total_len = 0, len;
+ char *fullname;
+
+ for (const struct upkg_export *c = e; c; c = c->parent) {
+ len = strlen(c->name) + 1;
+ if (total_len > SIZE_MAX - len)
+ return NULL;
+ total_len += len;
+ }
+
+ fullname = malloc(total_len);
+ if (!fullname)
+ return NULL;
+
+ for (const struct upkg_export *c = e; c; c = c->parent) {
+ len = strlen(c->name);
+ assert(total_len > len);
+
+ total_len -= len + 1;
+ memcpy(fullname + total_len, c->name, len);
+ fullname[total_len + len] = c == e ? '\0' : '.';
+ }
+
+ return fullname;
+}
+
int u_object_deserialize(GObject *obj, struct upkg *pkg, unsigned long idx)
{
g_return_val_if_fail(IS_U_OBJECT(obj), -1);
UObject *uo = U_OBJECT(obj);
+ const struct upkg_export *e;
struct upkg_file *f;
int rc;
uo->pkg = pkg;
uo->pkg_file = f;
+ e = upkg_get_export(pkg, idx);
+ if (!e)
+ return -1;
+ uo->pkg_name = get_obj_fullname(e);
+ if (!uo->pkg_name)
+ return -1;
+
rc = U_OBJECT_GET_CLASS(obj)->deserialize(uo);
if (rc != 0) {
upkg_export_close(f);
upkg_export_close(uo->pkg_file);
}
+ free(uo->pkg_name);
+
G_OBJECT_CLASS(u_object_parent_class)->finalize(o);
}
class->deserialize = deserialize;
go->finalize = u_object_finalize;
}
+
+/*
+ * Prepend a prefix to a printf-style format string. Unfortunately, there's
+ * no way to construct va_list values on the fly in C, so we cannot simply
+ * prepend %s and pass the prefix as an argument. Any % characters in the
+ * prefix will be escaped.
+ *
+ * Returns a pointer to a newly allocated string, which should be freed by the
+ * caller, or NULL otherwise.
+ */
+static char *prepend_fmt(const char *prefix, const char *fmt)
+{
+ size_t prefix_len = strlen(prefix), fmt_len = strlen(fmt);
+ char *new_fmt;
+
+ if (prefix_len > SIZE_MAX/2 - sizeof ": ")
+ return NULL;
+ if (2*prefix_len > SIZE_MAX - fmt_len)
+ return NULL;
+
+ new_fmt = malloc(2*prefix_len + fmt_len + 1);
+ if (new_fmt) {
+ size_t offset = 0;
+
+ for (size_t i = 0; i < prefix_len; i++) {
+ if (prefix[i] == '%')
+ new_fmt[offset++] = '%';
+ new_fmt[offset++] = prefix[i];
+ }
+
+ new_fmt[offset++] = ':';
+ new_fmt[offset++] = ' ';
+ strcpy(new_fmt+offset, fmt);
+ }
+
+ return new_fmt;
+}
+
+/* Logging helpers that automatically prepend the UObject class information. */
+void u_vlog_full(GObject *o, GLogLevelFlags level, const char *fmt, va_list ap)
+{
+ g_return_if_fail(IS_U_OBJECT(o));
+ UObject *uo = U_OBJECT(o);
+ char *new_fmt = NULL;
+
+ if (uo->pkg_name) {
+ new_fmt = prepend_fmt(uo->pkg_name, fmt);
+ if (!new_fmt) {
+ g_log(G_OBJECT_TYPE_NAME(o), level, "%s",
+ uo->pkg_file->name);
+ } else {
+ fmt = new_fmt;
+ }
+ }
+
+ g_logv(G_OBJECT_TYPE_NAME(o), level, fmt, ap);
+ free(new_fmt);
+}
+
+void u_log_full(GObject *o, GLogLevelFlags level, const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ u_vlog_full(o, level, fmt, ap);
+ va_end(ap);
+}