/*

 * Copyright 2004-2019 the Pacemaker project contributors

 *

 * The version control history for this file may have further details.

 *

 * This source code is licensed under the GNU Lesser General Public License

 * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.

 */

#include <crm_internal.h>

#include <stdio.h>

#include <string.h>

#include <dirent.h>

#include <errno.h>

#include <sys/stat.h>

#include <stdarg.h>

#include <libxml/relaxng.h>

#if HAVE_LIBXSLT

#  include <libxslt/xslt.h>

#  include <libxslt/transform.h>

#  include <libxslt/security.h>

#  include <libxslt/xsltutils.h>

#endif

#include <crm/msg_xml.h>

#include <crm/common/xml.h>

#include <crm/common/xml_internal.h>  /* CRM_XML_LOG_BASE */

typedef struct {

    unsigned char v[2];

} schema_version_t;

#define SCHEMA_ZERO { .v = { 0, 0 } }

#define schema_scanf(s, prefix, version, suffix) \

    sscanf((s), prefix "%hhu.%hhu" suffix, &((version).v[0]), &((version).v[1]))

#define schema_strdup_printf(prefix, version, suffix) \

    crm_strdup_printf(prefix "%u.%u" suffix, (version).v[0], (version).v[1])

typedef struct {

    xmlRelaxNGPtr rng;

    xmlRelaxNGValidCtxtPtr valid;

    xmlRelaxNGParserCtxtPtr parser;

} relaxng_ctx_cache_t;

enum schema_validator_e {

    schema_validator_none,

    schema_validator_rng

};

struct schema_s {

    char *name;

    char *transform;

    void *cache;

    enum schema_validator_e validator;

    int after_transform;

    schema_version_t version;

    char *transform_enter;

    bool transform_onleave;

};

static struct schema_s *known_schemas = NULL;

static int xml_schema_max = 0;

static bool silent_logging = FALSE;

static void

xml_log(int priority, const char *fmt, ...)

G_GNUC_PRINTF(2, 3);

static void

xml_log(int priority, const char *fmt, ...)

{

    va_list ap;

    va_start(ap, fmt);

    if (silent_logging == FALSE) {

        /* XXX should not this enable dechunking as well? */

        CRM_XML_LOG_BASE(priority, FALSE, 0, NULL, fmt, ap);

    }

    va_end(ap);

}

static int

xml_latest_schema_index(void)

{

    return xml_schema_max - 3; // index from 0, ignore "pacemaker-next"/"none"

}

static int

xml_minimum_schema_index(void)

{

    static int best = 0;

    if (best == 0) {

        int lpc = 0;

        best = xml_latest_schema_index();

        for (lpc = best; lpc > 0; lpc--) {

            if (known_schemas[lpc].version.v[0]

                < known_schemas[best].version.v[0]) {

                return best;

            } else {

                best = lpc;

            }

        }

        best = xml_latest_schema_index();

    }

    return best;

}

const char *

xml_latest_schema(void)

{

    return get_schema_name(xml_latest_schema_index());

}

static inline bool

version_from_filename(const char *filename, schema_version_t *version)

{

    int rc = schema_scanf(filename, "pacemaker-", *version, ".rng");

    return (rc == 2);

}

static int

schema_filter(const struct dirent *a)

{

    int rc = 0;

    schema_version_t version = SCHEMA_ZERO;

    if (strstr(a->d_name, "pacemaker-") != a->d_name) {

        /* crm_trace("%s - wrong prefix", a->d_name); */

    } else if (!crm_ends_with_ext(a->d_name, ".rng")) {

        /* crm_trace("%s - wrong suffix", a->d_name); */

    } else if (!version_from_filename(a->d_name, &version)) {

        /* crm_trace("%s - wrong format", a->d_name); */

    } else {

        /* crm_debug("%s - candidate", a->d_name); */

        rc = 1;

    }

    return rc;

}

static int

