redis.c

Go to the documentation of this file.

/*
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or (at
 *   your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
/**
 * $Id: 4fdca8dc62bd55b83baa02a4f9e462587c2be228 $
 * @file redis.c
 * @brief Common functions for interacting with Redis via hiredis
 *
 * @copyright 2015 Arran Cudbard-Bell (a.cudbardb@freeradius.org)
 * @copyright 2000,2006,2015 The FreeRADIUS server project
 * @copyright 2011 TekSavvy Solutions (gabe@teksavvy.com)
 */
#include <freeradius-devel/redis/base.h>
#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/value.h>
#include "attrs.h"
 
fr_table_num_sorted_t const redis_reply_types[] = {
        { L("array"),           REDIS_REPLY_ARRAY       },
        { L("error"),           REDIS_REPLY_ERROR       },
        { L("integer"),         REDIS_REPLY_INTEGER     },
        { L("nil"),             REDIS_REPLY_NIL         },
        { L("status"),          REDIS_REPLY_STATUS      },
        { L("string"),          REDIS_REPLY_STRING      }
};
size_t redis_reply_types_len = NUM_ELEMENTS(redis_reply_types);
 
fr_table_num_sorted_t const redis_rcodes[] = {
        { L("ask"),             REDIS_RCODE_ASK         },
        { L("error"),           REDIS_RCODE_ERROR       },
        { L("move"),            REDIS_RCODE_MOVE        },
        { L("reconnect"),       REDIS_RCODE_RECONNECT   },
        { L("success"),         REDIS_RCODE_SUCCESS     },
        { L("try again"),       REDIS_RCODE_TRY_AGAIN   }
};
size_t redis_rcodes_len = NUM_ELEMENTS(redis_rcodes);
 
fr_dict_t const *dict_redis;
 
extern fr_dict_autoload_t redis_base_dict[];
fr_dict_autoload_t redis_base_dict[] = {
        { .out = &dict_redis, .proto = "redis" },
        DICT_AUTOLOAD_TERMINATOR
};
 
fr_dict_attr_t const *attr_redis_packet_type;
fr_dict_attr_t const *attr_redis_log_prefix;
fr_dict_attr_t const *attr_redis_max_nodes;
fr_dict_attr_t const *attr_redis_bootstrap_node;
fr_dict_attr_t const *attr_redis_bootstrap_port;
fr_dict_attr_t const *attr_redis_username;
fr_dict_attr_t const *attr_redis_password;
fr_dict_attr_t const *attr_redis_cluster_id;
fr_dict_attr_t const *attr_redis_shard;
fr_dict_attr_t const *attr_redis_slot;
fr_dict_attr_t const *attr_redis_slot_start;
fr_dict_attr_t const *attr_redis_slot_end;
fr_dict_attr_t const *attr_redis_node;
fr_dict_attr_t const *attr_redis_node_endpoint;
fr_dict_attr_t const *attr_redis_node_port;
fr_dict_attr_t const *attr_redis_node_role;
fr_dict_attr_t const *attr_redis_force_update;
fr_dict_attr_t const *attr_redis_use_tls;
fr_dict_attr_t const *attr_redis_tls_conf;
 
