Mark more box functions up as non-null

diff --git a/src/lib/server/cond_eval.c b/src/lib/server/cond_eval.c
index 5aecc84e9dbe1354f97b0764e3538e945a8f3cd6..4840fbe1977ca38067101cbc6dadd3c687019a2d 100644 (file)
--- a/src/lib/server/cond_eval.c
+++ b/src/lib/server/cond_eval.c
@@ -509,7 +509,7 @@ static int cond_realize_attr(request_t *request, fr_value_box_t **realized, fr_v
        if (fr_value_box_cast(request, box, cast_type, da, &vp->data) < 0) {
                if (request) RPEDEBUG("Failed casting %pV to type %s", &vp->data,
                                      fr_type_to_str(tmpl_rules_cast(vpt)));
-               return false;
+               return -1;
        }
 
        *realized = box;

diff --git a/src/lib/server/tmpl_tokenize.c b/src/lib/server/tmpl_tokenize.c
index 0dc12451e2ae4091f95fa0257e4afc81819821c2..9d3555e9e7f4c73caaa9099f28be787dcc83061f 100644 (file)
--- a/src/lib/server/tmpl_tokenize.c
+++ b/src/lib/server/tmpl_tokenize.c
@@ -735,19 +735,19 @@ static tmpl_attr_t *tmpl_attr_add(tmpl_t *vpt, tmpl_attr_type_t type)
 int tmpl_afrom_value_box(TALLOC_CTX *ctx, tmpl_t **out, fr_value_box_t *data, bool steal)
 {
        char            *name;
-       size_t          len;
+       fr_slen_t       slen;
        tmpl_t          *vpt;
        fr_token_t      quote = (data->type == FR_TYPE_STRING) ? T_SINGLE_QUOTED_STRING : T_BARE_WORD;
 
        MEM(vpt = talloc(ctx, tmpl_t));
-       len = fr_value_box_aprint(vpt, &name, data, fr_value_escape_by_quote[quote]);
-       if (len < 0) {
+       slen = fr_value_box_aprint(vpt, &name, data, fr_value_escape_by_quote[quote]);
+       if (slen < 0) {
        error:
                talloc_free(vpt);
                return -1;
        }
 
-       tmpl_init_shallow(vpt, TMPL_TYPE_DATA, quote, name, len);
+       tmpl_init_shallow(vpt, TMPL_TYPE_DATA, quote, name, slen);
 
        if (steal) {
                if (fr_value_box_steal(vpt, tmpl_value(vpt), data) < 0) goto error;

diff --git a/src/lib/unlang/switch.c b/src/lib/unlang/switch.c
index f0e06eeb1f79df11f8a421712cf2b694ea690e6c..06f5e9ecdbcf958c0d31acd91a226eafcc15fcec 100644 (file)
--- a/src/lib/unlang/switch.c
+++ b/src/lib/unlang/switch.c
@@ -91,6 +91,8 @@ static unlang_action_t unlang_switch(rlm_rcode_t *p_result, request_t *request,
                tmpl_init_shallow(&vpt, TMPL_TYPE_DATA, T_SINGLE_QUOTED_STRING, p, len);
                fr_value_box_bstrndup_shallow(&vpt.data.literal, NULL, p, len, false);
                box = tmpl_value(&vpt);
+       } else if (!fr_cond_assert_msg(0, "Invalid tmpl type %s", tmpl_type_to_str(switch_gext->vpt->type))) {
+               return UNLANG_ACTION_FAIL;
        }
 
        /*

diff --git a/src/lib/unlang/xlat_builtin.c b/src/lib/unlang/xlat_builtin.c
index 748ef62d5cf0f7b85eab5d8e6f2b89b7036ca25c..a0c636c9e9f7304bb73533005ba57b62f0ea2d24 100644 (file)
--- a/src/lib/unlang/xlat_builtin.c
+++ b/src/lib/unlang/xlat_builtin.c
@@ -2360,9 +2360,12 @@ static xlat_action_t xlat_func_pairs(TALLOC_CTX *ctx, fr_dcursor_t *out,
                char *buff;
 
                MEM(vb = fr_value_box_alloc_null(ctx));
-
                vp->op = T_OP_EQ;
-               fr_pair_aprint(vb, &buff, NULL, vp);
+               if (unlikely(fr_pair_aprint(vb, &buff, NULL, vp) < 0)) {
+                       RPEDEBUG("Failed printing pair");
+                       talloc_free(vb);
+                       return XLAT_ACTION_FAIL;
+               }
                vp->op = op;
 
                fr_value_box_bstrdup_buffer_shallow(NULL, vb, NULL, buff, false);

diff --git a/src/lib/util/dict.h b/src/lib/util/dict.h
index 563b0216ba4c1f0283fae52484b09ecb5c9f896a..4a9ce71064cdabbd94d3b739d47dd32efa6d1b6b 100644 (file)
--- a/src/lib/util/dict.h
+++ b/src/lib/util/dict.h
@@ -570,7 +570,7 @@ ssize_t                     fr_dict_enum_by_name_substr(fr_dict_enum_value_t **out, fr_dict_attr_t
 fr_slen_t              fr_dict_enum_name_from_substr(fr_sbuff_t *out, fr_sbuff_t *in, fr_sbuff_term_t const *tt);
 
 static inline fr_slen_t fr_dict_enum_name_afrom_substr(TALLOC_CTX *ctx, char **out, fr_sbuff_t *in, fr_sbuff_term_t const *tt)
-SBUFF_OUT_TALLOC_FUNC_NO_LEN_DEF(fr_dict_enum_name_from_substr, in, tt)
+                       SBUFF_OUT_TALLOC_FUNC_NO_LEN_DEF(fr_dict_enum_name_from_substr, in, tt)
 /** @} */
 
 /** @name Dictionary and protocol loading

diff --git a/src/lib/util/pair.h b/src/lib/util/pair.h
index d1e56231f7359b1903e0325abce8f301738c4679..39ac2ec3b550333ba4be52d51a1a63c08491c6df 100644 (file)
--- a/src/lib/util/pair.h
+++ b/src/lib/util/pair.h
@@ -515,18 +515,14 @@ ssize_t           fr_pair_print_value_quoted(fr_sbuff_t *out,
 static inline size_t CC_HINT(nonnull(2,3))
                fr_pair_aprint_value_quoted(TALLOC_CTX *ctx, char **out,
                                            fr_pair_t const *vp, fr_token_t quote)
-{
                SBUFF_OUT_TALLOC_FUNC_NO_LEN_DEF(fr_pair_print_value_quoted, vp, quote)
-}
 
 ssize_t                fr_pair_print(fr_sbuff_t *out, fr_pair_t const *parent,
                              fr_pair_t const *vp) CC_HINT(nonnull(1,3));
 
 static inline size_t CC_HINT(nonnull(2,4))
                fr_pair_aprint(TALLOC_CTX *ctx, char **out, fr_pair_t const *parent, fr_pair_t const *vp)
-{
                SBUFF_OUT_TALLOC_FUNC_NO_LEN_DEF(fr_pair_print, parent, vp)
-}
 
 void           fr_pair_fprint(FILE *, fr_pair_t const *vp) CC_HINT(nonnull);
 

diff --git a/src/lib/util/sbuff.c b/src/lib/util/sbuff.c
index 22bb7cca77d2fb02fdd9bfa4ae06012269bd14e9..f221959f87c85fac2170806525c8e41ad6f353e9 100644 (file)
--- a/src/lib/util/sbuff.c
+++ b/src/lib/util/sbuff.c
@@ -392,7 +392,7 @@ int fr_sbuff_trim_talloc(fr_sbuff_t *sbuff, size_t len)
 
        if (nlen != clen) {
                new_buff = talloc_realloc(tctx->ctx, sbuff->buff, char, nlen);
-               if (!new_buff) {
+               if (unlikely(!new_buff)) {
                        fr_strerror_printf("Failed trimming buffer from %zu to %zu", clen, nlen);
                        return -1;
                }

diff --git a/src/lib/util/sbuff.h b/src/lib/util/sbuff.h
index ca4121bf1c1edf2d028734b94ef10e5474c9ea16..eed91a7dae02e3eee8eaa3f555c610c74dae9c39 100644 (file)
--- a/src/lib/util/sbuff.h
+++ b/src/lib/util/sbuff.h
@@ -1402,17 +1402,21 @@ do { \
        fr_sbuff_t              sbuff; \
        fr_sbuff_uctx_talloc_t  tctx; \
        fr_sbuff_parse_error_t  err; \
-       fr_slen_t               slen; \
-       fr_sbuff_init_talloc(ctx, &sbuff, &tctx, \
-                            ((_len) != SIZE_MAX) ? (_len) : 1024, \
-                            ((_len) != SIZE_MAX) ? (_len) : SIZE_MAX); \
-       slen = _func(&err, &sbuff, _in, _len, ##__VA_ARGS__); \
-       if (slen < 0) { \
+       fr_slen_t               slen = -1; \
+       if (unlikely(fr_sbuff_init_talloc(ctx, &sbuff, &tctx, \
+                                         ((_len) != SIZE_MAX) ? (_len) : 1024, \
+                                         ((_len) != SIZE_MAX) ? (_len) : SIZE_MAX) == NULL)) { \
+       error: \
                TALLOC_FREE(sbuff.buff); \
                *out = NULL; \
                return slen; \
        } \
-       fr_sbuff_trim_talloc(&sbuff, SIZE_MAX); \
+       slen = _func(&err, &sbuff, _in, _len, ##__VA_ARGS__); \
+       if (slen < 0) goto error; \
+       if (unlikely(fr_sbuff_trim_talloc(&sbuff, SIZE_MAX) < 0)) { \
+               slen = -1; \
+               goto error; \
+       } \
        *out = sbuff.buff; \
        return slen; \
 }
@@ -1428,17 +1432,21 @@ do { \
 { \
        fr_sbuff_t              sbuff; \
        fr_sbuff_uctx_talloc_t  tctx; \
-       fr_slen_t               slen; \
-       fr_sbuff_init_talloc(ctx, &sbuff, &tctx, \
-                            ((_len) != SIZE_MAX) ? (_len) : 1024, \
-                            ((_len) != SIZE_MAX) ? (_len) : SIZE_MAX); \
-       slen = _func(&sbuff, _in, _len, ##__VA_ARGS__); \
-       if (slen < 0) { \
+       fr_slen_t               slen = -1; \
+       if (unlikely(fr_sbuff_init_talloc(ctx, &sbuff, &tctx, \
+                                         ((_len) != SIZE_MAX) ? (_len) : 1024, \
+                                         ((_len) != SIZE_MAX) ? (_len) : SIZE_MAX) == NULL)) { \
+       error: \
                TALLOC_FREE(sbuff.buff); \
                *out = NULL; \
                return slen; \
        } \
-       fr_sbuff_trim_talloc(&sbuff, SIZE_MAX); \
+       slen = _func(&sbuff, _in, _len, ##__VA_ARGS__); \
+       if (slen < 0) goto error; \
+       if (unlikely(fr_sbuff_trim_talloc(&sbuff, SIZE_MAX) < 0)) { \
+               slen = -1; \
+               goto error; \
+       } \
        *out = sbuff.buff; \
        return slen; \
 }
@@ -1452,15 +1460,19 @@ do { \
 { \
        fr_sbuff_t              sbuff; \
        fr_sbuff_uctx_talloc_t  tctx; \
-       fr_slen_t               slen; \
-       fr_sbuff_init_talloc(ctx, &sbuff, &tctx, 0, SIZE_MAX); \
-       slen = _func(&sbuff, ##__VA_ARGS__); \
-       if (slen < 0) { \
+       fr_slen_t               slen = -1; \
+       if (unlikely(fr_sbuff_init_talloc(ctx, &sbuff, &tctx, 0, SIZE_MAX) == NULL)) { \
+       error: \
                TALLOC_FREE(sbuff.buff); \
                *out = NULL; \
                return slen; \
        } \
-       fr_sbuff_trim_talloc(&sbuff, SIZE_MAX); \
+       slen = _func(&sbuff, ##__VA_ARGS__); \
+       if (slen < 0) goto error; \
+       if (unlikely(fr_sbuff_trim_talloc(&sbuff, SIZE_MAX) < 0)) { \
+               slen = -1; \
+               goto error; \
+       } \
        *out = sbuff.buff; \
        return slen; \
 }

diff --git a/src/lib/util/value.c b/src/lib/util/value.c
index 11afdafa210297a5c2cf88cea7ef6854e3e56372..f8208b8f7da525d76ecdf155d694d567d34a1177 100644 (file)
--- a/src/lib/util/value.c
+++ b/src/lib/util/value.c
@@ -4506,7 +4506,10 @@ parse:
                if (!dst_enumv) {
                        char *buff;
 
-                       fr_sbuff_out_aunescape_until(ctx, &buff, &our_in, SIZE_MAX, rules->terminals, rules->escapes);
+                       if (unlikely(fr_sbuff_out_aunescape_until(ctx, &buff, &our_in, SIZE_MAX,
+                                                                 rules->terminals, rules->escapes) < 0)) {
+                               return -1;
+                       }
                        fr_value_box_bstrdup_buffer_shallow(NULL, dst, dst_enumv, buff, tainted);
                /*
                 *      We already have an unescaped version, just use that

diff --git a/src/lib/util/value.h b/src/lib/util/value.h
index a2319257979f5f3bde2c95e92ee15b9a2c182fa9..0862d77d592463a850d157a13ec4aced3871932b 100644 (file)
--- a/src/lib/util/value.h
+++ b/src/lib/util/value.h
@@ -385,7 +385,8 @@ extern fr_sbuff_parse_rules_t const *value_parse_rules_quoted_char[UINT8_MAX];
  * @param[in] list     of value boxes.
  * @return Number of boxes in the list.
  */
-static inline size_t fr_value_box_list_len(fr_value_box_list_t const *list)
+static inline CC_HINT(nonnull)
+size_t fr_value_box_list_len(fr_value_box_list_t const *list)
 {
        return fr_dlist_num_elements(list);
 }
@@ -398,7 +399,8 @@ static inline size_t fr_value_box_list_len(fr_value_box_list_t const *list)
  *     - true if the list has at least min boxes.
  *     - false if the list has fewer than min boxes.
  */
-static inline bool fr_value_box_list_len_min(fr_value_box_list_t const *list, unsigned int min)
+static inline CC_HINT(nonnull)
+bool fr_value_box_list_len_min(fr_value_box_list_t const *list, unsigned int min)
 {
        unsigned int i = fr_dlist_num_elements(list);
 
@@ -409,7 +411,8 @@ static inline bool fr_value_box_list_len_min(fr_value_box_list_t const *list, un
  *
  * @param[in,out] list         to initialise
  */
-static inline void fr_value_box_list_init(fr_value_box_list_t *list)
+static inline CC_HINT(nonnull)
+void fr_value_box_list_init(fr_value_box_list_t *list)
 {
        fr_dlist_init(list, fr_value_box_t, entry);     /* Not always talloced */
 }
@@ -432,8 +435,8 @@ static inline void fr_value_box_list_init(fr_value_box_list_t *list)
  * @param[in] enumv    Enumeration values.
  * @param[in] tainted  Whether data will come from an untrusted source.
  */
-static inline CC_HINT(always_inline) void fr_value_box_init(fr_value_box_t *vb, fr_type_t type,
-                                                           fr_dict_attr_t const *enumv, bool tainted)
+static inline CC_HINT(nonnull(1), always_inline)
+void fr_value_box_init(fr_value_box_t *vb, fr_type_t type, fr_dict_attr_t const *enumv, bool tainted)
 {
        /*
         *      An inventive way of defeating const on the type
@@ -455,7 +458,8 @@ static inline CC_HINT(always_inline) void fr_value_box_init(fr_value_box_t *vb,
 /** Initialise an empty/null box that will be filled later
  *
  */
-static inline CC_HINT(always_inline) void fr_value_box_init_null(fr_value_box_t *vb)
+static inline CC_HINT(always_inline)
+void fr_value_box_init_null(fr_value_box_t *vb)
 {
        fr_value_box_init(vb, FR_TYPE_NULL, NULL, false);
 }
@@ -473,8 +477,8 @@ static inline CC_HINT(always_inline) void fr_value_box_init_null(fr_value_box_t
  *     - A new fr_value_box_t.
  *     - NULL on error.
  */
-static inline CC_HINT(always_inline) fr_value_box_t *fr_value_box_alloc(TALLOC_CTX *ctx, fr_type_t type,
-                                                                       fr_dict_attr_t const *enumv, bool tainted)
+static inline CC_HINT(always_inline)
+fr_value_box_t *fr_value_box_alloc(TALLOC_CTX *ctx, fr_type_t type, fr_dict_attr_t const *enumv, bool tainted)
 {
        fr_value_box_t *vb;
 
@@ -493,7 +497,8 @@ static inline CC_HINT(always_inline) fr_value_box_t *fr_value_box_alloc(TALLOC_C
  *     - A new fr_value_box_t.
  *     - NULL on error.
  */
-static inline CC_HINT(always_inline) fr_value_box_t *fr_value_box_alloc_null(TALLOC_CTX *ctx)
+static inline CC_HINT(always_inline)
+fr_value_box_t *fr_value_box_alloc_null(TALLOC_CTX *ctx)
 {
        return fr_value_box_alloc(ctx, FR_TYPE_NULL, NULL, false);
 }
@@ -506,8 +511,9 @@ static inline CC_HINT(always_inline) fr_value_box_t *fr_value_box_alloc_null(TAL
  * @param[in] tainted  Whether data will come from an untrusted source.
  * @return 0 (always successful).
  */
-static inline CC_HINT(always_inline) int fr_value_box_ethernet_addr(fr_value_box_t *dst, fr_dict_attr_t const *enumv,
-                                                                   fr_ethernet_t const *src, bool tainted)
+static inline CC_HINT(nonnull(1,3), always_inline) \
+int fr_value_box_ethernet_addr(fr_value_box_t *dst, fr_dict_attr_t const *enumv, \
+                              fr_ethernet_t const *src, bool tainted)
 {
        fr_value_box_init(dst, FR_TYPE_ETHERNET, enumv, tainted);
        memcpy(dst->vb_ether, src, sizeof(dst->vb_ether));
@@ -515,8 +521,9 @@ static inline CC_HINT(always_inline) int fr_value_box_ethernet_addr(fr_value_box
 }
 
 #define DEF_BOXING_FUNC(_ctype, _field, _type) \
-static inline CC_HINT(always_inline) int fr_value_box_##_field(fr_value_box_t *dst, fr_dict_attr_t const *enumv, \
-                                                              _ctype const value, bool tainted) { \
+static inline CC_HINT(nonnull(1), always_inline) \
+int fr_value_box_##_field(fr_value_box_t *dst, fr_dict_attr_t const *enumv, \
+                         _ctype const value, bool tainted) { \
        fr_value_box_init(dst, _type, enumv, tainted); \
        dst->vb_##_field = value; \
        return 0; \
@@ -590,7 +597,8 @@ _Generic((_var), \
  *     - 0 on success.
  *     - -1 on type mismatch.
  */
-static inline int fr_value_unbox_ethernet_addr(fr_ethernet_t *dst, fr_value_box_t *src)
+static inline CC_HINT(nonnull)
+int fr_value_unbox_ethernet_addr(fr_ethernet_t *dst, fr_value_box_t *src)
 {
        if (unlikely(src->type != FR_TYPE_ETHERNET)) { \
                fr_strerror_printf("Unboxing failed.  Needed type %s, had type %s",
@@ -603,7 +611,8 @@ static inline int fr_value_unbox_ethernet_addr(fr_ethernet_t *dst, fr_value_box_
 }
 
 #define DEF_UNBOXING_FUNC(_ctype, _field, _type) \
-static inline int fr_value_unbox_##_field(_ctype *var, fr_value_box_t const *src) { \
+static inline CC_HINT(nonnull)  \
+int fr_value_unbox_##_field(_ctype *var, fr_value_box_t const *src) { \
        if (unlikely(src->type != _type)) { \
                fr_strerror_printf("Unboxing failed.  Needed type %s, had type %s", \
                                   fr_type_to_str(_type), \
@@ -653,16 +662,20 @@ _Generic((_var), \
 /*
  *     Comparison
  */
-int            fr_value_box_cmp(fr_value_box_t const *a, fr_value_box_t const *b);
+int            fr_value_box_cmp(fr_value_box_t const *a, fr_value_box_t const *b)
+               CC_HINT(nonnull);
 
-int            fr_value_box_cmp_op(fr_token_t op, fr_value_box_t const *a, fr_value_box_t const *b);
+int            fr_value_box_cmp_op(fr_token_t op, fr_value_box_t const *a, fr_value_box_t const *b)
+               CC_HINT(nonnull);
 
 /*
  *     Conversion
  */
-size_t         fr_value_str_unescape(fr_sbuff_t *out, fr_sbuff_t *in, size_t inlen, char quote);
+size_t         fr_value_str_unescape(fr_sbuff_t *out, fr_sbuff_t *in, size_t inlen, char quote)
+               CC_HINT(nonnull);
 
-size_t         fr_value_substr_unescape(fr_sbuff_t *out, fr_sbuff_t *in, size_t inlen, char quote);
+size_t         fr_value_substr_unescape(fr_sbuff_t *out, fr_sbuff_t *in, size_t inlen, char quote)
+               CC_HINT(nonnull);
 
 static inline size_t fr_value_str_aunescape(TALLOC_CTX *ctx, char **out, fr_sbuff_t *in, size_t inlen, char quote)
 SBUFF_OUT_TALLOC_FUNC_DEF(fr_value_str_unescape, in, inlen, quote)
@@ -670,14 +683,17 @@ SBUFF_OUT_TALLOC_FUNC_DEF(fr_value_str_unescape, in, inlen, quote)
 static inline size_t fr_value_substr_aunescape(TALLOC_CTX *ctx, char **out, fr_sbuff_t *in, size_t inlen, char quote)
 SBUFF_OUT_TALLOC_FUNC_DEF(fr_value_substr_unescape, in, inlen, quote)
 
-int            fr_value_box_hton(fr_value_box_t *dst, fr_value_box_t const *src);
+int            fr_value_box_hton(fr_value_box_t *dst, fr_value_box_t const *src)
+               CC_HINT(nonnull);
 
-size_t         fr_value_box_network_length(fr_value_box_t const *value);
+size_t         fr_value_box_network_length(fr_value_box_t const *value)
+               CC_HINT(nonnull);
 
 ssize_t                fr_value_box_to_network(fr_dbuff_t *dbuff, fr_value_box_t const *value);
 #define FR_VALUE_BOX_TO_NETWORK_RETURN(_dbuff, _value) FR_DBUFF_RETURN(fr_value_box_to_network, _dbuff, _value)
 
-int            fr_value_box_to_key(uint8_t **out, size_t *outlen, fr_value_box_t const *value) CC_HINT(nonnull);
+int            fr_value_box_to_key(uint8_t **out, size_t *outlen, fr_value_box_t const *value)
+               CC_HINT(nonnull);
 
 /** Special value to indicate fr_value_box_from_network experienced a general error
  */
@@ -693,45 +709,58 @@ int               fr_value_box_to_key(uint8_t **out, size_t *outlen, fr_value_box_t const *va
 
 ssize_t                fr_value_box_from_network(TALLOC_CTX *ctx,
                                          fr_value_box_t *dst, fr_type_t type, fr_dict_attr_t const *enumv,
-                                         fr_dbuff_t *dbuff, size_t len, bool tainted);
+                                         fr_dbuff_t *dbuff, size_t len, bool tainted)
+               CC_HINT(nonnull(2,5));
 
 int            fr_value_box_cast(TALLOC_CTX *ctx, fr_value_box_t *dst,
                                  fr_type_t dst_type, fr_dict_attr_t const *dst_enumv,
-                                 fr_value_box_t const *src) CC_HINT(nonnull(2, 5));
+                                 fr_value_box_t const *src)
+               CC_HINT(nonnull(2,5));
 
 int            fr_value_box_cast_in_place(TALLOC_CTX *ctx, fr_value_box_t *vb,
-                                          fr_type_t dst_type, fr_dict_attr_t const *dst_enumv);
+                                          fr_type_t dst_type, fr_dict_attr_t const *dst_enumv)
+               CC_HINT(nonnull(1));
 
 int            fr_value_box_ipaddr(fr_value_box_t *dst, fr_dict_attr_t const *enumv,
-                                        fr_ipaddr_t const *ipaddr, bool tainted);
+                                   fr_ipaddr_t const *ipaddr, bool tainted)
+               CC_HINT(nonnull(1,3));
 
-int            fr_value_unbox_ipaddr(fr_ipaddr_t *dst, fr_value_box_t *src);
+int            fr_value_unbox_ipaddr(fr_ipaddr_t *dst, fr_value_box_t *src)
+               CC_HINT(nonnull);
 
-static inline CC_HINT(nonnull,always_inline) bool fr_value_box_is_safe(fr_value_box_t const *box, uint16_t safe)
+static inline CC_HINT(nonnull, always_inline)
+bool fr_value_box_is_safe(fr_value_box_t const *box, uint16_t safe)
 {
        if (!safe) return false;
 
        return (box->safe == safe);
 }
 
-int fr_value_box_mark_safe(fr_value_box_t *box, uint16_t safe) CC_HINT(nonnull);
+int            fr_value_box_mark_safe(fr_value_box_t *box, uint16_t safe)
+               CC_HINT(nonnull);
 
-void fr_value_box_mark_unsafe(fr_value_box_t *box) CC_HINT(nonnull);
+void           fr_value_box_mark_unsafe(fr_value_box_t *box)
+               CC_HINT(nonnull);
 
 /** @name Box to box copying
  *
  * @{
  */
-void           fr_value_box_clear_value(fr_value_box_t *data);
+void           fr_value_box_clear_value(fr_value_box_t *data)
+               CC_HINT(nonnull(1));
 
-void           fr_value_box_clear(fr_value_box_t *data);
+void           fr_value_box_clear(fr_value_box_t *data)
+               CC_HINT(nonnull(1));
 
-int            fr_value_box_copy(TALLOC_CTX *ctx, fr_value_box_t *dst, const fr_value_box_t *src);
+int            fr_value_box_copy(TALLOC_CTX *ctx, fr_value_box_t *dst, const fr_value_box_t *src)
+               CC_HINT(nonnull(2,3));
 
 void           fr_value_box_copy_shallow(TALLOC_CTX *ctx, fr_value_box_t *dst,
-                                         const fr_value_box_t *src);
+                                         const fr_value_box_t *src)
+               CC_HINT(nonnull(2,3));
 
-int            fr_value_box_steal(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_value_box_t *src);
+int            fr_value_box_steal(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_value_box_t *src)
+               CC_HINT(nonnull(2,3));
 /** @} */
 
 /** @name Assign and manipulate binary-unsafe C strings
@@ -739,20 +768,23 @@ int               fr_value_box_steal(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_value_box_t *sr
  * @{
  */
 int            fr_value_box_strdup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
-                                   char const *src, bool tainted);
+                                   char const *src, bool tainted)
+               CC_HINT(nonnull(2,4));
 
-int            fr_value_box_strtrim(TALLOC_CTX *ctx, fr_value_box_t *vb);
+int            fr_value_box_strtrim(TALLOC_CTX *ctx, fr_value_box_t *vb)
+               CC_HINT(nonnull(1));
 
 int            fr_value_box_vasprintf(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, bool tainted,
                                       char const *fmt, va_list ap)
-               CC_HINT(format (printf, 5, 0));
+               CC_HINT(nonnull(2,5), format(printf,5,0));
 
 int            fr_value_box_asprintf(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, bool tainted,
                                      char const *fmt, ...)
-               CC_HINT(format (printf, 5, 6));
+               CC_HINT(format(printf,5,6), nonnull(2,5));
 
 void           fr_value_box_strdup_shallow(fr_value_box_t *dst, fr_dict_attr_t const *enumv,
-                                           char const *src, bool tainted);
+                                           char const *src, bool tainted)
+               CC_HINT(nonnull(1,3));
 /** @} */
 
 /** @name Assign and manipulate binary-safe strings
@@ -760,28 +792,37 @@ void              fr_value_box_strdup_shallow(fr_value_box_t *dst, fr_dict_attr_t const *enu
  * @{
  */
 int            fr_value_box_bstr_alloc(TALLOC_CTX *ctx, char **out, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
-                                       size_t len, bool tainted);
+                                       size_t len, bool tainted)
+               CC_HINT(nonnull(2,3));
 
-int            fr_value_box_bstr_realloc(TALLOC_CTX *ctx, char **out, fr_value_box_t *dst, size_t len);
+int            fr_value_box_bstr_realloc(TALLOC_CTX *ctx, char **out, fr_value_box_t *dst, size_t len)
+               CC_HINT(nonnull(3));
 
 int            fr_value_box_bstrndup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
-                                     char const *src, size_t len, bool tainted);
+                                     char const *src, size_t len, bool tainted)
+               CC_HINT(nonnull(2,4));
 
 int            fr_value_box_bstrndup_dbuff(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
-                                           fr_dbuff_t *dbuff, size_t len, bool tainted);
+                                           fr_dbuff_t *dbuff, size_t len, bool tainted)
+               CC_HINT(nonnull(2,4));
 
 int            fr_value_box_bstrdup_buffer(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
-                                          char const *src, bool tainted);
+                                          char const *src, bool tainted)
+               CC_HINT(nonnull(2,4));
 
 void           fr_value_box_bstrndup_shallow(fr_value_box_t *dst, fr_dict_attr_t const *enumv,
-                                             char const *src, size_t len, bool tainted);
+                                             char const *src, size_t len, bool tainted)
+               CC_HINT(nonnull(1,3));
 
 int            fr_value_box_bstrdup_buffer_shallow(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
-                                                   char const *src, bool tainted);
+                                                   char const *src, bool tainted)
+               CC_HINT(nonnull(2,4));
 
-int            fr_value_box_bstrn_append(TALLOC_CTX *ctx, fr_value_box_t *dst, char const *src, size_t len, bool tainted);
+int            fr_value_box_bstrn_append(TALLOC_CTX *ctx, fr_value_box_t *dst, char const *src, size_t len, bool tainted)
+               CC_HINT(nonnull(2,3));
 
-int            fr_value_box_bstr_append_buffer(TALLOC_CTX *ctx, fr_value_box_t *dst, char const *src, bool tainted);
+int            fr_value_box_bstr_append_buffer(TALLOC_CTX *ctx, fr_value_box_t *dst, char const *src, bool tainted)
+               CC_HINT(nonnull(2,3));
 /** @} */
 
 /** @name Assign and manipulate octets strings
@@ -789,32 +830,42 @@ int               fr_value_box_bstr_append_buffer(TALLOC_CTX *ctx, fr_value_box_t *dst, char
  * @{
  */
 int            fr_value_box_mem_alloc(TALLOC_CTX *ctx, uint8_t **out, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
-                                      size_t len, bool tainted);
+                                      size_t len, bool tainted)
+               CC_HINT(nonnull(2,3));
 
-int            fr_value_box_mem_realloc(TALLOC_CTX *ctx, uint8_t **out, fr_value_box_t *dst, size_t len);
+int            fr_value_box_mem_realloc(TALLOC_CTX *ctx, uint8_t **out, fr_value_box_t *dst, size_t len)
+               CC_HINT(nonnull(3));
 
 int            fr_value_box_memdup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
-                                   uint8_t const *src, size_t len, bool tainted);
+                                   uint8_t const *src, size_t len, bool tainted)
+               CC_HINT(nonnull(2,4));
 
 int            fr_value_box_memdup_dbuff(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
-                                         fr_dbuff_t *dbuff, size_t len, bool tainted);
+                                         fr_dbuff_t *dbuff, size_t len, bool tainted)
+               CC_HINT(nonnull(2,4));
 
 int            fr_value_box_memdup_buffer(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
-                                          uint8_t const *src, bool tainted);
+                                          uint8_t const *src, bool tainted)
+               CC_HINT(nonnull(2,4));
 
 void           fr_value_box_memdup_shallow(fr_value_box_t *dst, fr_dict_attr_t const *enumv,
-                                           uint8_t const *src, size_t len, bool tainted);
+                                           uint8_t const *src, size_t len, bool tainted)
+               CC_HINT(nonnull(1,3));
 
 void           fr_value_box_memdup_buffer_shallow(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
-                                                  uint8_t const *src, bool tainted);
+                                                  uint8_t const *src, bool tainted)
+               CC_HINT(nonnull(2,4));
 
 int            fr_value_box_mem_append(TALLOC_CTX *ctx, fr_value_box_t *dst,
-                                      uint8_t const *src, size_t len, bool tainted);
+                                      uint8_t const *src, size_t len, bool tainted)
+               CC_HINT(nonnull(2,3));
 
