jk_status.c

来自「以便Apache与其他服务进行整合 Mod_JK安装」· C语言 代码 · 共 1,753 行 · 第 1/5 页

               "retrieved string arg '%s' as '%s'%s",
               param, *result ? *result : "(null)",
               rv == JK_FALSE ? " (default)" : "");
    return rv;
}

static int status_get_int(status_endpoint_t *p,
                          const char *param,
                          int def,
                          jk_logger_t *l)
{
    const char *arg;
    int rv = def;

    if (status_get_string(p, param, NULL, &arg, l) == JK_TRUE) {
        rv = atoi(arg);
    }
    return rv;
}

static int status_get_bool(status_endpoint_t *p,
                           const char *param,
                           int def,
                           jk_logger_t *l)
{
    const char *arg;

    if (status_get_string(p, param, NULL, &arg, l) == JK_TRUE) {
        return jk_get_bool_code(arg, def);
    }
    return def;
}

static const char *status_cmd_text(int cmd)
{
    return cmd_type[cmd];
}

static int status_cmd_int(const char *cmd)
{
    if (!cmd)
        return JK_STATUS_CMD_DEF;
    if (!strcmp(cmd, JK_STATUS_CMD_TEXT_LIST))
        return JK_STATUS_CMD_LIST;
    else if (!strcmp(cmd, JK_STATUS_CMD_TEXT_SHOW))
        return JK_STATUS_CMD_SHOW;
    else if (!strcmp(cmd, JK_STATUS_CMD_TEXT_EDIT))
        return JK_STATUS_CMD_EDIT;
    else if (!strcmp(cmd, JK_STATUS_CMD_TEXT_UPDATE))
        return JK_STATUS_CMD_UPDATE;
    else if (!strcmp(cmd, JK_STATUS_CMD_TEXT_RESET))
        return JK_STATUS_CMD_RESET;
    else if (!strcmp(cmd, JK_STATUS_CMD_TEXT_VERSION))
        return JK_STATUS_CMD_VERSION;
    else if (!strcmp(cmd, JK_STATUS_CMD_TEXT_RECOVER))
        return JK_STATUS_CMD_RECOVER;
    return JK_STATUS_CMD_UNKNOWN;
}

static const char *status_mime_text(int mime)
{
    return mime_type[mime];
}

static int status_mime_int(const char *mime)
{
    if (!mime)
        return JK_STATUS_MIME_DEF;
    if (!strcmp(mime, JK_STATUS_MIME_TEXT_HTML))
        return JK_STATUS_MIME_HTML;
    else if (!strcmp(mime, JK_STATUS_MIME_TEXT_XML))
        return JK_STATUS_MIME_XML;
    else if (!strcmp(mime, JK_STATUS_MIME_TEXT_TXT))
        return JK_STATUS_MIME_TXT;
    else if (!strcmp(mime, JK_STATUS_MIME_TEXT_PROP))
        return JK_STATUS_MIME_PROP;
    return JK_STATUS_MIME_UNKNOWN;
}

static void status_start_form(jk_ws_service_t *s,
                              status_endpoint_t *p,
                              const char *method,
                              int cmd,
                              jk_logger_t *l)
{

    int i;
    int sz;
    jk_map_t *m = p->req_params;

    if (method)
        jk_printf(s, JK_STATUS_FORM_START, method, s->req_uri);
    else
        return;
    if (cmd != JK_STATUS_CMD_UNKNOWN) {
        jk_printf(s, JK_STATUS_FORM_HIDDEN_STRING,
                  JK_STATUS_ARG_CMD, status_cmd_text(cmd));
    }

    sz = jk_map_size(m);
    for (i = 0; i < sz; i++) {
        const char *k = jk_map_name_at(m, i);
        const char *v = jk_map_value_at(m, i);
        if (strcmp(k, JK_STATUS_ARG_CMD) || cmd == JK_STATUS_CMD_UNKNOWN) {
            jk_printf(s, JK_STATUS_FORM_HIDDEN_STRING, k, v);
        }
    }
}