extern fr_dict_attr_autoload_t redis_base_dict_attr[];
fr_dict_attr_autoload_t redis_base_dict_attr[] = {
        { .out = &attr_redis_packet_type, .name = "Packet-Type", .type = FR_TYPE_UINT32, .dict = &dict_redis },
        { .out = &attr_redis_log_prefix, .name = "Log-Prefix", .type = FR_TYPE_STRING, .dict = &dict_redis },
        { .out = &attr_redis_max_nodes, .name = "Max-Nodes", .type = FR_TYPE_UINT8, .dict = &dict_redis },
        { .out = &attr_redis_bootstrap_node, .name = "Bootstrap-Node", .type = FR_TYPE_STRING, .dict = &dict_redis },
        { .out = &attr_redis_bootstrap_port, .name = "Bootstrap-Port", .type = FR_TYPE_UINT16, .dict = &dict_redis },
        { .out = &attr_redis_username, .name = "Username", .type = FR_TYPE_STRING, .dict = &dict_redis },
        { .out = &attr_redis_password, .name = "Password", .type = FR_TYPE_STRING, .dict = &dict_redis },
        { .out = &attr_redis_cluster_id, .name = "Cluster-Id", .type = FR_TYPE_UINT16, .dict = &dict_redis },
        { .out = &attr_redis_shard, .name = "Shard", .type = FR_TYPE_TLV, .dict = &dict_redis },
        { .out = &attr_redis_slot, .name = "Shard.Slot", .type = FR_TYPE_TLV, .dict = &dict_redis },
        { .out = &attr_redis_slot_start, .name = "Shard.Slot.Start", .type = FR_TYPE_UINT16, .dict = &dict_redis },
        { .out = &attr_redis_slot_end, .name = "Shard.Slot.End", .type = FR_TYPE_UINT16, .dict = &dict_redis },
        { .out = &attr_redis_node, .name = "Shard.Node", .type = FR_TYPE_TLV, .dict = &dict_redis },
        { .out = &attr_redis_node_endpoint, .name = "Shard.Node.Endpoint", .type = FR_TYPE_STRING, .dict = &dict_redis },
        { .out = &attr_redis_node_port, .name = "Shard.Node.Port", .type = FR_TYPE_UINT16, .dict = &dict_redis },
        { .out = &attr_redis_node_role, .name = "Shard.Node.Role", .type = FR_TYPE_UINT8, .dict = &dict_redis },
        { .out = &attr_redis_force_update, .name = "Force-Update", .type = FR_TYPE_BOOL, .dict = &dict_redis },
        { .out = &attr_redis_use_tls, .name = "Use-TLS", .type = FR_TYPE_BOOL, .dict = &dict_redis },
        { .out = &attr_redis_tls_conf, .name = "TLS-Conf", .type = FR_TYPE_UINT64, .dict = &dict_redis },
 
        DICT_AUTOLOAD_TERMINATOR
};
 
/** Print the version of libhiredis the server was built against
 *
 */
void fr_redis_version_print(void)
{
        INFO("libfreeradius-redis: libhiredis version: %i.%i.%i", HIREDIS_MAJOR, HIREDIS_MINOR, HIREDIS_PATCH);
}
 
static int _redis_dict_init(UNUSED void *uctx)
{
        if (fr_dict_autoload(redis_base_dict) < 0) {
                PERROR("%s", __FUNCTION__);
                return -1;
        }
        if (fr_dict_attr_autoload(redis_base_dict_attr) < 0) {
                PERROR("%s", __FUNCTION__);
                fr_dict_autofree(redis_base_dict);
                return -1;
        }
 
        return 0;
}
 
static int _redis_dict_free(UNUSED void *uctx)
{
        fr_dict_autofree(redis_base_dict);
        return 0;
}
 
/** Load the Redis dictionaries
 *
 */
int redis_dict_init(void)
{
        int ret;
 
        fr_atexit_global_once_ret(&ret, _redis_dict_init, _redis_dict_free, NULL);
 
        return ret;
}
 
/** Print the response data in a useful treelike form
 *
 * @param[in] lvl to print data at.
 * @param[in] reply to print.
 * @param[in] request The current request.
 * @param[in] idx Response number.
 * @param[in] status code from processing last reply.
 */