schema_sort(const struct dirent **a, const struct dirent **b)

{

    schema_version_t a_version = SCHEMA_ZERO;

    schema_version_t b_version = SCHEMA_ZERO;

    if (!version_from_filename(a[0]->d_name, &a_version)

        || !version_from_filename(b[0]->d_name, &b_version)) {

        // Shouldn't be possible, but makes static analysis happy

        return 0;

    }

    for (int i = 0; i < 2; ++i) {

        if (a_version.v[i] < b_version.v[i]) {

            return -1;

        } else if (a_version.v[i] > b_version.v[i]) {

            return 1;

        }

    }

    return 0;

}

/*!

 * \internal

 * \brief Add given schema + auxiliary data to internal bookkeeping.

 *

 * \note When providing \p version, should not be called directly but

 *       through \c add_schema_by_version.

 */

static void

add_schema(enum schema_validator_e validator, const schema_version_t *version,

           const char *name, const char *transform,

           const char *transform_enter, bool transform_onleave,

           int after_transform)

{

    int last = xml_schema_max;

    bool have_version = FALSE;

    xml_schema_max++;

    known_schemas = realloc_safe(known_schemas,

                                 xml_schema_max * sizeof(struct schema_s));

    CRM_ASSERT(known_schemas != NULL);

    memset(known_schemas+last, 0, sizeof(struct schema_s));

    known_schemas[last].validator = validator;

    known_schemas[last].after_transform = after_transform;

    for (int i = 0; i < 2; ++i) {

        known_schemas[last].version.v[i] = version->v[i];

        if (version->v[i]) {

            have_version = TRUE;

        }

    }

    if (have_version) {

        known_schemas[last].name = schema_strdup_printf("pacemaker-", *version, "");

    } else {

        CRM_ASSERT(name);

        schema_scanf(name, "%*[^-]-", known_schemas[last].version, "");

        known_schemas[last].name = strdup(name);

    }

    if (transform) {

        known_schemas[last].transform = strdup(transform);

    }

    if (transform_enter) {

        known_schemas[last].transform_enter = strdup(transform_enter);

    }

    known_schemas[last].transform_onleave = transform_onleave;

    if (after_transform == 0) {

        after_transform = xml_schema_max;  /* upgrade is a one-way */

    }

    known_schemas[last].after_transform = after_transform;

    if (known_schemas[last].after_transform < 0) {

        crm_debug("Added supported schema %d: %s",

                  last, known_schemas[last].name);

    } else if (known_schemas[last].transform) {

        crm_debug("Added supported schema %d: %s (upgrades to %d with %s.xsl)",

                  last, known_schemas[last].name,

                  known_schemas[last].after_transform,

                  known_schemas[last].transform);

    } else {

        crm_debug("Added supported schema %d: %s (upgrades to %d)",

                  last, known_schemas[last].name,

                  known_schemas[last].after_transform);

    }

}

/*!

 * \internal

 * \brief Add version-specified schema + auxiliary data to internal bookkeeping.

 * \return \c -ENOENT when no upgrade schema associated, \c pcmk_ok otherwise.

 *

 * \note There's no reliance on the particular order of schemas entering here.

 *

 * \par A bit of theory

 * We track 3 XSLT stylesheets that differ per usage:

 * - "upgrade":

 *   . sparsely spread over the sequence of all available schemas,

 *     as they are only relevant when major version of the schema

 *     is getting bumped -- in that case, it MUST be set

 *   . name convention:  upgrade-X.Y.xsl

 * - "upgrade-enter":

 *   . may only accompany "upgrade" occurrence, but doesn't need to

 *     be present anytime such one is, i.e., it MAY not be set when

 *     "upgrade" is

 *   . name convention:  upgrade-X.Y-enter.xsl,

 *     when not present: upgrade-enter.xsl

 * - "upgrade-leave":

 *   . like "upgrade-enter", but SHOULD be present whenever

 *     "upgrade-enter" is (and vice versa, but that's only

 *     to prevent confusion based on observing the files,

 *     it would get ignored regardless)

 *   . name convention:  (see "upgrade-enter")

 */