static void status_write_uri(jk_ws_service_t *s,
                             status_endpoint_t *p,
                             const char *text,
                             int cmd, int mime,
                             const char *worker, const char *sub_worker,
                             unsigned int add_options, unsigned int rm_options,
                             const char *attribute,
                             jk_logger_t *l)
{
    int i;
    int sz;
    int started = 0;
    int from;
    int prev;
    unsigned int opt = 0;
    const char *arg;
    jk_map_t *m = p->req_params;

    if (text)
        jk_puts(s, "<a href=\"");
    jk_puts(s, s->req_uri);
    status_get_string(p, JK_STATUS_ARG_FROM, NULL, &arg, l);
    from = status_cmd_int(arg);
    status_get_string(p, JK_STATUS_ARG_CMD, NULL, &arg, l);
    prev = status_cmd_int(arg);
    if (cmd == JK_STATUS_CMD_UNKNOWN) {
        if (prev == JK_STATUS_CMD_UPDATE ||
            prev == JK_STATUS_CMD_RESET ||
            prev == JK_STATUS_CMD_RECOVER) {
            cmd = from;
        }
    }
    if (cmd != JK_STATUS_CMD_UNKNOWN) {
        jk_printf(s, "%s%s=%s", started ? "&amp;" : "?",
                  JK_STATUS_ARG_CMD, status_cmd_text(cmd));
        if (cmd == JK_STATUS_CMD_EDIT ||
            cmd == JK_STATUS_CMD_RESET ||
            cmd == JK_STATUS_CMD_RECOVER) {
            jk_printf(s, "%s%s=%s", "&amp;",
                      JK_STATUS_ARG_FROM, status_cmd_text(prev));
        }
        started=1;
    }
    if (mime != JK_STATUS_MIME_UNKNOWN) {
        jk_printf(s, "%s%s=%s", started ? "&amp;" : "?",
                  JK_STATUS_ARG_MIME, status_mime_text(mime));
        started=1;
    }
    if (worker && worker[0]) {
        jk_printf(s, "%s%s=%s", started ? "&amp;" : "?",
                  JK_STATUS_ARG_WORKER, worker);
        started=1;
    }
    if (sub_worker && sub_worker[0]) {
        jk_printf(s, "%s%s=%s", started ? "&amp;" : "?",
                  JK_STATUS_ARG_SUB_WORKER, sub_worker);
        started=1;
    }
    if (attribute && attribute[0]) {
        jk_printf(s, "%s%s=%s", started ? "&amp;" : "?",
                  JK_STATUS_ARG_ATTRIBUTE, attribute);
        started=1;
    }

    sz = jk_map_size(m);
    for (i = 0; i < sz; i++) {
        const char *k = jk_map_name_at(m, i);
        const char *v = jk_map_value_at(m, i);
        if (!strcmp(k, JK_STATUS_ARG_CMD) && cmd != JK_STATUS_CMD_UNKNOWN) {
            continue;
        }
        if (!strcmp(k, JK_STATUS_ARG_MIME) && mime != JK_STATUS_MIME_UNKNOWN) {
            continue;
        }
        if (!strcmp(k, JK_STATUS_ARG_FROM)) {
            continue;
        }
        if (!strcmp(k, JK_STATUS_ARG_WORKER) && worker) {
            continue;
        }
        if (!strcmp(k, JK_STATUS_ARG_SUB_WORKER) && sub_worker) {
            continue;
        }
        if (!strcmp(k, JK_STATUS_ARG_ATTRIBUTE) && attribute) {
            continue;
        }
        if (!strcmp(k, JK_STATUS_ARG_ATTRIBUTE) && cmd != JK_STATUS_CMD_UPDATE && cmd != JK_STATUS_CMD_EDIT) {
            continue;
        }
        if (!strncmp(k, JK_STATUS_ARG_MULT_VALUE_BASE, 3) && cmd != JK_STATUS_CMD_UPDATE) {
            continue;
        }
        if (strlen(k) == 2 && (k[0] == 'l' || k[0] == 'w') && cmd != JK_STATUS_CMD_UPDATE) {
            continue;
        }
        if (!strcmp(k, JK_STATUS_ARG_OPTIONS)) {
            opt = atoi(v);
            continue;
        }
        jk_printf(s, "%s%s=%s", started ? "&amp;" : "?", k, v);
        started=1;
    }
    if (opt | add_options | rm_options)
        jk_printf(s, "%s%s=%u", started ? "&amp;" : "?",
                  JK_STATUS_ARG_OPTIONS, (opt | add_options) & ~rm_options);
    if (text)
        jk_putv(s, "\">", text, "</a>", NULL);
}

