core: remove all the 'inner' functions in codebase

* move 'dict_keys_join()' from api/glfs_fops.c to libglusterfs/dict.c
  - also added an argument which is treated as a filter function if
    required, currently useful for fuse.

* now 'make CFLAGS="-std=gnu99 -pedantic" 2>&1 | grep nested' gives
  no output.

Change-Id: I4e18496fbd93ae1d3942026ef4931889cba015e8
Signed-off-by: Amar Tumballi <amarts@redhat.com>
BUG: 875913
Reviewed-on: http://review.gluster.org/4187
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Anand Avati <avati@redhat.com>

4 files changed, 145 insertions, 120 deletions

diff --git a/xlators/protocol/server/src/authenticate.c b/xlators/protocol/server/src/authenticate.c
index 9c843d0bb..eb6deb801 100644
--- a/xlators/protocol/server/src/authenticate.c
+++ b/xlators/protocol/server/src/authenticate.c
@@ -124,34 +124,41 @@ fini (dict_t *this, char *key, data_t *value, void *data)
         return 0;
 }
 
+static int
+_gf_auth_option_validate (dict_t *d, char *k, data_t *v, void *tmp)
+{
+        auth_handle_t *handle = NULL;
+        xlator_t      *xl = NULL;
+        int ret = 0;
+
+        xl = tmp;
+
+        handle = data_to_ptr (v);
+        if (!handle)
+                return 0;
+
+        list_add_tail (&(handle->vol_opt->list), &(xl->volume_options));
+
+        ret = xlator_options_validate_list (xl, xl->options,
+                                            handle->vol_opt, NULL);
+        if (ret) {
+                gf_log ("authenticate", GF_LOG_ERROR,
+                        "volume option validation failed");
+                return -1;
+        }
+        return 0;
+}
+
 int32_t
 gf_auth_init (xlator_t *xl, dict_t *auth_modules)
 {
         int ret = 0;
-        auth_handle_t *handle = NULL;
 
         dict_foreach (auth_modules, init, &ret);
         if (ret)
                 goto out;
 
-        int _auth_option_validate (dict_t *d, char *k, data_t *v, void *tmp)
-        {
-                handle = data_to_ptr (v);
-                if (!handle)
-                        return 0;
-
-                list_add_tail (&(handle->vol_opt->list),
-                               &(xl->volume_options));
-                ret = xlator_options_validate_list (xl, xl->options,
-                                                    handle->vol_opt, NULL);
-                if (ret) {
-                        gf_log ("authenticate", GF_LOG_ERROR,
-                                "volume option validation failed");
-                        return -1;
-                }
-                return 0;
-        }
-        ret = dict_foreach (auth_modules, _auth_option_validate, NULL);
+        ret = dict_foreach (auth_modules, _gf_auth_option_validate, xl);
 
 out:
         if (ret) {
diff --git a/xlators/protocol/server/src/server-helpers.c b/xlators/protocol/server/src/server-helpers.c
index 0adcd1cf1..28b912eec 100644
--- a/xlators/protocol/server/src/server-helpers.c
+++ b/xlators/protocol/server/src/server-helpers.c
@@ -1397,16 +1397,8 @@ gf_server_check_setxattr_cmd (call_frame_t *frame, dict_t *dict)
         if (!conf || !dict)
                 return 0;
 
-        /* this exact key is used in 'io-stats' too.
-         * But this is better place for this information dump.
-         */
-        int _handle_keyvalue_pair (dict_t *d, char *k,
-                                   data_t *v, void *tmp)
-        {
-                return 0;
-        }
         if (dict_foreach_fnmatch (dict, "*io*stat*dump",
-                                  _handle_keyvalue_pair, NULL ) > 0) {
+                                  dict_null_foreach_fn, NULL ) > 0) {
                 list_for_each_entry (xprt, &conf->xprt_list, list) {
                         total_read  += xprt->total_bytes_read;
                         total_write += xprt->total_bytes_write;
diff --git a/xlators/protocol/server/src/server-rpc-fops.c b/xlators/protocol/server/src/server-rpc-fops.c
index 286befc4e..f44ced41d 100644
--- a/xlators/protocol/server/src/server-rpc-fops.c
+++ b/xlators/protocol/server/src/server-rpc-fops.c
@@ -890,6 +890,24 @@ out:
         return 0;
 }
 
+/* print every key */
+static int
+_gf_server_log_setxattr_failure (dict_t *d, char *k, data_t *v,
+                                 void *tmp)
+{
+        server_state_t *state = NULL;
+        call_frame_t   *frame = NULL;
+
+        frame = tmp;
+        state = CALL_STATE(frame);
+
+        gf_log (THIS->name, GF_LOG_INFO,
+                "%"PRId64": SETXATTR %s (%s) ==> %s",
+                frame->root->unique, state->loc.path,
+                uuid_utoa (state->resolve.gfid), k);
+        return 0;
+}
+
 int
 server_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
@@ -905,19 +923,14 @@ server_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                                     rsp.xdata.xdata_len, op_errno, out);
 
         if (op_ret == -1) {
-                /* print every key */
-                int _log_setxattr_failure (dict_t *d, char *k, data_t *v,
-                                           void *tmp)
-                {
-                        gf_log (this->name, ((op_errno == ENOTSUP) ?
-                                             GF_LOG_DEBUG : GF_LOG_INFO),
-                                "%"PRId64": SETXATTR %s (%s) ==> %s (%s)",
-                                frame->root->unique, state->loc.path,
-                                uuid_utoa (state->resolve.gfid), k,
-                                strerror (op_errno));
-                        return 0;
-                }
-                dict_foreach (state->dict, _log_setxattr_failure, NULL);
+                if (op_errno != ENOTSUP)
+                        dict_foreach (state->dict,
+                                      _gf_server_log_setxattr_failure,
+                                      frame);
+
+                gf_log (THIS->name, ((op_errno == ENOTSUP) ?
+                                     GF_LOG_DEBUG : GF_LOG_INFO),
+                        "%s", strerror (op_errno));
                 goto out;
         }
 
@@ -933,6 +946,24 @@ out:
         return 0;
 }
 