-int            fr_value_box_mem_append_buffer(TALLOC_CTX *ctx, fr_value_box_t *dst, uint8_t const *src, bool tainted);
+int            fr_value_box_mem_append_buffer(TALLOC_CTX *ctx, fr_value_box_t *dst, uint8_t const *src, bool tainted)
+               CC_HINT(nonnull(2,3));
 /** @} */
 
-void           fr_value_box_increment(fr_value_box_t *vb);
+void           fr_value_box_increment(fr_value_box_t *vb)
+               CC_HINT(nonnull);
 
 /** @name Parsing
  *
@@ -823,13 +874,13 @@ void              fr_value_box_increment(fr_value_box_t *vb);
 ssize_t                fr_value_box_from_substr(TALLOC_CTX *ctx, fr_value_box_t *dst,
                                         fr_type_t dst_type, fr_dict_attr_t const *dst_enumv,
                                         fr_sbuff_t *in, fr_sbuff_parse_rules_t const *rules, bool tainted)
-                                        CC_HINT(nonnull(2,5));
+               CC_HINT(nonnull(2,5));
 
 ssize_t                fr_value_box_from_str(TALLOC_CTX *ctx, fr_value_box_t *dst,
                                      fr_type_t dst_type, fr_dict_attr_t const *dst_enumv,
                                      char const *in, size_t inlen,
                                      fr_sbuff_unescape_rules_t const *erules, bool tainted)
-                                     CC_HINT(nonnull(2,5));
+               CC_HINT(nonnull(2,5));
 /** @} */
 
 /** @name Work with lists of boxed values
@@ -838,43 +889,55 @@ ssize_t           fr_value_box_from_str(TALLOC_CTX *ctx, fr_value_box_t *dst,
  */
 ssize_t                fr_value_box_list_concat_as_string(bool *tainted, fr_sbuff_t *sbuff, fr_value_box_list_t *list,
                                                   char const *sep, size_t sep_len, fr_sbuff_escape_rules_t const *e_rules,
-                                                  fr_value_box_list_action_t proc_action, bool flatten);
+                                                  fr_value_box_list_action_t proc_action, bool flatten)
+               CC_HINT(nonnull(2,3));
 
 ssize_t                fr_value_box_list_concat_as_octets(bool *tainted, fr_dbuff_t *dbuff, fr_value_box_list_t *list,
                                                   uint8_t const *sep, size_t sep_len,
-                                                  fr_value_box_list_action_t proc_action, bool flatten);
+                                                  fr_value_box_list_action_t proc_action, bool flatten)
+               CC_HINT(nonnull(2,3));
 
 int            fr_value_box_list_concat_in_place(TALLOC_CTX *ctx,
                                                  fr_value_box_t *out, fr_value_box_list_t *list, fr_type_t type,
                                                  fr_value_box_list_action_t proc_action, bool flatten,
-                                                 size_t max_size);
+                                                 size_t max_size)
+               CC_HINT(nonnull(2,3));
 
 char           *fr_value_box_list_aprint(TALLOC_CTX *ctx, fr_value_box_list_t const *list, char const *delim,
-                                         fr_sbuff_escape_rules_t const *e_rules);
+                                         fr_sbuff_escape_rules_t const *e_rules)
+               CC_HINT(nonnull(2));
 