static int

add_schema_by_version(const schema_version_t *version, int next,

                      bool transform_expected)

{

    bool transform_onleave = FALSE;

    int rc = pcmk_ok;

    struct stat s;

    char *xslt = NULL,

         *transform_upgrade = NULL,

         *transform_enter = NULL;

    /* prologue for further transform_expected handling */

    if (transform_expected) {

        /* check if there's suitable "upgrade" stylesheet */

        transform_upgrade = schema_strdup_printf("upgrade-", *version, );

        xslt = pcmk__xml_artefact_path(pcmk__xml_artefact_ns_legacy_xslt,

                                       transform_upgrade);

    }

    if (!transform_expected) {

        /* jump directly to the end */

    } else if (stat(xslt, &s) == 0) {

        /* perhaps there's also a targeted "upgrade-enter" stylesheet */

        transform_enter = schema_strdup_printf("upgrade-", *version, "-enter");

        free(xslt);

        xslt = pcmk__xml_artefact_path(pcmk__xml_artefact_ns_legacy_xslt,

                                       transform_enter);

        if (stat(xslt, &s) != 0) {

            /* or initially, at least a generic one */

            crm_debug("Upgrade-enter transform %s.xsl not found", xslt);

            free(xslt);

            free(transform_enter);

            transform_enter = strdup("upgrade-enter");

            xslt = pcmk__xml_artefact_path(pcmk__xml_artefact_ns_legacy_xslt,

                                           transform_enter);

            if (stat(xslt, &s) != 0) {

                crm_debug("Upgrade-enter transform %s.xsl not found, either", xslt);

                free(xslt);

                xslt = NULL;

            }

        }

        /* xslt contains full path to "upgrade-enter" stylesheet */

        if (xslt != NULL) {

            /* then there should be "upgrade-leave" counterpart (enter->leave) */

            memcpy(strrchr(xslt, '-') + 1, "leave", sizeof("leave") - 1);

            transform_onleave = (stat(xslt, &s) == 0);

            free(xslt);

        } else {

            free(transform_enter);

            transform_enter = NULL;

        }

    } else {

        crm_err("Upgrade transform %s not found", xslt);

        free(xslt);

        free(transform_upgrade);

        transform_upgrade = NULL;

        next = -1;

        rc = -ENOENT;

    }

    add_schema(schema_validator_rng, version, NULL,

               transform_upgrade, transform_enter, transform_onleave, next);

    free(transform_upgrade);

    free(transform_enter);

    return rc;

}

static int

wrap_libxslt(bool finalize)

{

    static xsltSecurityPrefsPtr secprefs;

    int ret = 0;

    /* security framework preferences */

    if (!finalize) {

        CRM_ASSERT(secprefs == NULL);

        secprefs = xsltNewSecurityPrefs();

        ret = xsltSetSecurityPrefs(secprefs, XSLT_SECPREF_WRITE_FILE,

                                   xsltSecurityForbid)

              | xsltSetSecurityPrefs(secprefs, XSLT_SECPREF_CREATE_DIRECTORY,

                                     xsltSecurityForbid)

              | xsltSetSecurityPrefs(secprefs, XSLT_SECPREF_READ_NETWORK,

                                     xsltSecurityForbid)

              | xsltSetSecurityPrefs(secprefs, XSLT_SECPREF_WRITE_NETWORK,

                                     xsltSecurityForbid);

        if (ret != 0) {

            return -1;

        }

    } else {

        xsltFreeSecurityPrefs(secprefs);

        secprefs = NULL;

    }

    /* cleanup only */

    if (finalize) {

        xsltCleanupGlobals();

    }

    return ret;

}

/*!

 * \internal

 * \brief Load pacemaker schemas into cache

 *

 * \note This currently also serves as an entry point for the

 *       generic initialization of the libxslt library.

 */