void fr_redis_reply_print(fr_log_lvl_t lvl, redisReply *reply, request_t *request, int idx, fr_redis_rcode_t status)
{
        size_t i = 0;
 
        if (!reply) return;
 
        switch (reply->type) {
        case REDIS_REPLY_ERROR:
                if (status == REDIS_RCODE_MOVE) {
                        ROPTIONAL(RWARN, WARN, "(%i) warn    : %s", idx, reply->str);
                } else {
                        ROPTIONAL(REDEBUG, ERROR, "(%i) error   : %s", idx, reply->str);
                }
                break;
 
        case REDIS_REPLY_STATUS:
                ROPTIONAL(RDEBUGX, DEBUGX, lvl, "(%i) status  : %s", idx, reply->str);
                break;
 
        case REDIS_REPLY_STRING:
                ROPTIONAL(RDEBUGX, DEBUGX, lvl, "(%i) string  : %s", idx, reply->str);
                break;
 
        case REDIS_REPLY_INTEGER:
                ROPTIONAL(RDEBUGX, DEBUGX, lvl, "(%i) integer : %lld", idx, reply->integer);
                break;
 
        case REDIS_REPLY_NIL:
                ROPTIONAL(RDEBUGX, DEBUGX, lvl, "(%i) nil", idx);
                break;
 
        case REDIS_REPLY_ARRAY:
                ROPTIONAL(RDEBUGX, DEBUGX, lvl, "(%i) array[%zu]", idx, reply->elements);
                for (i = 0; i < reply->elements; i++) {
                        if (request) RINDENT();
                        fr_redis_reply_print(lvl, reply->element[i], request, i, status);
                        if (request) REXDENT();
                }
                break;
        }
}
 
/** Convert a string or integer type to #fr_value_box_t of specified type
 *
 * Will work with REDIS_REPLY_STRING (which is converted to #FR_TYPE_STRING
 * then cast to dst_type), or REDIS_REPLY_INTEGER (which is converted to
 * #FR_TYPE_UINT64, then cast to dst_type).
 *
 * @note Any unsupported types will trigger an assert. You must check the
 *      reply type prior to calling this function.
 *
 * @param[in,out] ctx           to allocate any buffers in.
 * @param[out] out              Where to write the cast type.
 * @param[in] reply             to process.
 * @param[in] dst_type          to convert to. May be FR_TYPE_VOID
 *                              to infer type.
 * @param[in] dst_enumv         Used to convert string types to
 *                              integers for attribute with enumerated
 *                              values.
 * @param[in] box_error         If true then REDIS_REPLY_ERROR will be
 *                              copied to a box, otherwise we'll return
 *                              and error with the contents of the error
 *                              available on the thread local error stack.
 * @param[in] shallow           If true, we shallow copy strings.
 * @return
 *      - 1 if we received a NIL reply.
 *      - 0 on success.
 *      - -1 on cast or parse failure.
 */