+/* print every key here */
+static int
+_gf_server_log_fsetxattr_failure (dict_t *d, char *k, data_t *v,
+                                 void *tmp)
+{
+        call_frame_t   *frame = NULL;
+        server_state_t *state = NULL;
+
+        frame = tmp;
+        state = CALL_STATE(frame);
+
+        gf_log (THIS->name, GF_LOG_INFO,
+                "%"PRId64": FSETXATTR %"PRId64" (%s) ==> %s",
+                frame->root->unique, state->resolve.fd_no,
+                uuid_utoa (state->resolve.gfid), k);
+
+        return 0;
+}
 
 int
 server_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
@@ -949,19 +980,14 @@ server_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                                     rsp.xdata.xdata_len, op_errno, out);
 
         if (op_ret == -1) {
-                /* print every key here */
-                int _log_setxattr_failure (dict_t *d, char *k, data_t *v,
-                                           void *tmp)
-                {
-                        gf_log (this->name, ((op_errno == ENOTSUP) ?
-                                             GF_LOG_DEBUG : GF_LOG_INFO),
-                                "%"PRId64": FSETXATTR %"PRId64" (%s) ==> %s (%s)",
-                                frame->root->unique, state->resolve.fd_no,
-                                uuid_utoa (state->resolve.gfid), k,
-                                strerror (op_errno));
-                        return 0;
+                if (op_errno != ENOTSUP) {
+                        dict_foreach (state->dict,
+                                      _gf_server_log_fsetxattr_failure,
+                                      frame);
                 }
-                dict_foreach (state->dict, _log_setxattr_failure, NULL);
+                gf_log (THIS->name, ((op_errno == ENOTSUP) ?
+                                     GF_LOG_DEBUG : GF_LOG_INFO),
+                        "%s", strerror (op_errno));
                 goto out;
         }
 
diff --git a/xlators/protocol/server/src/server.c b/xlators/protocol/server/src/server.c
index 19f09a82f..d2bc4876c 100644
--- a/xlators/protocol/server/src/server.c
+++ b/xlators/protocol/server/src/server.c
@@ -616,84 +616,85 @@ out:
         return 0;
 }
 
