void ldb_debug_messages(void *context, enum ldb_debug_level level,
const char *fmt, va_list ap)
{
int loglevel = SSSDBG_UNRESOLVED;
int ret;
char * message = NULL;
switch(level) {
case LDB_DEBUG_FATAL:
loglevel = SSSDBG_FATAL_FAILURE;
break;
case LDB_DEBUG_ERROR:
loglevel = SSSDBG_CRIT_FAILURE;
break;
case LDB_DEBUG_WARNING:
loglevel = SSSDBG_TRACE_FUNC;
break;
case LDB_DEBUG_TRACE:
loglevel = SSSDBG_TRACE_ALL;
break;
}
ret = vasprintf(&message, fmt, ap);
if (ret < 0) {
/* ENOMEM */
return;
}
if (DEBUG_IS_SET(loglevel))
debug_fn(__FILE__, __LINE__, "ldb", loglevel, "%s\n", message);
free(message);
}
/* turn libselinux messages into SSSD DEBUG() calls */
static void sss_semanage_error_callback(void *varg,
semanage_handle_t *handle,
const char *fmt, ...)
{
int level = SSSDBG_INVALID;
int ret;
char * message = NULL;
va_list ap;
switch (semanage_msg_get_level(handle)) {
case SEMANAGE_MSG_ERR:
level = SSSDBG_CRIT_FAILURE;
break;
case SEMANAGE_MSG_WARN:
level = SSSDBG_MINOR_FAILURE;
break;
case SEMANAGE_MSG_INFO:
level = SSSDBG_TRACE_FUNC;
break;
}
va_start(ap, fmt);
ret = vasprintf(&message, fmt, ap);
va_end(ap);
if (ret < 0) {
/* ENOMEM */
return;
}
if (DEBUG_IS_SET(level))
debug_fn(__FILE__, __LINE__, "libsemanage", level, "%s\n", message);
free(message);
}
void
debug_print(Printer& p, Expr* e) {
if (not e) {
print(p, "()");
return;
}
switch (e->kind) {
// Names
case basic_id: return debug_terminal(p, as<Basic_id>(e));
case operator_id: return debug_operator(p, as<Operator_id>(e));
case scoped_id: return debug_scoped(p, as<Scoped_id>(e));
case indexed_id: return debug_indexed(p, as<Indexed_id>(e));
case decl_id: return debug_id(p, as<Decl_id>(e));
// Types
case typename_type: return print(p, "typename");
case unit_type: return print(p, "unit");
case bool_type: return print(p, "bool");
case nat_type: return print(p, "nat");
case int_type: return print(p, "int");
case char_type: return print(p, "char");
case bitfield_type: return debug_ternary(p, as<Bitfield_type>(e));
case fn_type: return debug_binary(p, as<Fn_type>(e));
case range_type: return debug_unary(p, as<Range_type>(e));
case record_type: return debug_nested_unary(p, as<Record_type>(e));
case variant_type: return debug_nested_unary(p, as<Variant_type>(e));
case dep_variant_type: return debug_nested_binary(p, as<Dep_variant_type>(e));
case enum_type: return debug_nested_binary(p, as<Enum_type>(e));
case array_type: return debug_binary(p, as<Array_type>(e));
case dep_type: return debug_binary(p, as<Dep_type>(e));
case module_type: return debug_module(p, as<Module>(e));
// Networking primitives
case net_str_type: return debug_unary(p, as<Net_str_type>(e));
case net_seq_type: return debug_binary(p, as<Net_seq_type>(e));
// Terms
case unit_term: return print(p, "<unit>");
case bool_term: return debug_terminal(p, as<Bool>(e));
case int_term: return debug_terminal(p, as<Int>(e));
case default_term: return print(p, "default");
case fn_term: return debug_fn(p, as<Fn>(e));
case builtin_term: return print(p, "<builtin>");
case call_term: return debug_binary(p, as<Call>(e));
case promo_term: return debug_binary(p, as<Promo>(e));
case pred_term: return debug_binary(p, as<Pred>(e));
case range_term: return debug_binary(p, as<Range>(e));
case variant_term: return debug_binary(p, as<Variant>(e));
case unary_term: return debug_binary(p, as<Unary>(e));
case binary_term: return debug_ternary(p, as<Binary>(e));
case if_term: return debug_ternary(p, as<If>(e));
// Statements
case block_stmt: return debug_nested_unary(p, as<Block>(e));
case return_stmt: return debug_unary(p, as<Return>(e));
// Declarations
case top_decl: return debug_nested_unary(p, as<Top>(e));
case def_decl: return debug_ternary(p, as<Def>(e));
case parm_decl: return debug_ternary(p, as<Parm>(e));
case field_decl: return debug_ternary(p, as<Field>(e));
case alt_decl: return debug_binary(p, as<Alt>(e));
case enum_decl: return debug_constructor(p, as<Enum>(e));
case import_decl: return debug_unary(p, as<Import>(e));
case using_decl: return debug_unary(p, as<Using>(e));
// Unhandled
default:
// FIXME: Make a print formatter that gives complete information
// about a node, including its class and id.
steve_unreachable(format("debugging unhandled expression '{}'", node_name(e)));
}
}
static void debug(const char* text)
{
if (debug_fn)
debug_fn(text);
}