int fr_redis_reply_to_value_box(TALLOC_CTX *ctx, fr_value_box_t *out, redisReply *reply,
                                fr_type_t dst_type, fr_dict_attr_t const *dst_enumv,
                                bool box_error, bool shallow)
{
        fr_value_box_t  in;
        fr_value_box_t  *to_cast;
 
        if (dst_type != FR_TYPE_VOID) {
                fr_value_box_init_null(&in);
                to_cast = &in;
        } else {
                to_cast = out;
        }
 
        switch (reply->type) {
        case REDIS_REPLY_NIL:
                fr_value_box_init(out, FR_TYPE_NULL, NULL, false);
                return 1;
 
        /*
         *      Try and convert the integer to the smallest
         *      and simplest type possible, to give the cast
         *      the greatest chance of success.
         */
        case REDIS_REPLY_INTEGER:
                if (reply->integer < INT32_MIN) {       /* 64bit signed */
                        fr_value_box(to_cast, (int64_t) reply->integer, true);
                }
                else if (reply->integer < INT16_MIN) {  /* 32bit signed */
                        fr_value_box(to_cast, (int32_t) reply->integer, true);
                }
                else if (reply->integer < INT8_MIN) {   /* 16bit signed */
                        fr_value_box(to_cast, (int16_t) reply->integer, true);
                }
                else if (reply->integer < 0) {  /* 8bit signed */
                        fr_value_box(to_cast, (int8_t) reply->integer, true);
                }
                else if (reply->integer > UINT32_MAX) { /* 64bit unsigned */
                        fr_value_box(to_cast, (uint64_t) reply->integer, true);
                }
                else if (reply->integer > UINT16_MAX) { /* 32bit unsigned */
                        fr_value_box(to_cast, (uint32_t) reply->integer, true);
                }
                else if (reply->integer > UINT8_MAX) {  /* 16bit unsigned */
                        fr_value_box(to_cast, (uint16_t) reply->integer, true);
                }
                else {                                  /* 8bit unsigned */
                        fr_value_box(to_cast, (uint8_t) reply->integer, true);
                }
                break;
 
#if HIREDIS_MAJOR >= 1
        case REDIS_REPLY_DOUBLE:
                /* reply->str is \0 terminated in this case */
                fr_value_box(to_cast, strtod(reply->str, NULL), true);
                break;
 
        case REDIS_REPLY_BOOL:
                fr_value_box(to_cast, (bool)reply->integer, true);
                break;
#endif
 
        case REDIS_REPLY_ERROR:
                if (!box_error) {
                        fr_strerror_printf("Redis error: %pV",
                                           fr_box_strvalue_len(reply->str, reply->len));
                        return -1;
                }
                FALL_THROUGH;
 
#if HIREDIS_MAJOR >= 1
        case REDIS_REPLY_BIGNUM:        /* FIXME - Could try and convert to integer ? */
#endif
        case REDIS_REPLY_STRING:
        case REDIS_REPLY_STATUS:
                fr_value_box_init(out, FR_TYPE_STRING, NULL, false);
 
                if (shallow) {
                        fr_value_box_bstrndup_shallow(to_cast, NULL, reply->str, reply->len, true);
                } else {
                        if (fr_value_box_bstrndup(to_cast->talloced ? to_cast : ctx, to_cast, NULL,
                                                  reply->str, reply->len, true) < 0) return -1;
                }
                break;
 
#if HIREDIS_MAJOR >= 1
        case REDIS_REPLY_VERB:
        {
                fr_value_box_t *verb, *vtype;
 
                fr_value_box_init(out, FR_TYPE_GROUP, NULL, true);
 
                verb = fr_value_box_alloc(ctx, FR_TYPE_STRING, NULL);
                if (unlikely(!verb)) {
                        fr_strerror_const("Out of memory");
                        return -1;
                }
                if (fr_value_box_bstrndup(verb, verb, NULL, reply->str, reply->len, true) < 0) return -1;
                fr_value_box_list_insert_head(&out->vb_group, verb);
 
                vtype = fr_value_box_alloc(ctx, FR_TYPE_STRING, NULL);
                if (unlikely(!vtype)) {
                        fr_strerror_const("Out of memory");
                        talloc_free(verb);
                        return -1;
                }
                if (fr_value_box_strdup(ctx, vtype, NULL, reply->vtype, true) < 0) return -1;
                fr_value_box_list_insert_head(&out->vb_group, vtype);
 
        }
                break;
#endif
 
#if HIREDIS_MAJOR >= 1
        case REDIS_REPLY_SET:
        case REDIS_REPLY_MAP:
        case REDIS_REPLY_PUSH:
#endif
        case REDIS_REPLY_ARRAY:
        {
                fr_value_box_t *vb;
                size_t i;
 
                fr_value_box_init(out, FR_TYPE_GROUP, NULL, true);
 
                for (i = 0; i < reply->elements; i++) {
                        vb = fr_value_box_alloc_null(ctx);
                        if (unlikely(!vb)) {
                        array_error:
                                fr_value_box_list_talloc_free(&out->vb_group);
                                return -1;
                        }
 
                        if (fr_redis_reply_to_value_box(vb, vb, reply->element[i],
                                                        FR_TYPE_VOID, NULL, box_error, shallow) < 0) goto array_error;
                        fr_value_box_list_insert_tail(&out->vb_group, vb);
                }
        }
        }
 
        if ((dst_type != FR_TYPE_VOID) && (fr_value_box_cast(ctx, out, dst_type, dst_enumv, to_cast) < 0)) return -1;
 
        return 0;
}
 
/** Convert a pair of redis reply objects to a map
 *
 * The maps can then be applied using #map_to_request.
 *
 * @param[in,out] ctx to allocate maps in.
 * @param[out] out Where to write the head of the new maps list.
 * @param[in] request The current request.
 * @param[in] key to process.
 * @param[in] op to process.
 * @param[in] value to process.
 * @return
 *      - 0 on success.
 *      - -1 on failure.
 */