-int            fr_value_box_list_acopy(TALLOC_CTX *ctx, fr_value_box_list_t *out, fr_value_box_list_t const *in);
+int            fr_value_box_list_acopy(TALLOC_CTX *ctx, fr_value_box_list_t *out, fr_value_box_list_t const *in)
+               CC_HINT(nonnull(2,3));
 
-bool           fr_value_box_list_tainted(fr_value_box_list_t const *head);
+bool           fr_value_box_list_tainted(fr_value_box_list_t const *head)
+               CC_HINT(nonnull(1));
 
-void           fr_value_box_list_taint(fr_value_box_list_t *head);
+void           fr_value_box_list_taint(fr_value_box_list_t *head)
+               CC_HINT(nonnull(1));
 
-void           fr_value_box_list_untaint(fr_value_box_list_t *head);
+void           fr_value_box_list_untaint(fr_value_box_list_t *head)
+               CC_HINT(nonnull(1));
 /** @} */
 
 /** @name Print the value of a value box as a string
  *
  * @{
  */
-ssize_t                fr_value_box_print(fr_sbuff_t *out, fr_value_box_t const *data, fr_sbuff_escape_rules_t const *e_rules) CC_HINT(nonnull(1,2));
+ssize_t                fr_value_box_print(fr_sbuff_t *out, fr_value_box_t const *data, fr_sbuff_escape_rules_t const *e_rules)
+               CC_HINT(nonnull(1,2));
 
