SQL functions now use ssize_t so that they can indicate actual error conditions

A module expanding to a 0 length string is no longer considered and error condition

If a module xlat returns < 0 update sections will return fail

diff --git a/src/include/radiusd.h b/src/include/radiusd.h
index be4a27b..e8ad0ec 100644 (file)
--- a/src/include/radiusd.h
+++ b/src/include/radiusd.h
@@ -625,7 +625,7 @@ ssize_t radius_xlat(char *out, size_t outlen, REQUEST *request, char const *fmt,
 ssize_t radius_axlat(char **out, REQUEST *request, char const *fmt, RADIUS_ESCAPE_STRING escape,
                          void *escape_ctx);
                    
-typedef size_t (*RAD_XLAT_FUNC)(void *instance, REQUEST *, char const *, char *, size_t);
+typedef ssize_t (*RAD_XLAT_FUNC)(void *instance, REQUEST *, char const *, char *, size_t);
 int            xlat_register(char const *module, RAD_XLAT_FUNC func, RADIUS_ESCAPE_STRING escape,
                              void *instance);
 void           xlat_unregister(char const *module, RAD_XLAT_FUNC func,

diff --git a/src/main/listen.c b/src/main/listen.c
index 3689b87..e4987d9 100644 (file)
--- a/src/main/listen.c
+++ b/src/main/listen.c
@@ -76,9 +76,9 @@ static fr_protocol_t master_listen[RAD_LISTEN_MAX];
 /*
  *     Xlat for %{listen:foo}
  */
-static size_t xlat_listen(UNUSED void *instance, REQUEST *request,
-                      char const *fmt, char *out,
-                      size_t outlen)
+static ssize_t xlat_listen(UNUSED void *instance, REQUEST *request,
+                          char const *fmt, char *out,
+                          size_t outlen)
 {
        char const *value = NULL;
        CONF_PAIR *cp;
@@ -86,12 +86,14 @@ static size_t xlat_listen(UNUSED void *instance, REQUEST *request,
        if (!fmt || !out || (outlen < 1)) return 0;
 
        if (!request || !request->listener) {
+               RWDEBUG("No listener associated with this request");
                *out = '\0';
                return 0;
        }
 
        cp = cf_pair_find(request->listener->cs, fmt);
        if (!cp || !(value = cf_pair_value(cp))) {
+               RDEBUG("Listener does not contain config item \"%s\"", fmt);
                *out = '\0';
                return 0;
        }

diff --git a/src/main/mainconfig.c b/src/main/mainconfig.c
index 531032c..2b94c17 100644 (file)
--- a/src/main/mainconfig.c
+++ b/src/main/mainconfig.c
@@ -287,7 +287,7 @@ static size_t config_escape_func(UNUSED REQUEST *request, char *out, size_t outl
 /*
  *     Xlat for %{config:section.subsection.attribute}
  */
-static size_t xlat_config(UNUSED void *instance, REQUEST *request, char const *fmt, char *out, size_t outlen)
+static ssize_t xlat_config(UNUSED void *instance, REQUEST *request, char const *fmt, char *out, size_t outlen)
 {
        char const *value;
        CONF_PAIR *cp;
@@ -304,8 +304,9 @@ static size_t xlat_config(UNUSED void *instance, REQUEST *request, char const *f
        ci = cf_reference_item(request->root->config,
                               request->root->config, buffer);
        if (!ci || !cf_item_is_pair(ci)) {
+               REDEBUG("Config item \"%s\" does not exist", fmt);
                *out = '\0';
-               return 0;
+               return -1;
        }
 
        cp = cf_itemtopair(ci);
@@ -334,9 +335,7 @@ static size_t xlat_config(UNUSED void *instance, REQUEST *request, char const *f
 /*
  *     Xlat for %{client:foo}
  */
-static size_t xlat_client(UNUSED void *instance, REQUEST *request,
-                      char const *fmt, char *out,
-                      size_t outlen)
+static ssize_t xlat_client(UNUSED void *instance, REQUEST *request, char const *fmt, char *out, size_t outlen)
 {
        char const *value = NULL;
        CONF_PAIR *cp;
@@ -344,6 +343,7 @@ static size_t xlat_client(UNUSED void *instance, REQUEST *request,
        if (!fmt || !out || (outlen < 1)) return 0;
 
        if (!request || !request->client) {
+               RWDEBUG("No client associated with this request");
                *out = '\0';
                return 0;
        }
@@ -354,7 +354,7 @@ static size_t xlat_client(UNUSED void *instance, REQUEST *request,
                        strlcpy(out, request->client->shortname, outlen);
                        return strlen(out);
                }
-
+               RDEBUG("Client does not contain config item \"%s\"", fmt);
                *out = '\0';
                return 0;
        }

diff --git a/src/main/radattr.c b/src/main/radattr.c
index b7f765f..30e8cb5 100644 (file)
--- a/src/main/radattr.c
+++ b/src/main/radattr.c
@@ -47,7 +47,7 @@ log_debug_t debug_flag = 0;
 #include <stdarg.h>
 
 typedef size_t (*RADIUS_ESCAPE_STRING)(REQUEST *, char *out, size_t outlen, char const *in, void *arg);
-typedef size_t (*RAD_XLAT_FUNC)(void *instance, REQUEST *, char const *, char *, size_t);
+typedef ssize_t (*RAD_XLAT_FUNC)(void *instance, REQUEST *, char const *, char *, size_t);
 int            xlat_register(char const *module, RAD_XLAT_FUNC func, RADIUS_ESCAPE_STRING escape,
                             void *instance);
 void module_failure_msg(UNUSED REQUEST *request, UNUSED char const *fmt, ...);
@@ -66,8 +66,8 @@ pid_t rad_waitpid(pid_t pid, int *status)
        return waitpid(pid, status, 0);
 }
 
-static size_t xlat_test(UNUSED void *instance, UNUSED REQUEST *request,
-                      UNUSED char const *fmt, UNUSED char *out, UNUSED size_t outlen)
+static ssize_t xlat_test(UNUSED void *instance, UNUSED REQUEST *request,
+                        UNUSED char const *fmt, UNUSED char *out, UNUSED size_t outlen)
 {
        return 0;
 }

diff --git a/src/main/realms.c b/src/main/realms.c
index b99dfa3..156439b 100644 (file)
--- a/src/main/realms.c
+++ b/src/main/realms.c
@@ -228,12 +228,14 @@ static size_t xlat_cs(CONF_SECTION *cs, char const *fmt, char *out, size_t outle
 /*
  *     Xlat for %{home_server:foo}
  */
-static size_t xlat_home_server(UNUSED void *instance, REQUEST *request,
-                              char const *fmt, char *out, size_t outlen)
+static ssize_t xlat_home_server(UNUSED void *instance, REQUEST *request,
+                               char const *fmt, char *out, size_t outlen)
 {
        if (!fmt || !out || (outlen < 1)) return 0;
 
        if (!request || !request->home_server) {
+               RWDEBUG("No home_server associated with this request");
+               
                *out = '\0';
                return 0;
        }
@@ -245,12 +247,14 @@ static size_t xlat_home_server(UNUSED void *instance, REQUEST *request,
 /*
  *     Xlat for %{home_server_pool:foo}
  */
-static size_t xlat_server_pool(UNUSED void *instance, REQUEST *request,
-                              char const *fmt, char *out, size_t outlen)
+static ssize_t xlat_server_pool(UNUSED void *instance, REQUEST *request,
+                               char const *fmt, char *out, size_t outlen)
 {
        if (!fmt || !out || (outlen < 1)) return 0;
 
        if (!request || !request->home_pool) {
+               RWDEBUG("No home_pool associated with this request");
+               
                *out = '\0';
                return 0;
        }

diff --git a/src/main/xlat.c b/src/main/xlat.c
index 6032ae4..75a15cb 100644 (file)
--- a/src/main/xlat.c
+++ b/src/main/xlat.c
@@ -137,8 +137,8 @@ static int valuepair2str(char * out,int outlen,VALUE_PAIR * pair, int type)
 /** Print data as integer, not as VALUE.
  *
  */
-static size_t xlat_integer(UNUSED void *instance, REQUEST *request,
-                          char const *fmt, char *out, size_t outlen)
+static ssize_t xlat_integer(UNUSED void *instance, REQUEST *request,
+                           char const *fmt, char *out, size_t outlen)
 {
        VALUE_PAIR      *vp;
 
@@ -176,15 +176,18 @@ static size_t xlat_integer(UNUSED void *instance, REQUEST *request,
                        break;
        }
        
+       REDEBUG("Type \"%s\" cannot be converted to integer",
+               fr_int2str(dict_attr_types, vp->da->type, PW_TYPE_INVALID));
        *out = '\0';
-       return 0;
+       
+       return -1;
 }
 
 /** Print data as hex, not as VALUE.
  *
  */
-static size_t xlat_hex(UNUSED void *instance, REQUEST *request,
-                      char const *fmt, char *out, size_t outlen)
+static ssize_t xlat_hex(UNUSED void *instance, REQUEST *request,
+                       char const *fmt, char *out, size_t outlen)
 {
        size_t i;
        VALUE_PAIR *vp;
@@ -196,7 +199,7 @@ static size_t xlat_hex(UNUSED void *instance, REQUEST *request,
 
        if ((radius_get_vp(request, fmt, &vp) < 0) || !vp) {
                *out = '\0';
-               return 0;
+               return -1;
        }
        
        ret = rad_vp2data(vp, buffer, sizeof(buffer));
@@ -220,8 +223,8 @@ static size_t xlat_hex(UNUSED void *instance, REQUEST *request,
 /** Print data as base64, not as VALUE
  *
  */
-static size_t xlat_base64(UNUSED void *instance, REQUEST *request,
-                         char const *fmt, char *out, size_t outlen)
+static ssize_t xlat_base64(UNUSED void *instance, REQUEST *request,
+                          char const *fmt, char *out, size_t outlen)
 {
        VALUE_PAIR *vp;
        uint8_t buffer[MAX_STRING_LEN];
@@ -236,8 +239,8 @@ static size_t xlat_base64(UNUSED void *instance, REQUEST *request,
        
        ret = rad_vp2data(vp, buffer, sizeof(buffer));
        if (ret < 0) {
-               *out = 0;
-               return 0;
+               *out = '\0';
+               return ret;
        }
 
        return fr_base64_encode(buffer, (size_t) ret, out, outlen);
@@ -246,8 +249,8 @@ static size_t xlat_base64(UNUSED void *instance, REQUEST *request,
 /** Prints the current module processing the request
  *
  */
-static size_t xlat_module(UNUSED void *instance, REQUEST *request,
-                         UNUSED char const *fmt, char *out, size_t outlen)
+static ssize_t xlat_module(UNUSED void *instance, REQUEST *request,
+                          UNUSED char const *fmt, char *out, size_t outlen)
 {
        strlcpy(out, request->module, outlen);
 
@@ -259,8 +262,8 @@ static size_t xlat_module(UNUSED void *instance, REQUEST *request,
  *
  * @see modcall()
  */
-static size_t xlat_foreach(void *instance, REQUEST *request,
-                          UNUSED char const *fmt, char *out, size_t outlen)
+static ssize_t xlat_foreach(void *instance, REQUEST *request,
+                           UNUSED char const *fmt, char *out, size_t outlen)
 {
        VALUE_PAIR      **pvp;
 
@@ -284,8 +287,8 @@ static size_t xlat_foreach(void *instance, REQUEST *request,
  * be printed as 0x0a0a0a. The xlat "%{string:Foo}" will instead
  * expand to "\n\n\n"
  */
-static size_t xlat_string(UNUSED void *instance, REQUEST *request,
-                         char const *fmt, char *out, size_t outlen)
+static ssize_t xlat_string(UNUSED void *instance, REQUEST *request,
+                          char const *fmt, char *out, size_t outlen)
 {
        int len;
        VALUE_PAIR *vp;
@@ -311,7 +314,7 @@ static size_t xlat_string(UNUSED void *instance, REQUEST *request,
 /** xlat expand string attribute value
  *
  */
-static size_t xlat_xlat(UNUSED void *instance, REQUEST *request,
+static ssize_t xlat_xlat(UNUSED void *instance, REQUEST *request,
                        char const *fmt, char *out, size_t outlen)
 {
        VALUE_PAIR *vp;
@@ -333,8 +336,8 @@ static size_t xlat_xlat(UNUSED void *instance, REQUEST *request,
  *
  * Example %{debug:3}
  */
-static size_t xlat_debug(UNUSED void *instance, REQUEST *request,
-                        char const *fmt, char *out, size_t outlen)
+static ssize_t xlat_debug(UNUSED void *instance, REQUEST *request,
+                         char const *fmt, char *out, size_t outlen)
 {
        int level = 0;
        
@@ -1543,7 +1546,7 @@ do_print:
 static char *xlat_aprint(TALLOC_CTX *ctx, REQUEST *request, xlat_exp_t const * const node,
                         RADIUS_ESCAPE_STRING escape, void *escape_ctx, int lvl)
 {
-       size_t rcode;
+       ssize_t rcode;
        char *str = NULL, *child;
        REQUEST *ref;
 
@@ -1680,10 +1683,11 @@ static char *xlat_aprint(TALLOC_CTX *ctx, REQUEST *request, xlat_exp_t const * c
                XLAT_DEBUG("%.*sexpand mod %s --> '%s'", lvl, xlat_spaces, node->fmt, child);
 
                str = talloc_array(ctx, char, 1024); /* FIXME: have the module call talloc_asprintf */
-
+               *str = '\0';    /* Be sure the string is NULL terminated, we now only free on error */
+               
                rcode = node->xlat->func(node->xlat->instance, request, child, str, 1024);
                talloc_free(child);
-               if (rcode == 0) {
+               if (rcode < 0) {
                        talloc_free(str);
                        return NULL;
                }

diff --git a/src/modules/proto_dhcp/rlm_dhcp.c b/src/modules/proto_dhcp/rlm_dhcp.c
index 53043ce..5a7fb16 100644 (file)
--- a/src/modules/proto_dhcp/rlm_dhcp.c
+++ b/src/modules/proto_dhcp/rlm_dhcp.c
@@ -45,8 +45,8 @@ typedef struct rlm_dhcp_t {
 /*
  *     Allow single attribute values to be retrieved from the dhcp.
  */
-static size_t dhcp_options_xlat(UNUSED void *instance, REQUEST *request,
-                               char const *fmt, char *out, size_t freespace)
+static ssize_t dhcp_options_xlat(UNUSED void *instance, REQUEST *request,
+                                char const *fmt, char *out, size_t freespace)
 {
        vp_cursor_t cursor;
        VALUE_PAIR *vp, *head = NULL;
@@ -57,15 +57,14 @@ static size_t dhcp_options_xlat(UNUSED void *instance, REQUEST *request,
        
        if ((radius_get_vp(request, fmt, &vp) < 0) || !vp) {
                 *out = '\0';
-               
                 return 0;
        }
        
        if ((fr_dhcp_decode_options(request->packet,
-                                   vp->vp_octets, vp->length, &head) < 0) ||
-           (!head)) {
+                                   vp->vp_octets, vp->length, &head) < 0) || (!head)) {
                RWDEBUG("DHCP option decoding failed");
-               goto fail;
+               *out = '\0';
+               return -1;
        }
        
 
@@ -80,8 +79,6 @@ static size_t dhcp_options_xlat(UNUSED void *instance, REQUEST *request,
        /* Free any unmoved pairs */
        pairfree(&head);
        
-       fail:
-       
        snprintf(out, freespace, "%i", decoded);
                        
        return strlen(out);

diff --git a/src/modules/rlm_cache/rlm_cache.c b/src/modules/rlm_cache/rlm_cache.c
index 934c9fe..9ccbf37 100644 (file)
--- a/src/modules/rlm_cache/rlm_cache.c
+++ b/src/modules/rlm_cache/rlm_cache.c
@@ -601,8 +601,8 @@ static int cache_verify(rlm_cache_t *inst, value_pair_map_t **head)
 /*
  *     Allow single attribute values to be retrieved from the cache.
  */
-static size_t cache_xlat(void *instance, REQUEST *request,
-                        char const *fmt, char *out, size_t freespace)
+static ssize_t cache_xlat(void *instance, REQUEST *request,
+                         char const *fmt, char *out, size_t freespace)
 {
        rlm_cache_entry_t *c;
        rlm_cache_t *inst = instance;
@@ -625,6 +625,7 @@ static size_t cache_xlat(void *instance, REQUEST *request,
        
        if (!c) {
                RDEBUG("No cache entry for key \"%s\"", fmt);
+               *out = '\0';
                goto done;
        }
 
@@ -644,18 +645,19 @@ static size_t cache_xlat(void *instance, REQUEST *request,
        case PAIR_LIST_UNKNOWN:
                PTHREAD_MUTEX_UNLOCK(&inst->cache_mutex);
                REDEBUG("Unknown list qualifier in \"%s\"", fmt);
-               return 0;
+               return -1;
                
        default:
                PTHREAD_MUTEX_UNLOCK(&inst->cache_mutex);
                REDEBUG("Unsupported list \"%s\"",
-                      fr_int2str(pair_lists, list, "¿Unknown?"));
-               return 0;
+                       fr_int2str(pair_lists, list, "¿Unknown?"));
+               return -1;
        }
 
        vp = pairfind(vps, target->attr, target->vendor, TAG_ANY);
        if (!vp) {
                RDEBUG("No instance of this attribute has been cached");
+               *out = '\0';
                goto done;
        }
        

diff --git a/src/modules/rlm_exec/rlm_exec.c b/src/modules/rlm_exec/rlm_exec.c
index f594285..66c59a6 100644 (file)
--- a/src/modules/rlm_exec/rlm_exec.c
+++ b/src/modules/rlm_exec/rlm_exec.c
@@ -153,7 +153,7 @@ static rlm_rcode_t rlm_exec_status2rcode(REQUEST *request, char *answer, size_t
 /*
  *     Do xlat of strings.
  */
-static size_t exec_xlat(void *instance, REQUEST *request, char const *fmt, char *out, size_t outlen)
+static ssize_t exec_xlat(void *instance, REQUEST *request, char const *fmt, char *out, size_t outlen)
 {
        int             result;
        rlm_exec_t      *inst = instance;
@@ -162,16 +162,16 @@ static size_t exec_xlat(void *instance, REQUEST *request, char const *fmt, char
 
        if (!inst->wait) {
                REDEBUG("'wait' must be enabled to use exec xlat");
-               out[0] = '\0';
-               return 0;
+               *out = '\0';
+               return -1;
        }
 
        if (inst->input_list) {
                input_pairs = radius_list(request, inst->input_list);
                if (!input_pairs) {
                        REDEBUG("Failed to find input pairs for xlat");
-                       out[0] = '\0';
-                       return 0;
+                       *out = '\0';
+                       return -1;
                }
        }
        
@@ -182,7 +182,7 @@ static size_t exec_xlat(void *instance, REQUEST *request, char const *fmt, char
                                     out, outlen, input_pairs ? *input_pairs : NULL, NULL);
        if (result != 0) {
                out[0] = '\0';
-               return 0;
+               return -1;
        }
        
        for (p = out; *p != '\0'; p++) {

diff --git a/src/modules/rlm_expr/rlm_expr.c b/src/modules/rlm_expr/rlm_expr.c
index 55c9100..087a759 100644 (file)
--- a/src/modules/rlm_expr/rlm_expr.c
+++ b/src/modules/rlm_expr/rlm_expr.c
@@ -245,8 +245,8 @@ static int get_number(REQUEST *request, char const **string, int64_t *answer)
 /*
  *  Do xlat of strings!
  */
-static size_t expr_xlat(UNUSED void *instance, REQUEST *request, char const *fmt,
-                       char *out, size_t outlen)
+static ssize_t expr_xlat(UNUSED void *instance, REQUEST *request, char const *fmt,
+                        char *out, size_t outlen)
 {
        int             rcode;
        int64_t         result;
@@ -255,7 +255,7 @@ static size_t expr_xlat(UNUSED void *instance, REQUEST *request, char const *fmt
        p = fmt;
        rcode = get_number(request, &p, &result);
        if (rcode < 0) {
-               return 0;
+               return -1;
        }
 
        /*
@@ -263,7 +263,7 @@ static size_t expr_xlat(UNUSED void *instance, REQUEST *request, char const *fmt
         */
        if (*p != '\0') {
                RDEBUG2("Failed at %s", p);
-               return 0;
+               return -1;
        }
 
        snprintf(out, outlen, "%ld", (long int) result);
@@ -274,8 +274,8 @@ static size_t expr_xlat(UNUSED void *instance, REQUEST *request, char const *fmt
  *  @brief Generate a random integer value
  *
  */
-static size_t rand_xlat(UNUSED void *instance, UNUSED REQUEST *request, char const *fmt,
-                       char *out, size_t outlen)
+static ssize_t rand_xlat(UNUSED void *instance, UNUSED REQUEST *request, char const *fmt,
+                        char *out, size_t outlen)
 {
        int64_t         result;
 
@@ -284,7 +284,10 @@ static size_t rand_xlat(UNUSED void *instance, UNUSED REQUEST *request, char con
        /*
         *      Too small or too big.
         */
-       if (result <= 0) return 0;
+       if (result <= 0) {
+               *out = '\0';
+               return -1;
+       }
        if (result >= (1 << 30)) result = (1 << 30);
 
        result *= fr_rand();    /* 0..2^32-1 */
@@ -300,8 +303,8 @@ static size_t rand_xlat(UNUSED void *instance, UNUSED REQUEST *request, char con
  *  Build strings of random chars, useful for generating tokens and passcodes
  *  Format similar to String::Random.
  */
-static size_t randstr_xlat(UNUSED void *instance, UNUSED REQUEST *request,
-                          char const *fmt, char *out, size_t outlen)
+static ssize_t randstr_xlat(UNUSED void *instance, UNUSED REQUEST *request,
+                           char const *fmt, char *out, size_t outlen)
 {
        char const      *p;
        unsigned int    result;
@@ -309,6 +312,8 @@ static size_t randstr_xlat(UNUSED void *instance, UNUSED REQUEST *request,
        
        if (outlen <= 1) return 0;
 
+       *out = '\0';
+
        p = fmt;
        while (*p && (--freespace > 0)) {
                result = fr_rand();
@@ -367,8 +372,9 @@ static size_t randstr_xlat(UNUSED void *instance, UNUSED REQUEST *request,
                         *  non printable chars).
                         */
                        case 'h':
-                               if (freespace < 2)
+                               if (freespace < 2) {
                                        break;
+                               }
                                
                                snprintf(out, 3, "%02x", result % 256);
                                
@@ -378,10 +384,9 @@ static size_t randstr_xlat(UNUSED void *instance, UNUSED REQUEST *request,
                                break;
                        
                        default:
-                               ERROR("rlm_expr: invalid character class '%c'",
-                                      *p);
+                               ERROR("rlm_expr: invalid character class '%c'", *p);
                                
-                               return 0;
+                               return -1;
                }
        
                p++;
@@ -397,8 +402,8 @@ static size_t randstr_xlat(UNUSED void *instance, UNUSED REQUEST *request,
  *
  * Example: "%{urlquote:http://example.org/}" == "http%3A%47%47example.org%47"
  */
-static size_t urlquote_xlat(UNUSED void *instance, UNUSED REQUEST *request,
-                           char const *fmt, char *out, size_t outlen)
+static ssize_t urlquote_xlat(UNUSED void *instance, UNUSED REQUEST *request,
+                            char const *fmt, char *out, size_t outlen)
 {
        char const      *p;
        size_t  freespace = outlen;
@@ -441,8 +446,8 @@ static size_t urlquote_xlat(UNUSED void *instance, UNUSED REQUEST *request,
  *
  * @verbatim Example: "%{escape:<img>foo.jpg</img>}" == "=60img=62foo.jpg=60=/img=62" @endverbatim
  */
-static size_t escape_xlat(UNUSED void *instance, UNUSED REQUEST *request,
-                         char const *fmt, char *out, size_t outlen)
+static ssize_t escape_xlat(UNUSED void *instance, UNUSED REQUEST *request,
+                          char const *fmt, char *out, size_t outlen)
 {
        rlm_expr_t *inst = instance;
        char const      *p;
@@ -483,8 +488,8 @@ static size_t escape_xlat(UNUSED void *instance, UNUSED REQUEST *request,
  *
  * Probably only works for ASCII
  */
-static size_t lc_xlat(UNUSED void *instance, UNUSED REQUEST *request,
-                     char const *fmt, char *out, size_t outlen)
+static ssize_t lc_xlat(UNUSED void *instance, UNUSED REQUEST *request,
+                      char const *fmt, char *out, size_t outlen)
 {
        char *q;
        char const *p;
@@ -509,8 +514,8 @@ static size_t lc_xlat(UNUSED void *instance, UNUSED REQUEST *request,
  *
  * Probably only works for ASCII
  */
-static size_t uc_xlat(UNUSED void *instance, UNUSED REQUEST *request,
-                     char const *fmt, char *out, size_t outlen)
+static ssize_t uc_xlat(UNUSED void *instance, UNUSED REQUEST *request,
+                      char const *fmt, char *out, size_t outlen)
 {
        char *q;
        char const *p;
@@ -533,8 +538,8 @@ static size_t uc_xlat(UNUSED void *instance, UNUSED REQUEST *request,
  *
  * Example: "%{md5:foo}" == "acbd18db4cc2f85cedef654fccc4a4d8"
  */
-static size_t md5_xlat(UNUSED void *instance, UNUSED REQUEST *request,
-                      char const *fmt, char *out, size_t outlen)
+static ssize_t md5_xlat(UNUSED void *instance, UNUSED REQUEST *request,
+                       char const *fmt, char *out, size_t outlen)
 {
        uint8_t digest[16];
        int i, len;
@@ -571,8 +576,8 @@ static size_t md5_xlat(UNUSED void *instance, UNUSED REQUEST *request,
  *
  * Example: "%{sha1:foo}" == "0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"
  */
-static size_t sha1_xlat(UNUSED void *instance, UNUSED REQUEST *request,
-                       char const *fmt, char *out, size_t outlen)
+static ssize_t sha1_xlat(UNUSED void *instance, UNUSED REQUEST *request,
+                         char const *fmt, char *out, size_t outlen)
 {
         uint8_t digest[20];
         int i, len;
@@ -609,8 +614,8 @@ static size_t sha1_xlat(UNUSED void *instance, UNUSED REQUEST *request,
  *
  * Example: "%{tobase64:foo}" == "Zm9v"
  */
-static size_t base64_xlat(UNUSED void *instance, UNUSED REQUEST *request,
-                         char const *fmt, char *out, size_t outlen)
+static ssize_t base64_xlat(UNUSED void *instance, UNUSED REQUEST *request,
+                          char const *fmt, char *out, size_t outlen)
 {
        ssize_t len;
 
@@ -623,10 +628,10 @@ static size_t base64_xlat(UNUSED void *instance, UNUSED REQUEST *request,
        if ((len < 0) || ((FR_BASE64_ENC_LENGTH(len) + 1) > (ssize_t) outlen)) {
                REDEBUG("xlat failed.");
                *out = '\0';
-               return 0;
+               return -1;
        }
        
-       return  fr_base64_encode((const uint8_t *) fmt, len, out, outlen);
+       return fr_base64_encode((const uint8_t *) fmt, len, out, outlen);
 }
 
 /**
@@ -634,8 +639,8 @@ static size_t base64_xlat(UNUSED void *instance, UNUSED REQUEST *request,
  *
  * Example: "%{base64tohex:Zm9v}" == "666f6f"
  */
-static size_t base64_to_hex_xlat(UNUSED void *instance, UNUSED REQUEST *request,
-                                char const *fmt, char *out, size_t outlen)
+static ssize_t base64_to_hex_xlat(UNUSED void *instance, UNUSED REQUEST *request,
+                                 char const *fmt, char *out, size_t outlen)
 {      
        uint8_t decbuf[1024], *p;
        
@@ -648,7 +653,7 @@ static size_t base64_to_hex_xlat(UNUSED void *instance, UNUSED REQUEST *request,
        declen = fr_base64_decode(fmt, len, decbuf, sizeof(decbuf));
        if (declen < 0) {
                REDEBUG("Base64 string invalid");
-               return 0;
+               return -1;
        }
        
        p = decbuf;

diff --git a/src/modules/rlm_idn/rlm_idn.c b/src/modules/rlm_idn/rlm_idn.c
index 5d90f6f..ab15131 100644 (file)
--- a/src/modules/rlm_idn/rlm_idn.c
+++ b/src/modules/rlm_idn/rlm_idn.c
@@ -87,7 +87,7 @@ static const CONF_PARSER mod_config[] = {
        { NULL, -1, 0, NULL, NULL }
 };
 
-static size_t xlat_idna(void *instance, UNUSED REQUEST *request, char const *fmt, char *out, size_t freespace)
+static ssize_t xlat_idna(void *instance, UNUSED REQUEST *request, char const *fmt, char *out, size_t freespace)
 {
        rlm_idn_t *inst = instance;
        char *idna = NULL;
@@ -108,8 +108,8 @@ static size_t xlat_idna(void *instance, UNUSED REQUEST *request, char const *fmt
                        free (idna); /* Docs unclear, be safe. */
                }
 
-               RERROR("%s", idna_strerror(res));
-               return 0;
+               REDEBUG("%s", idna_strerror(res));
+               return -1;
        }
 
         len = strlen(idna);
@@ -117,10 +117,10 @@ static size_t xlat_idna(void *instance, UNUSED REQUEST *request, char const *fmt
        /* 253 is max DNS length */
         if (!((len < (freespace - 1)) && (len <= 253))) {
                /* Never provide a truncated result, as it may be queried. */
-               RERROR("Conversion was truncated");
+               REDEBUG("Conversion was truncated");
                
                free(idna);
-               return 0;
+               return -1;
 
        }
 

diff --git a/src/modules/rlm_ldap/rlm_ldap.c b/src/modules/rlm_ldap/rlm_ldap.c
index f55a98b..7881c78 100644 (file)
--- a/src/modules/rlm_ldap/rlm_ldap.c
+++ b/src/modules/rlm_ldap/rlm_ldap.c
@@ -226,11 +226,10 @@ static const CONF_PARSER module_config[] = {
 /** Expand an LDAP URL into a query, and return a string result from that query.
  *
  */
-static size_t ldap_xlat(void *instance, REQUEST *request, char const *fmt,
-                       char *out, size_t freespace)
+static ssize_t ldap_xlat(void *instance, REQUEST *request, char const *fmt, char *out, size_t freespace)
 {
        ldap_rcode_t status;
-       size_t length = 0;
+       size_t len = 0;
        ldap_instance_t *inst = instance;
        LDAPURLDesc *ldap_url;
        LDAPMessage *result = NULL;
@@ -245,12 +244,12 @@ static size_t ldap_xlat(void *instance, REQUEST *request, char const *fmt,
 
        if (!ldap_is_ldap_url(url)) {
                REDEBUG("String passed does not look like an LDAP URL");
-               return 0;
+               return -1;
        }
 
        if (ldap_url_parse(url, &ldap_url)){
                REDEBUG("Parsing LDAP URL failed");
-               return 0;
+               return -1;
        }
 
        /*
@@ -296,6 +295,7 @@ static size_t ldap_xlat(void *instance, REQUEST *request, char const *fmt,
        if (!entry) {
                ldap_get_option(conn->handle, LDAP_OPT_RESULT_CODE, &ldap_errno);
                REDEBUG("Failed retrieving entry: %s", ldap_err2string(ldap_errno));
+               len = -1;
                goto free_result;
        }
 
@@ -305,9 +305,8 @@ static size_t ldap_xlat(void *instance, REQUEST *request, char const *fmt,
                goto free_result;
        }
 
-       length = strlen(vals[0]);
-       if (length >= freespace){
-
+       len = strlen(vals[0]);
+       if (len >= freespace){
                goto free_vals;
        }
 
@@ -322,7 +321,7 @@ free_socket:
 free_urldesc:
        ldap_free_urldesc(ldap_url);
 
-       return length;
+       return len;
 }
 
 /** Perform LDAP-Group comparison checking

diff --git a/src/modules/rlm_mschap/rlm_mschap.c b/src/modules/rlm_mschap/rlm_mschap.c
index 38e90f8..dcb0944 100644 (file)
--- a/src/modules/rlm_mschap/rlm_mschap.c
+++ b/src/modules/rlm_mschap/rlm_mschap.c
@@ -163,8 +163,8 @@ typedef struct rlm_mschap_t {
  *     Pulls NT-Response, LM-Response, or Challenge from MSCHAP
  *     attributes.
  */
-static size_t mschap_xlat(void *instance, REQUEST *request,
-                      char const *fmt, char *out, size_t outlen)
+static ssize_t mschap_xlat(void *instance, REQUEST *request,
+                          char const *fmt, char *out, size_t outlen)
 {
        size_t          i, data_len;
        uint8_t const   *data = NULL;

diff --git a/src/modules/rlm_perl/rlm_perl.c b/src/modules/rlm_perl/rlm_perl.c
index 059d228..5f2a156 100644 (file)
--- a/src/modules/rlm_perl/rlm_perl.c
+++ b/src/modules/rlm_perl/rlm_perl.c
@@ -313,7 +313,7 @@ static void xs_init(pTHX)
 /*
  * The xlat function
  */
-static size_t perl_xlat(void *instance, REQUEST *request, char const *fmt, char *out, size_t freespace)
+static ssize_t perl_xlat(void *instance, REQUEST *request, char const *fmt, char *out, size_t freespace)
 {
 
        rlm_perl_t      *inst= (rlm_perl_t *) instance;

diff --git a/src/modules/rlm_redis/rlm_redis.c b/src/modules/rlm_redis/rlm_redis.c
index bef4980..72e558c 100644 (file)
--- a/src/modules/rlm_redis/rlm_redis.c
+++ b/src/modules/rlm_redis/rlm_redis.c
@@ -137,8 +137,7 @@ static void *mod_conn_create(void *ctx)
        return dissocket;
 }
 
-static size_t redis_xlat(void *instance, REQUEST *request,
-                     char const *fmt, char *out, size_t freespace)
+static ssize_t redis_xlat(void *instance, REQUEST *request, char const *fmt, char *out, size_t freespace)
 {
        REDIS_INST *inst = instance;
        REDISSOCK *dissocket;
@@ -151,7 +150,7 @@ static size_t redis_xlat(void *instance, REQUEST *request,
                ERROR("rlm_redis (%s): redis_get_socket() failed",
                       inst->xlat_name);
 
-               return 0;
+               return -1;
        }
 
        /* Query failed for some reason, release socket and return */
@@ -182,7 +181,7 @@ static size_t redis_xlat(void *instance, REQUEST *request,
        if ((ret >= freespace) || (!buffer_ptr)) {
                RDEBUG("rlm_redis (%s): Can't write result, insufficient space or unsupported result\n",
                       inst->xlat_name);
-               ret = 0;
+               ret = -1;
                goto release;
        }
        

diff --git a/src/modules/rlm_soh/rlm_soh.c b/src/modules/rlm_soh/rlm_soh.c
index 2be1e37..15856f6 100644 (file)
--- a/src/modules/rlm_soh/rlm_soh.c
+++ b/src/modules/rlm_soh/rlm_soh.c
@@ -37,7 +37,7 @@ typedef struct rlm_soh_t {
 /*
  * Not sure how to make this useful yet...
  */
-static size_t soh_xlat(UNUSED void *instance, REQUEST *request, char const *fmt, char *out, size_t outlen) {
+static ssize_t soh_xlat(UNUSED void *instance, REQUEST *request, char const *fmt, char *out, size_t outlen) {
 
        VALUE_PAIR* vp[6];
        char const *osname;

diff --git a/src/modules/rlm_sql/rlm_sql.c b/src/modules/rlm_sql/rlm_sql.c
index 41975a3..6f76f08 100644 (file)
--- a/src/modules/rlm_sql/rlm_sql.c
+++ b/src/modules/rlm_sql/rlm_sql.c
@@ -126,12 +126,13 @@ static size_t sql_escape_func(REQUEST *, char *out, size_t outlen, char const *i
  *  for inserts, updates and deletes the number of rows afftected will be
  *  returned instead.
  */
-static size_t sql_xlat(void *instance, REQUEST *request, char const *query, char *out, size_t freespace)
+static ssize_t sql_xlat(void *instance, REQUEST *request, char const *query, char *out, size_t freespace)
 {
        rlm_sql_handle_t *handle = NULL;
        rlm_sql_row_t row;
        rlm_sql_t *inst = instance;
-       size_t ret = 0;
+       ssize_t ret = 0;
+       size_t len = 0;
 
        /*
         *      Add SQL-User-Name attribute just in case it is needed
@@ -178,24 +179,27 @@ static size_t sql_xlat(void *instance, REQUEST *request, char const *query, char
                 */
                snprintf(buffer, sizeof(buffer), "%d", numaffected);
                
-               ret = strlen(buffer);
-               if (ret >= freespace){
+               len = strlen(buffer);
+               if (len >= freespace){
                        RDEBUG("rlm_sql (%s): Can't write result, insufficient string space", inst->config->xlat_name);
                        
                        (inst->module->sql_finish_query)(handle, inst->config);
 
-                       ret = 0;
+                       ret = -1;
                        goto finish;
                }
                
-               memcpy(out, buffer, ret + 1); /* we did bounds checking above */
-
+               memcpy(out, buffer, len + 1); /* we did bounds checking above */
+               ret = len;
+               
                (inst->module->sql_finish_query)(handle, inst->config);
                
                goto finish;
        } /* else it's a SELECT statement */
 
        if (rlm_sql_select_query(&handle, inst, query)){
+               ret = -1;
+               
                goto finish;
        }
 
@@ -203,6 +207,7 @@ static size_t sql_xlat(void *instance, REQUEST *request, char const *query, char
        if (ret) {
                RDEBUG("SQL query failed");
                (inst->module->sql_finish_select_query)(handle, inst->config);
+               ret = -1;
                
                goto finish;
        }
@@ -222,16 +227,17 @@ static size_t sql_xlat(void *instance, REQUEST *request, char const *query, char
                goto finish;
        }
        
-       ret = strlen(row[0]);
-       if (ret >= freespace){
+       len = strlen(row[0]);
+       if (len >= freespace){
                RDEBUG("Insufficient string space");
                (inst->module->sql_finish_select_query)(handle, inst->config);
 
-               ret = 0;
+               ret = -1;
                goto finish;
        }
 
        strlcpy(out, row[0], freespace);
+       ret = len;
 
        RDEBUG("sql_xlat finished");
 

diff --git a/src/modules/rlm_yubikey/rlm_yubikey.c b/src/modules/rlm_yubikey/rlm_yubikey.c
index ed7a235..cb0d38b 100644 (file)
--- a/src/modules/rlm_yubikey/rlm_yubikey.c
+++ b/src/modules/rlm_yubikey/rlm_yubikey.c
@@ -102,7 +102,7 @@ static ssize_t modhex2hex(char const *modhex, uint8_t *hex, size_t len)
  *
  * Example: "%{modhextohex:vvrbuctetdhc}" == "ffc1e0d3d260"
  */
-static size_t modhex_to_hex_xlat(UNUSED void *instance, REQUEST *request, char const *fmt, char *out, size_t outlen)
+static ssize_t modhex_to_hex_xlat(UNUSED void *instance, REQUEST *request, char const *fmt, char *out, size_t outlen)
 {      
        ssize_t len;
 
@@ -119,7 +119,7 @@ static size_t modhex_to_hex_xlat(UNUSED void *instance, REQUEST *request, char c
                *out = '\0';
                REDEBUG("Modhex string invalid");
                
-               return 0;
+               return -1;
        }
        
        return len;