int fr_redis_reply_to_map(TALLOC_CTX *ctx, map_list_t *out, request_t *request,
                          redisReply *key, redisReply *op, redisReply *value)
{
        map_t   *map = NULL;
        ssize_t         slen;
 
        if (key->type != REDIS_REPLY_STRING) {
                REDEBUG("Bad key type, expected string, got %s",
                        fr_table_str_by_value(redis_reply_types, key->type, "<UNKNOWN>"));
        error:
                TALLOC_FREE(map);
                return -1;
        }
 
        if (op->type != REDIS_REPLY_STRING) {
                REDEBUG("Bad op type, expected string, got %s",
                        fr_table_str_by_value(redis_reply_types, op->type, "<UNKNOWN>"));
                goto error;
        }
 
        RDEBUG3("Got key   : %s", key->str);
        RDEBUG3("Got op    : %s", op->str);
        RDEBUG3("Got value : %pV", fr_box_strvalue_len(value->str, value->len));
 
        MEM(map = talloc_zero(ctx, map_t));
        slen = tmpl_afrom_attr_str(map, NULL, &map->lhs, key->str,
                                   &(tmpl_rules_t){
                                        .attr = {
                                                .dict_def = request->local_dict,
                                                .list_def = request_attr_request
                                        }
                                   });
        if (slen <= 0) {
                REMARKER(key->str, -slen, "%s", fr_strerror());
                goto error;
        }
 
        map->op = fr_table_value_by_str(fr_tokens_table, op->str, T_INVALID);
        if (map->op == T_INVALID) {
                REDEBUG("Invalid operator \"%s\"", op->str);
                goto error;
        }
 
        switch (value->type) {
        case REDIS_REPLY_STRING:
        case REDIS_REPLY_INTEGER:
        {
                fr_value_box_t vb = FR_VALUE_BOX_INITIALISER_NULL(vb);
 
                /* Logs own errors */
                if (fr_redis_reply_to_value_box(map, &vb, value,
                                                tmpl_attr_tail_da(map->lhs)->type, tmpl_attr_tail_da(map->lhs), false, false) < 0) {
                        RPEDEBUG("Failed converting Redis data");
                        goto error;
                }
 
                /* This will only fail only memory allocation errors */
                if (tmpl_afrom_value_box(map, &map->rhs, &vb, true) < 0) goto error;
        }
                break;
 
        default:
                REDEBUG("Bad value type, expected string or integer, got %s",
                        fr_table_str_by_value(redis_reply_types, value->type, "<UNKNOWN>"));
                goto error;
 
        }
        MAP_VERIFY(map);
 
        map_list_insert_tail(out, map);
 
        return 0;
}
 
/** Add a single map pair to an existing command string as three elements
 *
 * - Integer types will be encoded as integers.
 * - Strings and octets will be encoded in their raw form.
 * - Other types will be converted to their printable form and will be encoded as strings.
 *
 * @note lhs must be a #TMPL_TYPE_ATTR.
 * @note rhs must be a #TMPL_TYPE_DATA.
 *
 * @param pool to allocate any buffers in.
 * @param out Where to write pointers to the member of the tuple. Unused elements should be
 *      a multiple of three, and it should have at least three unused elements.
 * @param out_len Where to write the size of the data pointed to by the equivalent index
 *      in the out array.
 * @param map to convert.
 * @return
 *      0 on success.
 *      -1 on failure.
 */