-ssize_t                fr_value_box_print_quoted(fr_sbuff_t *out, fr_value_box_t const *data, fr_token_t quote) CC_HINT(nonnull);
+ssize_t                fr_value_box_print_quoted(fr_sbuff_t *out, fr_value_box_t const *data, fr_token_t quote)
+               CC_HINT(nonnull);
 
-static inline fr_slen_t fr_value_box_aprint(TALLOC_CTX *ctx, char **out,
-                                           fr_value_box_t const *data, fr_sbuff_escape_rules_t const *e_rules)
+static inline CC_HINT(nonnull(2,3))
+               fr_slen_t fr_value_box_aprint(TALLOC_CTX *ctx, char **out,
+                                             fr_value_box_t const *data, fr_sbuff_escape_rules_t const *e_rules)
                SBUFF_OUT_TALLOC_FUNC_NO_LEN_DEF(fr_value_box_print, data, e_rules)
 
-static inline fr_slen_t fr_value_box_aprint_quoted(TALLOC_CTX *ctx, char **out,
-                                                  fr_value_box_t const *data, fr_token_t quote)
+static inline CC_HINT(nonnull(2,3))
+               fr_slen_t fr_value_box_aprint_quoted(TALLOC_CTX *ctx, char **out,
+                                                    fr_value_box_t const *data, fr_token_t quote)
                SBUFF_OUT_TALLOC_FUNC_NO_LEN_DEF(fr_value_box_print_quoted, data, quote)
 
 /** @} */
@@ -886,8 +949,10 @@ uint32_t   fr_value_box_hash(fr_value_box_t const *vb);
 
 /** @} */
 
-void value_box_verify(char const *file, int line, fr_value_box_t const *vb, bool talloced);
-void value_box_list_verify(char const *file, int line, fr_value_box_list_t const *list, bool talloced);
+void           value_box_verify(char const *file, int line, fr_value_box_t const *vb, bool talloced)
+               CC_HINT(nonnull(3));
+void           value_box_list_verify(char const *file, int line, fr_value_box_list_t const *list, bool talloced)
+               CC_HINT(nonnull(3));
 
 #ifdef WITH_VERIFY_PTR
 #  define VALUE_BOX_VERIFY(_x) value_box_verify(__FILE__, __LINE__, _x, false)