static int status_parse_uri(jk_ws_service_t *s,
                            status_endpoint_t *p,
                            jk_logger_t *l)
{
    jk_map_t *m;
    status_worker_t *w = p->worker;
#ifdef _REENTRANT
    char *lasts;
#endif
    char *param;
    char *query;

    JK_TRACE_ENTER(l);

    if (!jk_map_alloc(&(p->req_params))) {
        jk_log(l, JK_LOG_ERROR,
               "Status worker '%s' could not alloc map for request parameters",
               w->name);
        JK_TRACE_EXIT(l);
        return JK_FALSE;
    }
    if (!s->query_string) {
        if (JK_IS_DEBUG_LEVEL(l))
            jk_log(l, JK_LOG_DEBUG,
                   "Status worker '%s' query string is empty",
                   w->name);
        JK_TRACE_EXIT(l);
        return JK_TRUE;
    }
    m = p->req_params;
    query = jk_pool_strdup(s->pool, s->query_string);
    if (!query) {
        jk_log(l, JK_LOG_ERROR,
               "Status worker '%s' could not copy string",
               w->name);
        JK_TRACE_EXIT(l);
        return JK_FALSE;
    }
#ifdef _REENTRANT
    for (param = strtok_r(query, "&", &lasts);
         param; param = strtok_r(NULL, "&", &lasts)) {
#else
    for (param = strtok(query, "&"); param; param = strtok(NULL, "&")) {
#endif
        char *key = jk_pool_strdup(s->pool, param);
        char *value;
        if (!key) {
            jk_log(l, JK_LOG_ERROR,
                   "Status worker '%s' could not copy string",
                   w->name);
            JK_TRACE_EXIT(l);
            return JK_FALSE;
        }
        value = strchr(key, '=');
        if (value) {
            char *off;
            *value = '\0';
            value++;
    /* XXX Depending on the params values, we might need to trim and decode */
    /* XXX For now we simply mask special chars with '@' to prevent cross code injection */
            off = value;
            while ((off = strpbrk(off, JK_STATUS_ESC_CHARS)))
                off[0] = '@';
            if (strlen(key)) {
                if (JK_IS_DEBUG_LEVEL(l))
                    jk_log(l, JK_LOG_DEBUG,
                           "Status worker '%s' adding request param '%s' with value '%s'",
                           w->name, key, value);
                jk_map_put(m, key, value, NULL);
            }
        }
    }

    JK_TRACE_EXIT(l);
    return JK_TRUE;
}

static int fetch_worker_and_sub_worker(status_endpoint_t *p,
                                       const char *operation,
                                       const char **worker,
                                       const char **sub_worker,
                                       jk_logger_t *l)
{
    status_worker_t *w = p->worker;

    JK_TRACE_ENTER(l);
    status_get_string(p, JK_STATUS_ARG_WORKER, NULL, worker, l);
    status_get_string(p, JK_STATUS_ARG_SUB_WORKER, NULL, sub_worker, l);
    if (JK_IS_DEBUG_LEVEL(l))
        jk_log(l, JK_LOG_DEBUG,
               "Status worker '%s' %s worker '%s' sub worker '%s'",
               w->name, operation,
               *worker ? *worker : "(null)", *sub_worker ? *sub_worker : "(null)");
    JK_TRACE_EXIT(l);
    return JK_TRUE;
}

static int check_valid_lb(jk_ws_service_t *s,
                          status_endpoint_t *p,
                          jk_worker_t *jw,
                          const char *worker,
                          lb_worker_t **lbp,
                          int implemented,
                          jk_logger_t *l)
{
    status_worker_t *w = p->worker;

    JK_TRACE_ENTER(l);
    if (jw->type != JK_LB_WORKER_TYPE) {
        if (implemented) {
            jk_log(l, JK_LOG_WARNING,
                   "Status worker '%s' worker type of worker '%s' has no sub workers",
                   w->name, worker);
            p->msg = "worker type has no sub workers";
        }
        else {
            jk_log(l, JK_LOG_WARNING,
                   "Status worker '%s' worker type of worker '%s' not implemented",
                   w->name, worker);
                   p->msg = "worker type not implemented";
        }
        JK_TRACE_EXIT(l);
        return JK_FALSE;
    }
    *lbp = (lb_worker_t *)jw->worker_private;
    if (!*lbp) {
        jk_log(l, JK_LOG_WARNING,
               "Status worker '%s' lb structure of worker '%s' is (null)",
               w->name, worker);
        p->msg = "lb structure is (null)";
        JK_TRACE_EXIT(l);
        return JK_FALSE;
    }