Beispiel #1
0
/*
 * This function takes mdata->to_regexp and copies it into a struct
 * sol_buffer, with all the number ref entries already replaced by the
 * due text. It assumes that @a buf is already initialized.
 */
static int
get_unescaped_regexp_replacement_str(struct string_regexp_replace_data *mdata,
    struct sol_buffer *buf,
    int *match_vector,
    size_t match_cnt)
{
    int r;
    struct sol_str_slice slice;
    char *ptr = mdata->to_regexp;

    SOL_NULL_CHECK(buf, -EINVAL);

    /* \g<number> or \<number> syntax. Go on as far as numbers are in
     * [0-9] range. Leading zeros are permitted.
     */
    while (*ptr) {
        if (*ptr == '\\') {
            int n;
            uint64_t grp_num = 0;

            ptr++;

            if (*ptr == 'g')
                ptr++;

            for (; (n = *ptr - '0') >= 0 && n <= 9; ptr++) {
                if (!grp_num && !n) {
                    continue;
                }

                r = sol_util_uint64_mul(grp_num, 10, &grp_num);
                SOL_INT_CHECK_GOTO(r, < 0, err);

                r = sol_util_uint64_add(grp_num, n, &grp_num);
                SOL_INT_CHECK_GOTO(r, < 0, err);
            }

            if (!grp_num || grp_num > match_cnt) {
                sol_flow_send_error_packet(mdata->node, EINVAL,
                    "Could not process '%s' pattern's reference "
                    "to non-existent subpattern on '%s'",
                    mdata->to_regexp, mdata->regexp);
                r = -EINVAL;
                goto err;
            }

            slice = SOL_STR_SLICE_STR(mdata->orig_string
                + match_vector[grp_num * 2],
                match_vector[grp_num * 2 + 1] - match_vector[grp_num * 2]);
            r = sol_buffer_append_slice(buf, slice);
            SOL_INT_CHECK_GOTO(r, < 0, err);
        } else {
Beispiel #2
0
static int
token_get_uint64(const struct sol_json_token *token, uint64_t *value)
{
    const char *itr = token->start;
    uint64_t tmpvar = 0;

    if (*itr == '+')
        itr++;

    for (; itr < token->end; itr++) {
        const char c = *itr;
        if (c >= '0' && c <= '9') {
            int r;

            r = sol_util_uint64_mul(tmpvar, 10, &tmpvar);
            if (r < 0)
                goto overflow;

            r = sol_util_uint64_add(tmpvar, c - '0', &tmpvar);
            if (r < 0)
                goto overflow;
            continue;
        }
        *value = tmpvar; /* best effort */
        SOL_DBG("unexpected char '%c' at position %u of integer token %.*s",
            c, (unsigned)(itr - token->start),
            (int)sol_json_token_get_size(token), token->start);
        return -EINVAL;

overflow:
        *value = UINT64_MAX; /* best effort */
        SOL_DBG("number is too large at position %u of integer token %.*s",
            (unsigned)(itr - token->start),
            (int)sol_json_token_get_size(token), token->start);
        return -ERANGE;
    }

    *value = tmpvar;
    return 0;
}