void

crm_schema_init(void)

{

    int lpc, max;

    char *base = pcmk__xml_artefact_root(pcmk__xml_artefact_ns_legacy_rng);

    struct dirent **namelist = NULL;

    const schema_version_t zero = SCHEMA_ZERO;

    wrap_libxslt(false);

    max = scandir(base, &namelist, schema_filter, schema_sort);

    if (max < 0) {

        crm_notice("scandir(%s) failed: %s (%d)", base, strerror(errno), errno);

        free(base);

    } else {

        free(base);

        for (lpc = 0; lpc < max; lpc++) {

            bool transform_expected = FALSE;

            int next = 0;

            schema_version_t version = SCHEMA_ZERO;

            if (!version_from_filename(namelist[lpc]->d_name, &version)) {

                // Shouldn't be possible, but makes static analysis happy

                crm_err("Skipping schema '%s': could not parse version",

                        namelist[lpc]->d_name);

                continue;

            }

            if ((lpc + 1) < max) {

                schema_version_t next_version = SCHEMA_ZERO;

                if (version_from_filename(namelist[lpc+1]->d_name, &next_version)

                        && (version.v[0] < next_version.v[0])) {

                    transform_expected = TRUE;

                }

            } else {

                next = -1;

            }

            if (add_schema_by_version(&version, next, transform_expected)

                    == -ENOENT) {

                break;

            }

        }

        for (lpc = 0; lpc < max; lpc++) {

            free(namelist[lpc]);

        }

        free(namelist);

    }

    add_schema(schema_validator_rng, &zero, "pacemaker-next",

               NULL, NULL, FALSE, -1);

    add_schema(schema_validator_none, &zero, "none", NULL, NULL, FALSE, -1);

}

#if 0

static void

relaxng_invalid_stderr(void *userData, xmlErrorPtr error)

{

    /*

       Structure xmlError

       struct _xmlError {

       int      domain  : What part of the library raised this er

       int      code    : The error code, e.g. an xmlParserError

       char *   message : human-readable informative error messag

       xmlErrorLevel    level   : how consequent is the error

       char *   file    : the filename

       int      line    : the line number if available

       char *   str1    : extra string information

       char *   str2    : extra string information

       char *   str3    : extra string information

       int      int1    : extra number information

       int      int2    : column number of the error or 0 if N/A

       void *   ctxt    : the parser context if available

       void *   node    : the node in the tree

       }

     */

    crm_err("Structured error: line=%d, level=%d %s", error->line, error->level, error->message);

}

#endif

static gboolean

validate_with_relaxng(xmlDocPtr doc, gboolean to_logs, const char *relaxng_file,

                      relaxng_ctx_cache_t **cached_ctx)

