Rename resolution functions

diff --git a/src/lib/server/tmpl_tokenize.c b/src/lib/server/tmpl_tokenize.c
index 60d0d109244a2f1d4caa3e6ad1b68c04787e3506..afbb94f82790c8b47a91609db1c7dd456de91bbd 100644 (file)
--- a/src/lib/server/tmpl_tokenize.c
+++ b/src/lib/server/tmpl_tokenize.c
@@ -1395,8 +1395,8 @@ static inline int tmpl_attr_afrom_attr_substr(TALLOC_CTX *ctx, tmpl_attr_error_t
         *      No parent means we need to go hunting through all the dictionaries
         */
        if (!parent) {
-               slen = fr_dict_attr_by_qualified_name_substr(&dict_err, &da,
-                                                            rules->dict_def, name, !rules->disallow_internal);
+               slen = fr_dict_attr_by_qualified_oid_substr(&dict_err, &da,
+                                                           rules->dict_def, name, !rules->disallow_internal);
        /*
         *      Otherwise we're resolving in the context of the last component,
         *      or its reference in the case of group attributes.
@@ -2865,8 +2865,9 @@ static inline CC_HINT(always_inline) int tmpl_attr_resolve(tmpl_t *vpt)
         */
        ar = fr_dlist_head(&vpt->data.attribute.ar);
        if (ar->type == TMPL_ATTR_TYPE_UNRESOLVED) {
-               if (fr_dict_attr_by_qualified_name(&da, vpt->rules.dict_def,
-                                                  ar->ar_unresolved, true) != FR_DICT_ATTR_OK) {
+               da = fr_dict_attr_by_qualified_oid(NULL, vpt->rules.dict_def,
+                                                  ar->ar_unresolved, true);
+               if (!da) {
                        parent = fr_dict_root(vpt->rules.dict_def);
                        goto unknown;
                }

diff --git a/src/lib/util/dict.h b/src/lib/util/dict.h
index 02fd773fb79b0654202525c096613c720caf7866..77dc9e1e4f255a9b5d02ac5f5f503672ebe716b1 100644 (file)
--- a/src/lib/util/dict.h
+++ b/src/lib/util/dict.h
@@ -469,12 +469,13 @@ ssize_t                   fr_dict_attr_by_name_substr(fr_dict_attr_err_t *err, fr_dict_attr_t co
 fr_dict_attr_t const   *fr_dict_attr_by_name(fr_dict_attr_err_t *err, fr_dict_attr_t const *parent, char const *attr)
                        CC_HINT(nonnull(2,3));
 
-ssize_t                        fr_dict_attr_by_qualified_name_substr(fr_dict_attr_err_t *err, fr_dict_attr_t const **out,
-                                                             fr_dict_t const *dict_def,
-                                                             fr_sbuff_t *name, bool fallback);
+ssize_t                        fr_dict_attr_by_qualified_oid_substr(fr_dict_attr_err_t *err, fr_dict_attr_t const **out,
+                                                            fr_dict_t const *dict_def,
+                                                            fr_sbuff_t *name, bool fallback);
 
-fr_dict_attr_err_t     fr_dict_attr_by_qualified_name(fr_dict_attr_t const **out,
-                                                      fr_dict_t const *dict_def, char const *attr, bool fallback);
+fr_dict_attr_t const   *fr_dict_attr_by_qualified_oid(fr_dict_attr_err_t *err,
+                                                      fr_dict_t const *dict_def, char const *attr, bool fallback)
+                                                      CC_HINT(nonnull(3));
 
 fr_dict_attr_t const   *fr_dict_attr_by_type(fr_dict_attr_t const *da, fr_type_t type);
 

diff --git a/src/lib/util/dict_util.c b/src/lib/util/dict_util.c
index 1947a09105ed70a7184d07c58b2b25f3e6e65180..8f02d65c19fa5d05f67c194922068787f21bed39 100644 (file)
--- a/src/lib/util/dict_util.c
+++ b/src/lib/util/dict_util.c
@@ -2360,8 +2360,8 @@ fr_dict_attr_t const *fr_dict_attr_by_name(fr_dict_attr_err_t *err, fr_dict_attr
  *     - <= 0 on failure.
  *     - The number of bytes of name consumed on success.
  */
-ssize_t fr_dict_attr_by_qualified_name_substr(fr_dict_attr_err_t *err, fr_dict_attr_t const **out,
-                                             fr_dict_t const *dict_def, fr_sbuff_t *name, bool fallback)
+ssize_t fr_dict_attr_by_qualified_oid_substr(fr_dict_attr_err_t *err, fr_dict_attr_t const **out,
+                                            fr_dict_t const *dict_def, fr_sbuff_t *name, bool fallback)
 {
        fr_dict_t               *dict = NULL;
        fr_dict_t               *dict_iter = NULL;
@@ -2479,30 +2479,32 @@ again:
 
 /** Locate a qualified #fr_dict_attr_t by its name and a dictionary qualifier
  *
- * @param[out] out             Dictionary found attribute.
+ * @param[out] err             Why parsing failed. May be NULL.
+ *                             @see fr_dict_attr_err_t.
  * @param[in] dict_def         Default dictionary for non-qualified dictionaries.
  * @param[in] name             Dictionary/Attribute name.
  * @param[in] fallback         If true, fallback to the internal dictionary.
  * @return an #fr_dict_attr_err_t value.
  */
-fr_dict_attr_err_t fr_dict_attr_by_qualified_name(fr_dict_attr_t const **out, fr_dict_t const *dict_def,
-                                                 char const *name, bool fallback)
+fr_dict_attr_t const *fr_dict_attr_by_qualified_oid(fr_dict_attr_err_t *err, fr_dict_t const *dict_def,
+                                                   char const *name, bool fallback)
 {
        ssize_t                 slen;
-       fr_dict_attr_err_t      err = FR_DICT_ATTR_PARSE_ERROR;
        fr_sbuff_t              our_name;
+       fr_dict_attr_t const    *da;
 
        fr_sbuff_init(&our_name, name, strlen(name) + 1);
 
-       slen = fr_dict_attr_by_qualified_name_substr(&err, out, dict_def, &our_name, fallback);
-       if (slen <= 0) return err;
+       slen = fr_dict_attr_by_qualified_oid_substr(err, &da, dict_def, &our_name, fallback);
+       if (slen <= 0) return NULL;
 
        if ((size_t)slen != fr_sbuff_len(&our_name)) {
                fr_strerror_printf("Trailing garbage after attr string \"%s\"", name);
-               return FR_DICT_ATTR_PARSE_ERROR;
+               if (err) *err = FR_DICT_ATTR_PARSE_ERROR;
+               return NULL;
        }
 
-       return FR_DICT_ATTR_OK;
+       return da;
 }
 
 /** Lookup a attribute by its its vendor and attribute numbers and data type

diff --git a/src/lib/util/pair_legacy.c b/src/lib/util/pair_legacy.c
index aec6941128048c8bee61aa16e0dcd9e25e36a60c..744c4ed2899515fb94a526c80b435312fb0da6f2 100644 (file)
--- a/src/lib/util/pair_legacy.c
+++ b/src/lib/util/pair_legacy.c
@@ -152,7 +152,8 @@ fr_pair_t *fr_pair_make(TALLOC_CTX *ctx, fr_dict_t const *dict, fr_pair_list_t *
         *      It's not found in the dictionary, so we use
         *      another method to create the attribute.
         */
-       if (fr_dict_attr_by_qualified_name(&da, dict, attrname, true) != FR_DICT_ATTR_OK) {
+       da = fr_dict_attr_by_qualified_oid(NULL, dict, attrname, true);
+       if (da) {
                vp = fr_pair_make_unknown(ctx, dict, attrname, value, op);
                if (!vp) return NULL;
 

diff --git a/src/modules/rlm_detail/rlm_detail.c b/src/modules/rlm_detail/rlm_detail.c
index cd454e2b81181b06998e6b1b2900ca43bdf9bec5..a06e1a596b30595575502f699322e055a2a71c46 100644 (file)
--- a/src/modules/rlm_detail/rlm_detail.c
+++ b/src/modules/rlm_detail/rlm_detail.c
@@ -185,7 +185,8 @@ static int mod_instantiate(void *instance, CONF_SECTION *conf)
                        attr = cf_pair_attr(cf_item_to_pair(ci));
                        if (!attr) continue; /* pair-anoia */
 
-                       if (fr_dict_attr_by_qualified_name(&da, dict_radius, attr, false) != FR_DICT_ATTR_OK) {
+                       da = fr_dict_attr_by_qualified_oid(NULL, dict_radius, attr, false);
+                       if (da) {
                                cf_log_perr(conf, "Failed resolving attribute");
                                return -1;
                        }

diff --git a/src/modules/rlm_passwd/rlm_passwd.c b/src/modules/rlm_passwd/rlm_passwd.c
index bee77d99d19d747ecdc5fc9ac735d97a2c197e32..eafa720145f192124e40bb8ed173bfa5607dc554 100644 (file)
--- a/src/modules/rlm_passwd/rlm_passwd.c
+++ b/src/modules/rlm_passwd/rlm_passwd.c
@@ -479,8 +479,9 @@ static int mod_instantiate(void *instance, CONF_SECTION *conf)
                return -1;
        }
 
-       if (fr_dict_attr_by_qualified_name(&da, dict_freeradius,
-                                          inst->pwd_fmt->field[key_field], true) != FR_DICT_ATTR_OK) {
+       da = fr_dict_attr_by_qualified_oid(NULL, dict_freeradius,
+                                          inst->pwd_fmt->field[key_field], true);
+       if (!da) {
                PERROR("Unable to resolve attribute");
                release_ht(inst->ht);
                inst->ht = NULL;

diff --git a/src/modules/rlm_sql/rlm_sql.c b/src/modules/rlm_sql/rlm_sql.c
index 75595faaef6808bbfb3379cfe438042c93939304..7234a2aa3d28c444c7de0cda9b907dc15c958088 100644 (file)
--- a/src/modules/rlm_sql/rlm_sql.c
+++ b/src/modules/rlm_sql/rlm_sql.c
@@ -1075,8 +1075,8 @@ static int mod_bootstrap(void *instance, CONF_SECTION *conf)
                        goto error;
                }
 
-               if (fr_dict_attr_by_qualified_name(&inst->group_da, dict_freeradius,
-                                                  group_attribute, false) != FR_DICT_ATTR_OK) {
+               inst->group_da = fr_dict_attr_by_qualified_oid(NULL, dict_freeradius, group_attribute, false);
+               if (!inst->group_da) {
                        PERROR("Failed resolving group attribute");
                        goto error;
                }

diff --git a/src/modules/rlm_sqlippool/rlm_sqlippool.c b/src/modules/rlm_sqlippool/rlm_sqlippool.c
index 0ef5be21fe7001a2698c3a048717b6cbac153fb1..49c96e22aabe478b1873edac99d27424e1c78b4f 100644 (file)
--- a/src/modules/rlm_sqlippool/rlm_sqlippool.c
+++ b/src/modules/rlm_sqlippool/rlm_sqlippool.c
@@ -428,8 +428,9 @@ static int mod_instantiate(void *instance, CONF_SECTION *conf)
                return -1;
        }
 
-       if (fr_dict_attr_by_qualified_name(&inst->allocated_address_da,
-                                          dict_freeradius, inst->allocated_address_attr, false) != FR_DICT_ATTR_OK) {
+       inst->allocated_address_da = fr_dict_attr_by_qualified_oid(NULL, dict_freeradius,
+                                                                  inst->allocated_address_attr, false);
+       if (!inst->allocated_address_da) {
                cf_log_perr(conf, "Failed resolving attribute");
                return -1;
        }