+int
+_check_for_auth_option (dict_t *d, char *k, data_t *v,
+                        void *tmp)
+{
+        int       ret           = 0;
+        xlator_t *xl            = NULL;
+        char     *tail          = NULL;
+        char     *tmp_addr_list = NULL;
+        char     *addr          = NULL;
+        char     *tmp_str       = NULL;
+
+        xl = tmp;
+
+        tail = strtail (k, "auth.");
+        if (!tail)
+                goto out;
+
+        /* fast fwd thru module type */
+        tail = strchr (tail, '.');
+        if (!tail)
+                goto out;
+        tail++;
+
+        tail = strtail (tail, xl->name);
+        if (!tail)
+                goto out;
+
+        if (*tail == '.') {
+                /* when we are here, the key is checked for
+                 * valid auth.allow.<xlator>
+                 * Now we verify the ip address
+                 */
+                if (!strcmp (v->data, "*")) {
+                        ret = 0;
+                        goto out;
+                }
+
+                tmp_addr_list = gf_strdup (v->data);
+                addr = strtok_r (tmp_addr_list, ",", &tmp_str);
+                if (!addr)
+                        addr = v->data;
+
+                while (addr) {
+                        if (valid_internet_address (addr, _gf_true)) {
+                                ret = 0;
+                        } else {
+                                ret = -1;
+                                gf_log (xl->name, GF_LOG_ERROR,
+                                        "internet address '%s'"
+                                        " does not conform to"
+                                        " standards.", addr);
+                                goto out;
+                        }
+                        if (tmp_str)
+                                addr = strtok_r (NULL, ",", &tmp_str);
+                        else
+                                addr = NULL;
+                }
+
+                GF_FREE (tmp_addr_list);
+                tmp_addr_list = NULL;
+        }
+out:
+        return ret;
+}
 
 int
 validate_auth_options (xlator_t *this, dict_t *dict)
 {
         int            error = -1;
         xlator_list_t *trav = NULL;
-        char          *tail = NULL;
-        char          *tmp_addr_list = NULL;
-        char          *addr = NULL;
-        char          *tmp_str = NULL;
 
         GF_VALIDATE_OR_GOTO ("server", this, out);
         GF_VALIDATE_OR_GOTO ("server", dict, out);
 
         trav = this->children;
         while (trav) {
-                int _check_for_auth_option (dict_t *d, char *k, data_t *v,
-                                            void *tmp)
-                {
-                        int ret = 0;
-                        tail = strtail (k, "auth.");
-                        if (!tail)
-                                goto internal_out;
-
-                        /* fast fwd thru module type */
-                        tail = strchr (tail, '.');
-                        if (!tail)
-                                goto internal_out;
-                        tail++;
-
-                        tail = strtail (tail, trav->xlator->name);
-                        if (!tail)
-                                goto internal_out;
-
-                        if (*tail == '.') {
-
-                                /* when we are here, the key is checked for
-                                 * valid auth.allow.<xlator>
-                                 * Now we verify the ip address
-                                 */
-                                if (!strcmp (v->data, "*")) {
-                                        ret = 0;
-                                        goto internal_out;
-                                }
-
-                                tmp_addr_list = gf_strdup (v->data);
-                                addr = strtok_r (tmp_addr_list, ",", &tmp_str);
-                                if (!addr)
-                                        addr = v->data;
-
-                                while (addr) {
-
-                                        if (valid_internet_address (addr,
-                                                                    _gf_true)) {
-                                                ret = 0;
-                                        } else {
-                                                ret = -1;
-                                                gf_log (this->name, GF_LOG_ERROR,
-                                                        "internet address '%s'"
-                                                        " does not conform to"
-                                                        " standards.", addr);
-                                                goto internal_out;
-
-                                        }
-                                        if (tmp_str)
-                                                addr = strtok_r (NULL, ",",
-                                                                 &tmp_str);
-                                        else
-                                                addr = NULL;
-                                }
-
-                                GF_FREE (tmp_addr_list);
-                                tmp_addr_list = NULL;
-                        }
-                internal_out:
-                        return ret;
-                }
-                error = dict_foreach (dict, _check_for_auth_option, NULL);
+                error = dict_foreach (dict, _check_for_auth_option,
+                                      trav->xlator);
 
                 if (-1 == error) {
                         gf_log (this->name, GF_LOG_ERROR,
@@ -706,7 +707,6 @@ validate_auth_options (xlator_t *this, dict_t *dict)
         }
 
 out:
-        GF_FREE (tmp_addr_list);
         return error;
 }