{

    int rc = 0;

    gboolean valid = TRUE;

    relaxng_ctx_cache_t *ctx = NULL;

    CRM_CHECK(doc != NULL, return FALSE);

    CRM_CHECK(relaxng_file != NULL, return FALSE);

    if (cached_ctx && *cached_ctx) {

        ctx = *cached_ctx;

    } else {

        crm_debug("Creating RNG parser context");

        ctx = calloc(1, sizeof(relaxng_ctx_cache_t));

        xmlLoadExtDtdDefaultValue = 1;

        ctx->parser = xmlRelaxNGNewParserCtxt(relaxng_file);

        CRM_CHECK(ctx->parser != NULL, goto cleanup);

        if (to_logs) {

            xmlRelaxNGSetParserErrors(ctx->parser,

                                      (xmlRelaxNGValidityErrorFunc) xml_log,

                                      (xmlRelaxNGValidityWarningFunc) xml_log,

                                      GUINT_TO_POINTER(LOG_ERR));

        } else {

            xmlRelaxNGSetParserErrors(ctx->parser,

                                      (xmlRelaxNGValidityErrorFunc) fprintf,

                                      (xmlRelaxNGValidityWarningFunc) fprintf,

                                      stderr);

        }

        ctx->rng = xmlRelaxNGParse(ctx->parser);

        CRM_CHECK(ctx->rng != NULL,

                  crm_err("Could not find/parse %s", relaxng_file);

                  goto cleanup);

        ctx->valid = xmlRelaxNGNewValidCtxt(ctx->rng);

        CRM_CHECK(ctx->valid != NULL, goto cleanup);

        if (to_logs) {

            xmlRelaxNGSetValidErrors(ctx->valid,

                                     (xmlRelaxNGValidityErrorFunc) xml_log,

                                     (xmlRelaxNGValidityWarningFunc) xml_log,

                                     GUINT_TO_POINTER(LOG_ERR));

        } else {

            xmlRelaxNGSetValidErrors(ctx->valid,

                                     (xmlRelaxNGValidityErrorFunc) fprintf,

                                     (xmlRelaxNGValidityWarningFunc) fprintf,

                                     stderr);

        }

    }

    /* xmlRelaxNGSetValidStructuredErrors( */

    /*  valid, relaxng_invalid_stderr, valid); */

    xmlLineNumbersDefault(1);

    rc = xmlRelaxNGValidateDoc(ctx->valid, doc);

    if (rc > 0) {

        valid = FALSE;

    } else if (rc < 0) {

        crm_err("Internal libxml error during validation");

    }

  cleanup:

    if (cached_ctx) {

        *cached_ctx = ctx;

    } else {

        if (ctx->parser != NULL) {

            xmlRelaxNGFreeParserCtxt(ctx->parser);

        }

        if (ctx->valid != NULL) {

            xmlRelaxNGFreeValidCtxt(ctx->valid);

        }

        if (ctx->rng != NULL) {

            xmlRelaxNGFree(ctx->rng);

        }

        free(ctx);

    }

    return valid;

}

/*!

 * \internal

 * \brief Clean up global memory associated with XML schemas

 */

void

crm_schema_cleanup(void)

{

    int lpc;

    relaxng_ctx_cache_t *ctx = NULL;

    for (lpc = 0; lpc < xml_schema_max; lpc++) {

        switch (known_schemas[lpc].validator) {

            case schema_validator_none: // not cached

                break;

            case schema_validator_rng: // cached

                ctx = (relaxng_ctx_cache_t *) known_schemas[lpc].cache;

                if (ctx == NULL) {

                    break;

                }

                if (ctx->parser != NULL) {

                    xmlRelaxNGFreeParserCtxt(ctx->parser);

                }

                if (ctx->valid != NULL) {

                    xmlRelaxNGFreeValidCtxt(ctx->valid);

                }

                if (ctx->rng != NULL) {

                    xmlRelaxNGFree(ctx->rng);

                }

                free(ctx);

                known_schemas[lpc].cache = NULL;

                break;

        }

        free(known_schemas[lpc].name);

        free(known_schemas[lpc].transform);

        free(known_schemas[lpc].transform_enter);

    }

    free(known_schemas);

    known_schemas = NULL;

    wrap_libxslt(true);

}

static gboolean

validate_with(xmlNode *xml, int method, gboolean to_logs)

{

    xmlDocPtr doc = NULL;

    gboolean valid = FALSE;

    char *file = NULL;

    if (method < 0) {

        return FALSE;

    }

    if (known_schemas[method].validator == schema_validator_none) {

        return TRUE;

    }

    CRM_CHECK(xml != NULL, return FALSE);

    doc = getDocPtr(xml);

    file = pcmk__xml_artefact_path(pcmk__xml_artefact_ns_legacy_rng,

                                   known_schemas[method].name);

    crm_trace("Validating with: %s (type=%d)",

              crm_str(file), known_schemas[method].validator);

    switch (known_schemas[method].validator) {

        case schema_validator_rng:

            valid =

                validate_with_relaxng(doc, to_logs, file,

                                      (relaxng_ctx_cache_t **) & (known_schemas[method].cache));

            break;

        default:

            crm_err("Unknown validator type: %d",

                    known_schemas[method].validator);

            break;

    }

    free(file);

    return valid;

}