int fr_redis_tuple_from_map(TALLOC_CTX *pool, char const *out[], size_t out_len[], map_t *map)
{
        char            *new;
 
        char            key_buf[256];
        fr_sbuff_t      key_buf_sbuff = FR_SBUFF_OUT(key_buf, sizeof(key_buf));
        char            *key;
        size_t          key_len;
        ssize_t         slen;
 
        fr_assert(tmpl_is_attr(map->lhs));
        fr_assert(tmpl_is_data(map->rhs));
 
        slen = tmpl_print(&key_buf_sbuff, map->lhs, NULL);
        if (slen < 0) {
                fr_strerror_printf("Key too long.  Must be < " STRINGIFY(sizeof(key_buf)) " "
                                   "bytes, got %zu bytes", (size_t)(slen * -1));
                return -1;
        }
        key_len = (size_t)slen;
        key = talloc_bstrndup(pool, fr_sbuff_start(&key_buf_sbuff), key_len);
        if (!key) return -1;
 
        switch (tmpl_value_type(map->rhs)) {
        case FR_TYPE_STRING:
        case FR_TYPE_OCTETS:
                out[2] = tmpl_value(map->rhs)->datum.ptr;
                out_len[2] = tmpl_value_length(map->rhs);
                break;
 
        /*
         *      For everything else we get the string representation
         */
        default:
                fr_value_box_aprint(pool, &new, tmpl_value(map->rhs), NULL);
                if (!new) {
                        talloc_free(key);
                        return -1;
                }
                out[2] = new;
                out_len[2] = talloc_strlen(new);
                break;
        }
 
        out[0] = key;
        out_len[0] = key_len;
        out[1] = fr_table_str_by_value(fr_tokens_table, map->op, NULL);
        out_len[1] = strlen(out[1]);
 
        return 0;
}
 
/** Parse the reply from the Redis command INFO SERVER to extract the version
 *
 * @param[out] out Where to write the version string.
 * @param[in] out_len Length of the version string buffer.
 * @param[in] reply Redis reply to parse
 * @return
 *      - 0 on success.
 *      - -1 on command/response mismatch or command error.
 */
int fr_redis_parse_version(char *out, size_t out_len, redisReply *reply)
{
        fr_sbuff_t      sbuff;
 
        if (reply->type != REDIS_REPLY_STRING) {
                fr_strerror_printf("Bad value type, expected string or integer, got %s",
                                   fr_table_str_by_value(redis_reply_types, reply->type, "<UNKNOWN>"));
        error:
                return -1;
        }
 
        fr_sbuff_init_in(&sbuff, reply->str, reply->len);
 
        if (!fr_sbuff_adv_to_str_literal(&sbuff, SIZE_MAX, "redis_version:")) {
                fr_strerror_const("Response did not contain version string");
                goto error;
        }
        fr_sbuff_advance(&sbuff, sizeof("redis_version:") -1);
 
        if (fr_sbuff_out_bstrncpy_until(&FR_SBUFF_OUT(out, out_len), &sbuff, SIZE_MAX, &FR_SBUFF_TERMS(L("\r\n")), NULL) == 0) {
                fr_strerror_printf("Failed extracting version string");
                goto error;
        }
 
        return 0;
}
 
/** Convert version string into a 32bit unsigned integer for comparisons
 *
 * @param[in] version string to parse.
 * @return 32bit unsigned integer representing the version string.
 */
uint32_t fr_redis_version_num(char const *version)
{
        unsigned long num;
        uint32_t ret;
        char const *p = version;
        char *q;
 
        num = strtoul(p, &q, 10);
        if (num > UINT8_MAX) {
                fr_strerror_printf("Major version number %lu greater than " STRINGIFY(UINT8_MAX), num);
                return 0;
        }
 
        if ((p == q) || (q[0] != '.')) {
                fr_strerror_printf("Trailing garbage in Redis version \"%s\"", q);
                return 0;
        }
        ret = num << 24;
        p = q + 1;
 
        num = strtoul(p, &q, 10);
        if (num > UINT8_MAX) {
                fr_strerror_printf("Minor version number %lu greater than " STRINGIFY(UINT8_MAX), num);
                return 0;
        }
 
        if ((p == q) || (q[0] != '.')) {
                fr_strerror_printf("Trailing garbage in Redis version \"%s\"", q);
                return 0;
        }
        ret |= num << 16;
        p = q + 1;
 
        num = strtoul(p, &q, 10);
        if (num > UINT16_MAX) {
                fr_strerror_printf("Minor version number %lu greater than " STRINGIFY(UINT16_MAX), num);
                return 0;
        }
 
        if ((p == q) || (q[0] != '\0')) {
                fr_strerror_printf("Trailing garbage in Redis version \"%s\"", q);
                return 0;
        }
 
        return ret | num;
}