static bool

validate_with_silent(xmlNode *xml, int method)

{

    bool rc, sl_backup = silent_logging;

    silent_logging = TRUE;

    rc = validate_with(xml, method, TRUE);

    silent_logging = sl_backup;

    return rc;

}

static void

dump_file(const char *filename)

{

    FILE *fp = NULL;

    int ch, line = 0;

    CRM_CHECK(filename != NULL, return);

    fp = fopen(filename, "r");

    if (fp == NULL) {

        crm_perror(LOG_ERR, "Could not open %s for reading", filename);

        return;

    }

    fprintf(stderr, "%4d ", ++line);

    do {

        ch = getc(fp);

        if (ch == EOF) {

            putc('\n', stderr);

            break;

        } else if (ch == '\n') {

            fprintf(stderr, "\n%4d ", ++line);

        } else {

            putc(ch, stderr);

        }

    } while (1);

    fclose(fp);

}

gboolean

validate_xml_verbose(xmlNode *xml_blob)

{

    int fd = 0;

    xmlDoc *doc = NULL;

    xmlNode *xml = NULL;

    gboolean rc = FALSE;

    char *filename = NULL;

    filename = crm_strdup_printf("%s/cib-invalid.XXXXXX", crm_get_tmpdir());

    umask(S_IWGRP | S_IWOTH | S_IROTH);

    fd = mkstemp(filename);

    write_xml_fd(xml_blob, filename, fd, FALSE);

    dump_file(filename);

    doc = xmlParseFile(filename);

    xml = xmlDocGetRootElement(doc);

    rc = validate_xml(xml, NULL, FALSE);

    free_xml(xml);

    unlink(filename);

    free(filename);

    return rc;

}

gboolean

validate_xml(xmlNode *xml_blob, const char *validation, gboolean to_logs)

{

    int version = 0;

    if (validation == NULL) {

        validation = crm_element_value(xml_blob, XML_ATTR_VALIDATION);

    }

    if (validation == NULL) {

        int lpc = 0;

        bool valid = FALSE;

        for (lpc = 0; lpc < xml_schema_max; lpc++) {

            if (validate_with(xml_blob, lpc, FALSE)) {

                valid = TRUE;

                crm_xml_add(xml_blob, XML_ATTR_VALIDATION,

                            known_schemas[lpc].name);

                crm_info("XML validated against %s", known_schemas[lpc].name);

                if(known_schemas[lpc].after_transform == 0) {

                    break;

                }

            }

        }

        return valid;

    }

    version = get_schema_version(validation);

    if (strcmp(validation, "none") == 0) {

        return TRUE;

    } else if (version < xml_schema_max) {

        return validate_with(xml_blob, version, to_logs);

    }

    crm_err("Unknown validator: %s", validation);

    return FALSE;

}

#if HAVE_LIBXSLT

static void

cib_upgrade_err(void *ctx, const char *fmt, ...)

G_GNUC_PRINTF(2, 3);

/* With this arrangement, an attempt to identify the message severity

   as explicitly signalled directly from XSLT is performed in rather

   a smart way (no reliance on formatting string + arguments being

   always specified as ["%s", purposeful_string], as it can also be

   ["%s: %s", some_prefix, purposeful_string] etc. so every argument

   pertaining %s specifier is investigated), and if such a mark found,

   the respective level is determined and, when the messages are to go

   to the native logs, the mark itself gets dropped

   (by the means of string shift).

   NOTE: whether the native logging is the right sink is decided per

         the ctx parameter -- NULL denotes this case, otherwise it

         carries a pointer to the numeric expression of the desired

         target logging level (messages with higher level will be

         suppressed)

   NOTE: on some architectures, this string shift may not have any

         effect, but that's an acceptable tradeoff

   The logging level for not explicitly designated messages

   (suspicious, likely internal errors or some runaways) is

   LOG_WARNING.

 */

static void

cib_upgrade_err(void *ctx, const char *fmt, ...)

{

    va_list ap, aq;

    char *arg_cur;

    bool found = FALSE;

    const char *fmt_iter = fmt;

    uint8_t msg_log_level = LOG_WARNING;  /* default for runaway messages */

    const unsigned * log_level = (const unsigned *) ctx;

    enum {

        escan_seennothing,

        escan_seenpercent,

    } scan_state = escan_seennothing;

    va_start(ap, fmt);

    va_copy(aq, ap);

    while (!found && *fmt_iter != '\0') {

        /* while casing schema borrowed from libqb:qb_vsnprintf_serialize */

        switch (*fmt_iter++) {

        case '%':

            if (scan_state == escan_seennothing) {

                scan_state = escan_seenpercent;

            } else if (scan_state == escan_seenpercent) {

                scan_state = escan_seennothing;

            }

            break;

        case 's':

            if (scan_state == escan_seenpercent) {

                scan_state = escan_seennothing;

                arg_cur = va_arg(aq, char *);

                if (arg_cur != NULL) {

                    switch (arg_cur[0]) {

                    case 'W':

                        if (!strncmp(arg_cur, "WARNING: ",

                                     sizeof("WARNING: ") - 1)) {

                            msg_log_level = LOG_WARNING;

                        }

                        if (ctx == NULL) {

                            memmove(arg_cur, arg_cur + sizeof("WARNING: ") - 1,

                                    strlen(arg_cur + sizeof("WARNING: ") - 1) + 1);

                        }

                        found = TRUE;

                        break;

                    case 'I':

                        if (!strncmp(arg_cur, "INFO: ",

                                     sizeof("INFO: ") - 1)) {

                            msg_log_level = LOG_INFO;

                        }

                        if (ctx == NULL) {

                            memmove(arg_cur, arg_cur + sizeof("INFO: ") - 1,

                                    strlen(arg_cur + sizeof("INFO: ") - 1) + 1);

                        }

                        found = TRUE;

                        break;

                    case 'D':

                        if (!strncmp(arg_cur, "DEBUG: ",

                                     sizeof("DEBUG: ") - 1)) {

                            msg_log_level = LOG_DEBUG;

                        }

                        if (ctx == NULL) {

                            memmove(arg_cur, arg_cur + sizeof("DEBUG: ") - 1,

                                    strlen(arg_cur + sizeof("DEBUG: ") - 1) + 1);

                        }

                        found = TRUE;

                        break;

                    }

                }

            }

            break;

        case '#': case '-': case ' ': case '+': case '\'': case 'I': case '.':

        case '0': case '1': case '2': case '3': case '4':

        case '5': case '6': case '7': case '8': case '9':

        case '*':

            break;

        case 'l':

        case 'z':

        case 't':

        case 'j':

        case 'd': case 'i':

        case 'o':

        case 'u':

        case 'x': case 'X':

        case 'e': case 'E':

        case 'f': case 'F':

        case 'g': case 'G':

        case 'a': case 'A':

        case 'c':

        case 'p':

            if (scan_state == escan_seenpercent) {

                (void) va_arg(aq, void *);  /* skip forward */

                scan_state = escan_seennothing;

            }

            break;

        default:

            scan_state = escan_seennothing;

            break;

        }

    }

    if (log_level != NULL) {

        /* intention of the following offset is:

           cibadmin -V -> start showing INFO labelled messages */

        if (*log_level + 4 >= msg_log_level) {

            vfprintf(stderr, fmt, ap);

        }

    } else {

        CRM_XML_LOG_BASE(msg_log_level, TRUE, 0, "CIB upgrade: ", fmt, ap);

    }

    va_end(aq);

    va_end(ap);