diff options
Diffstat (limited to 'xlators')
| -rw-r--r-- | xlators/nfs/server/src/Makefile.am | 4 | ||||
| -rw-r--r-- | xlators/nfs/server/src/exports.c | 1437 | ||||
| -rw-r--r-- | xlators/nfs/server/src/exports.h | 92 | ||||
| -rw-r--r-- | xlators/nfs/server/src/nfs-mem-types.h | 1 | ||||
| -rw-r--r-- | xlators/nfs/server/src/nfs.h | 3 |
5 files changed, 1535 insertions, 2 deletions
diff --git a/xlators/nfs/server/src/Makefile.am b/xlators/nfs/server/src/Makefile.am index c72b314c458..94f47021178 100644 --- a/xlators/nfs/server/src/Makefile.am +++ b/xlators/nfs/server/src/Makefile.am @@ -4,13 +4,13 @@ nfsrpclibdir = $(top_srcdir)/rpc/rpc-lib/src server_la_LDFLAGS = -module -avoid-version server_la_SOURCES = nfs.c nfs-common.c nfs-fops.c nfs-inodes.c \ nfs-generics.c mount3.c nfs3-fh.c nfs3.c nfs3-helpers.c nlm4.c \ - nlmcbk_svc.c mount3udp_svc.c acl3.c netgroups.c + nlmcbk_svc.c mount3udp_svc.c acl3.c netgroups.c exports.c server_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \ $(top_builddir)/api/src/libgfapi.la noinst_HEADERS = nfs.h nfs-common.h nfs-fops.h nfs-inodes.h nfs-generics.h \ mount3.h nfs3-fh.h nfs3.h nfs3-helpers.h nfs-mem-types.h nlm4.h \ - acl3.h netgroups.h + acl3.h netgroups.h exports.h AM_CPPFLAGS = $(GF_CPPFLAGS) \ -DLIBDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)/auth\" \ diff --git a/xlators/nfs/server/src/exports.c b/xlators/nfs/server/src/exports.c new file mode 100644 index 00000000000..3f704bdf9ce --- /dev/null +++ b/xlators/nfs/server/src/exports.c @@ -0,0 +1,1437 @@ +/* + Copyright 2014-present Facebook. All Rights Reserved + + This file is part of GlusterFS. + + Author : + Shreyas Siravara <shreyas.siravara@gmail.com> + + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. +*/ + +#include "exports.h" +#include "hashfn.h" +#include "parse-utils.h" + +static void _exp_dict_destroy (dict_t *ng_dict); +static void _export_options_print (const struct export_options *opts); +static void _export_options_deinit (struct export_options *opts); +static void _export_dir_deinit (struct export_dir *dir); + +static struct parser *netgroup_parser; +static struct parser *hostname_parser; +static struct parser *options_parser; + +/** + * _exp_init_parsers -- Initialize parsers to be used in this file + * + * @return: success: 0 + * failure: -1 + */ +static int +_exp_init_parsers () +{ + int ret = -1; + + netgroup_parser = parser_init (NETGROUP_REGEX_PATTERN); + if (!netgroup_parser) + goto out; + + hostname_parser = parser_init (HOSTNAME_REGEX_PATTERN); + if (!hostname_parser) + goto out; + + options_parser = parser_init (OPTIONS_REGEX_PATTERN); + if (!options_parser) + goto out; + + ret = 0; +out: + return ret; +} + +/** + * _exp_deinit_parsers -- Free parsers used in this file + */ +static void +_exp_deinit_parsers () +{ + parser_deinit (netgroup_parser); + parser_deinit (hostname_parser); + parser_deinit (options_parser); +} + +/** + * _export_file_init -- Initialize an exports file structure. + * + * @return : success: Pointer to an allocated exports file struct + * failure: NULL + * + * Not for external use. + */ +struct exports_file * +_exports_file_init () +{ + struct exports_file *file = NULL; + + file = GF_CALLOC (1, sizeof (*file), gf_nfs_mt_exports); + if (!file) { + gf_log (GF_EXP, GF_LOG_CRITICAL, + "Failed to allocate file struct!"); + goto out; + } + + file->exports_dict = dict_new (); + file->exports_map = dict_new (); + if (!file->exports_dict || !file->exports_map) { + gf_log (GF_EXP, GF_LOG_CRITICAL, "Failed to allocate dict!"); + goto free_and_out; + } + + + + goto out; + +free_and_out: + GF_FREE (file); + file = NULL; +out: + return file; +} + +/** + * _exp_file_dict_destroy -- Delete each item in the dict + * + * @dict : Dict to free elements from + * @key : Key in the dict we are on + * @val : Value associated with that dict + * @tmp : Not used + * + * Not for external use. + */ +static int +_exp_file_dict_destroy (dict_t *dict, char *key, data_t *val, void *tmp) +{ + struct export_dir *dir = NULL; + + GF_VALIDATE_OR_GOTO (GF_EXP, dict, out); + + if (val) { + dir = (struct export_dir *)val->data; + + _export_dir_deinit (dir); + val->data = NULL; + dict_del (dict, key); + } + +out: + return 0; +} + +/** + * _exp_file_deinit -- Free memory used by an export file + * + * @expfile : Pointer to the exports file to free + * + * Externally usable. + */ +void +exp_file_deinit (struct exports_file *expfile) +{ + if (!expfile || !expfile->exports_dict) + goto out; + + dict_foreach (expfile->exports_dict, _exp_file_dict_destroy, NULL); + GF_FREE (expfile->filename); + GF_FREE (expfile); +out: + return; +} + +/** + * _export_dir_init -- Initialize an export directory structure. + * + * @return : success: Pointer to an allocated exports directory struct + * failure: NULL + * + * Not for external use. + */ +static struct export_dir * +_export_dir_init () +{ + struct export_dir *expdir = GF_CALLOC (1, sizeof (*expdir), + gf_nfs_mt_exports); + + if (!expdir) + gf_log (GF_EXP, GF_LOG_CRITICAL, + "Failed to allocate export dir structure!"); + + return expdir; +} + +/** + * _export_dir_deinit -- Free memory used by an export dir + * + * @expdir : Pointer to the export directory to free + * + * Not for external use. + */ +static void +_export_dir_deinit (struct export_dir *dir) +{ + GF_VALIDATE_OR_GOTO (GF_EXP, dir, out); + GF_FREE (dir->dir_name); + _exp_dict_destroy (dir->netgroups); + _exp_dict_destroy (dir->hosts); + GF_FREE (dir); + +out: + return; +} + + +/** + * _export_item_print -- Print the elements in the export item. + * + * @expdir : Pointer to the item struct to print out. + * + * Not for external use. + */ +static void +_export_item_print (const struct export_item *item) +{ + GF_VALIDATE_OR_GOTO (GF_EXP, item, out); + printf ("%s", item->name); + _export_options_print (item->opts); +out: + return; +} + +/** + * _export_item_init -- Initialize an export item structure + * + * @return : success: Pointer to an allocated exports item struct + * failure: NULL + * + * Not for external use. + */ +static struct export_item * +_export_item_init () +{ + struct export_item *item = GF_CALLOC (1, sizeof (*item), + gf_nfs_mt_exports); + + if (!item) + gf_log (GF_EXP, GF_LOG_CRITICAL, + "Failed to allocate export item!"); + + return item; +} + +/** + * _export_item_deinit -- Free memory used by an export item + * + * @expdir : Pointer to the export item to free + * + * Not for external use. + */ +static void +_export_item_deinit (struct export_item *item) +{ + if (!item) + return; + + _export_options_deinit (item->opts); + GF_FREE (item->name); + GF_FREE (item); +} + +/** + * _export_host_init -- Initialize an export options struct + * + * @return : success: Pointer to an allocated options struct + * failure: NULL + * + * Not for external use. + */ +static struct export_options * +_export_options_init () +{ + struct export_options *opts = GF_CALLOC (1, sizeof (*opts), + gf_nfs_mt_exports); + + if (!opts) + gf_log (GF_EXP, GF_LOG_CRITICAL, + "Failed to allocate options structure!"); + + return opts; +} + +/** + * _export_options_deinit -- Free memory used by a options struct + * + * @expdir : Pointer to the options struct to free + * + * Not for external use. + */ +static void +_export_options_deinit (struct export_options *opts) +{ + if (!opts) + return; + + GF_FREE (opts->anon_uid); + GF_FREE (opts->sec_type); + GF_FREE (opts); +} + +/** + * _export_options_print -- Print the elements in the options struct. + * + * @expdir : Pointer to the options struct to print out. + * + * Not for external use. + */ +static void +_export_options_print (const struct export_options *opts) +{ + GF_VALIDATE_OR_GOTO (GF_EXP, opts, out); + + printf ("("); + if (opts->rw) + printf ("rw,"); + else + printf ("ro,"); + + if (opts->nosuid) + printf ("nosuid,"); + + if (opts->root) + printf ("root,"); + + if (opts->anon_uid) + printf ("anonuid=%s,", opts->anon_uid); + + if (opts->sec_type) + printf ("sec=%s,", opts->sec_type); + + printf (") "); +out: + return; +} + +/** + * __exp_dict_free_walk -- Delete each item in the dict + * + * @dict : Dict to free elements from + * @key : Key in the dict we are on + * @val : Value associated with that dict + * @tmp : Not used + * + * Passed as a function pointer to dict_foreach() + * + * Not for external use. + */ +static int +__exp_dict_free_walk (dict_t *dict, char *key, data_t *val, void *tmp) +{ + if (val) { + _export_item_deinit ((struct export_item *)val->data); + val->data = NULL; + dict_del (dict, key); + } + return 0; +} + +/** + * _exp_dict_destroy -- Delete all the items from this dict + * through the helper function above. + * + * @ng_dict : Dict to free + * + * Not for external use. + */ +static void +_exp_dict_destroy (dict_t *ng_dict) +{ + if (!ng_dict) + goto out; + + dict_foreach (ng_dict, __exp_dict_free_walk, NULL); +out: + return; +} + +/** + * exp_file_dir_from_uuid -- Using a uuid as the key, retrieve an exports + * directory from the file. + * + * @file: File to retrieve data from + * @export_uuid: UUID of the export (mountid in the NFS xlator) + * + * @return : success: Pointer to an export dir struct + * failure: NULL + */ +struct export_dir * +exp_file_dir_from_uuid (const struct exports_file *file, + const uuid_t export_uuid) +{ + char export_uuid_str[512] = {0, }; + data_t *dirdata = NULL; + struct export_dir *dir = NULL; + + uuid_unparse (export_uuid, export_uuid_str); + + dirdata = dict_get (file->exports_map, export_uuid_str); + if (dirdata) + dir = (struct export_dir *)dirdata->data; + + return dir; +} + +/** + * _exp_file_insert -- Insert the exports directory into the file structure + * using the directory as a dict. Also hashes the dirname, + * stores it in a uuid type, converts the uuid type to a + * string and uses that as the key to the exports map. + * The exports map maps an export "uuid" to an export + * directory struct. + * + * @file : Exports file struct to insert into + * @dir : Export directory to insert + * + * Not for external use. + */ +static void +_exp_file_insert (struct exports_file *file, struct export_dir *dir) +{ + data_t *dirdata = NULL; + uint32_t hashedval = 0; + uuid_t export_uuid = {0, }; + char export_uuid_str[512] = {0, }; + char *dirdup = NULL; + + GF_VALIDATE_OR_GOTO (GF_EXP, file, out); + GF_VALIDATE_OR_GOTO (GF_EXP, dir, out); + + dirdata = bin_to_data (dir, sizeof (*dir)); + dict_set (file->exports_dict, dir->dir_name, dirdata); + + dirdup = strdupa (dir->dir_name); + while (strlen (dirdup) > 0 && dirdup[0] == '/') + dirdup++; + + hashedval = SuperFastHash (dirdup, strlen (dirdup)); + memset (export_uuid, 0, sizeof (export_uuid)); + memcpy (export_uuid, &hashedval, sizeof (hashedval)); + uuid_unparse (export_uuid, export_uuid_str); + + dict_set (file->exports_map, export_uuid_str, dirdata); +out: + return; +} + +/** + * __exp_item_print_walk -- Print all the keys and values in the dict + * + * @dict : the dict to walk + * @key : the key in the dict we are currently on + * @val : the value in the dict assocated with the key + * @tmp : Additional parameter data (not used) + * + * Passed as a function pointer to dict_foreach (). + * + * Not for external use. + */ +static int +__exp_item_print_walk (dict_t *dict, char *key, data_t *val, void *tmp) +{ + if (val) + _export_item_print ((struct export_item *)val->data); + + return 0; +} + +/** + * __exp_file_print_walk -- Print all the keys and values in the dict + * + * @dict : the dict to walk + * @key : the key in the dict we are currently on + * @val : the value in the dict assocated with the key + * @tmp : Additional parameter data (not used) + * + * Passed as a function pointer to dict_foreach (). + * + * Not for external use. + */ +static int +__exp_file_print_walk (dict_t *dict, char *key, data_t *val, void *tmp) +{ + if (val) { + struct export_dir *dir = (struct export_dir *)val->data; + + printf ("%s ", key); + + if (dir->netgroups) + dict_foreach (dir->netgroups, __exp_item_print_walk, + NULL); + + if (dir->hosts) + dict_foreach (dir->hosts, __exp_item_print_walk, NULL); + + printf ("\n"); + } + return 0; +} + +/** + * exp_file_print -- Print out the contents of the exports file + * + * @file : Exports file to print + * + * Not for external use. + */ +void +exp_file_print (const struct exports_file *file) +{ + GF_VALIDATE_OR_GOTO (GF_EXP, file, out); + dict_foreach (file->exports_dict, __exp_file_print_walk, NULL); +out: + return; +} + +#define __exp_line_get_opt_val(val, equals, ret, errlabel) \ + do { \ + (val) = (equals) + 1; \ + if (!(*(val))) { \ + (ret) = 1; \ + goto errlabel; \ + } \ + } while (0) \ + +enum gf_exp_parse_status { + GF_EXP_PARSE_SUCCESS = 0, + GF_EXP_PARSE_ITEM_NOT_FOUND = 1, + GF_EXP_PARSE_ITEM_FAILURE = 2, + GF_EXP_PARSE_ITEM_NOT_IN_MOUNT_STATE = 3, + GF_EXP_PARSE_LINE_IGNORING = 4, +}; + +/** + * __exp_line_opt_key_value_parse -- Parse the key-value options in the options + * string. + * + * Given a string like (sec=sys,anonuid=0,rw), to parse, this function + * will get called once with 'sec=sys' and again with 'anonuid=0'. + * It will check for the '=', make sure there is data to be read + * after the '=' and copy the data into the options struct. + * + * @option : An option string like sec=sys or anonuid=0 + * @opts : Pointer to an struct export_options that holds all the export + * options. + * + * @return: success: GF_EXP_PARSE_SUCCESS + * failure: GF_EXP_PARSE_ITEM_FAILURE on parse failure, + * -EINVAL on bad args, -ENOMEM on allocation errors. + * + * Not for external use. + */ +static int +__exp_line_opt_key_value_parse (char *option, struct export_options *opts) +{ + char *equals = NULL; + char *right = NULL; + char *strmatch = option; + int ret = -EINVAL; + + GF_VALIDATE_OR_GOTO (GF_EXP, option, out); + GF_VALIDATE_OR_GOTO (GF_EXP, opts, out); + + equals = strchr (option, '='); + if (!equals) { + ret = GF_EXP_PARSE_ITEM_FAILURE; + goto out; + } + + *equals = 0; + /* Now that an '=' has been found the left side is the option and + * the right side is the value. We simply have to compare those and + * extract it. + */ + if (strcmp (strmatch, "anonuid") == 0) { + *equals = '='; + /* Get the value for this option */ + __exp_line_get_opt_val (right, equals, ret, out); + opts->anon_uid = gf_strdup (right); + GF_CHECK_ALLOC (opts->anon_uid, ret, out); + } else if (strcmp (strmatch, "sec") == 0) { + *equals = '='; + /* Get the value for this option */ + __exp_line_get_opt_val (right, equals, ret, out); + opts->sec_type = gf_strdup (right); + GF_CHECK_ALLOC (opts->sec_type, ret, out); + } else { + *equals = '='; + ret = GF_EXP_PARSE_ITEM_FAILURE; + goto out; + } + + ret = GF_EXP_PARSE_SUCCESS; +out: + return ret; +} + +/** + * __exp_line_opt_parse -- Parse the options part of an + * exports or netgroups string. + * + * @opt_str : The option string to parse + * @exp_opts : Double pointer to the options we are going + * to allocate and setup. + * + * + * @return: success: GF_EXP_PARSE_SUCCESS + * failure: GF_EXP_PARSE_ITEM_FAILURE on parse failure, + * -EINVAL on bad args, -ENOMEM on allocation errors. + * + * Not for external use. + */ +static int +__exp_line_opt_parse (const char *opt_str, struct export_options **exp_opts) +{ + struct export_options *opts = NULL; + char *strmatch = NULL; + int ret = -EINVAL; + char *equals = NULL; + + ret = parser_set_string (options_parser, opt_str); + if (ret < 0) + goto out; + + while ((strmatch = parser_get_next_match (options_parser))) { + if (!opts) { + /* If the options have not been allocated, + * allocate it. + */ + opts = _export_options_init (); + if (!opts) { + ret = -ENOMEM; + parser_unset_string (options_parser); + goto out; + } + } + + /* First, check for all the boolean options Second, check for + * an '=', and check the available options there. The string + * parsing here gets slightly messy, but the concept itself + * is pretty simple. + */ + equals = strchr (strmatch, '='); + if (strcmp (strmatch, "root") == 0) + opts->root = _gf_true; + else if (strcmp (strmatch, "ro") == 0) + opts->rw = _gf_false; + else if (strcmp (strmatch, "rw") == 0) + opts->rw = _gf_true; + else if (strcmp (strmatch, "nosuid") == 0) + opts->nosuid = _gf_true; + else if (equals) { + ret = __exp_line_opt_key_value_parse (strmatch, opts); + if (ret < 0) { + /* This means invalid key value options were + * specified, or memory allocation failed. + * The ret value gets bubbled up to the caller. + */ + GF_FREE (strmatch); + parser_unset_string (options_parser); + _export_options_deinit (opts); + goto out; + } + } else + gf_log (GF_EXP, GF_LOG_WARNING, + "Could not find any valid options for " + "string: %s", strmatch); + GF_FREE (strmatch); + } + + if (!opts) { + /* If opts is not allocated + * that means no matches were found + * which is a parse error. Not marking + * it as "not found" because it is a parse + * error to not have options. + */ + ret = GF_EXP_PARSE_ITEM_FAILURE; + parser_unset_string (options_parser); + goto out; + } + + *exp_opts = opts; + parser_unset_string (options_parser); + ret = GF_EXP_PARSE_SUCCESS; +out: + return ret; +} + + +/** + * __exp_line_ng_host_str_parse -- Parse the netgroup or host string + * + * e.g. @mygroup(<options>), parsing @mygroup and (<options>) + * or myhost001.dom(<options>), parsing myhost001.dom and (<options>) + * + * @line : The line to parse + * @exp_item : Double pointer to a struct export_item + * + * @return: success: GF_PARSE_SUCCESS + * failure: GF_EXP_PARSE_ITEM_FAILURE on parse failure, + * -EINVAL on bad args, -ENOMEM on allocation errors. + * + * Not for external use. + */ +static int +__exp_line_ng_host_str_parse (char *str, struct export_item **exp_item) +{ + struct export_item *item = NULL; + int ret = -EINVAL; + char *parens = NULL; + char *optstr = NULL; + struct export_options *exp_opts = NULL; + char *item_name = NULL; + + GF_VALIDATE_OR_GOTO (GF_EXP, str, out); + GF_VALIDATE_OR_GOTO (GF_EXP, exp_item, out); + + /* A netgroup/host string looks like this: + * @test(sec=sys,rw,anonuid=0) or host(sec=sys,rw,anonuid=0) + * We want to extract the name, 'test' or 'host' + * Again, we could setup a regex and use it here, + * but its simpler to find the '(' and copy until + * there. + */ + parens = strchr (str, '('); + if (!parens) { + /* Parse error if there are no parens. */ + ret = GF_EXP_PARSE_ITEM_FAILURE; + goto out; + } + + *parens = '\0'; /* Temporarily terminate it so we can do a copy */ + + if (strlen (str) > FQDN_MAX_LEN) { + ret = GF_EXP_PARSE_ITEM_FAILURE; + goto out; + } + + /* Strip leading whitespaces */ + while (*str == ' ' || *str == '\t') + str++; + + item_name = gf_strdup (str); + GF_CHECK_ALLOC (item_name, ret, out); + + /* Initialize an export item for this */ + item = _export_item_init (); + GF_CHECK_ALLOC (item, ret, free_and_out); + item->name = item_name; + + *parens = '('; /* Restore the string */ + + /* Options start at the parantheses */ + optstr = parens; + + ret = __exp_line_opt_parse (optstr, &exp_opts); + if (ret != 0) { + /* Bubble up the error to the caller */ + _export_item_deinit (item); + goto out; + } + + item->opts = exp_opts; + + *exp_item = item; + + ret = GF_EXP_PARSE_SUCCESS; + goto out; + +free_and_out: + GF_FREE (item_name); +out: + return ret; +} + +/** + * __exp_line_ng_parse -- Extract the netgroups in the line + * and call helper functions to parse + * the string. + * + * The call chain goes like this: + * + * 1) __exp_line_ng_parse ("/test @test(sec=sys,rw,anonuid=0)") + * 2) __exp_line_ng_str_parse ("@test(sec=sys,rw,anonuid=0)"); + * 3) __exp_line_opt_parse("(sec=sys,rw,anonuid=0)"); + * + * + * @line : The line to parse + * @ng_dict : Double pointer to the dict we want to + * insert netgroups into. + * + * Allocates the dict, extracts netgroup strings from the line, + * parses them into a struct export_item structure and inserts + * them in the dict. + * + * @return: success: GF_EXP_PARSE_SUCCESS + * failure: GF_EXP_PARSE_ITEM_FAILURE on parse failure, + * GF_EXP_PARSE_ITEM_NOT_FOUND if the netgroup was not found + * -EINVAL on bad args, -ENOMEM on allocation errors. + * + * Not for external use. + */ +static int +__exp_line_ng_parse (const char *line, dict_t **ng_dict) +{ + dict_t *netgroups = NULL; + char *strmatch = NULL; + int ret = -EINVAL; + struct export_item *exp_ng = NULL; + data_t *ngdata = NULL; + + GF_VALIDATE_OR_GOTO (GF_EXP, line, out); + GF_VALIDATE_OR_GOTO (GF_EXP, ng_dict, out); + + *ng_dict = NULL; /* Will be set if parse is successful */ + + /* Initialize a parser with the line to parse + * and the regex used to parse it. + */ + ret = parser_set_string (netgroup_parser, line); + if (ret < 0) { + goto out; + } + + while ((strmatch = parser_get_next_match (netgroup_parser))) { + if (!netgroups) { + /* Allocate a new dict to store the netgroups. */ + netgroups = dict_new (); + if (!netgroups) { + ret = -ENOMEM; + goto free_and_out; + } + } + + ret = __exp_line_ng_host_str_parse (strmatch, &exp_ng); + + if (ret != 0) { + /* Parsing or other critical errors. + * caller will handle return value. + */ + _exp_dict_destroy (netgroups); + goto free_and_out; + } + + ngdata = bin_to_data (exp_ng, sizeof (*exp_ng)); + dict_set (netgroups, exp_ng->name, ngdata); + + /* Free this matched string and continue parsing. */ + GF_FREE (strmatch); + } + + /* If the netgroups dict was not allocated, then we know that + * no matches were found. + */ + if (!netgroups) { + ret = GF_EXP_PARSE_ITEM_NOT_FOUND; + parser_unset_string (netgroup_parser); + goto out; + } + + ret = GF_EXP_PARSE_SUCCESS; + *ng_dict = netgroups; + +free_and_out: + parser_unset_string (netgroup_parser); + GF_FREE (strmatch); +out: + return ret; +} + +/** + * __exp_line_host_parse -- Extract the hosts in the line + * and call helper functions to parse + * the string. + * + * The call chain goes like this: + * + * 1) __exp_line_host_parse ("/test hostip(sec=sys,rw,anonuid=0)") + * 2) __exp_line_ng_host_str_parse ("hostip(sec=sys,rw,anonuid=0)"); + * 3) __exp_line_opt_parse("(sec=sys,rw,anonuid=0)"); + * + * + * @line : The line to parse + * @ng_dict : Double pointer to the dict we want to + * insert hosts into. + * + * Allocates the dict, extracts host strings from the line, + * parses them into a struct export_item structure and inserts + * them in the dict. + * + * @return: success: GF_EXP_PARSE_SUCCESS + * failure: GF_EXP_PARSE_ITEM_FAILURE on parse failure, + * GF_EXP_PARSE_ITEM_NOT_FOUND if the host was not found, + * -EINVAL on bad args, -ENOMEM on allocation errors. + * + * Not for external use. + */ +static int +__exp_line_host_parse (const char *line, dict_t **host_dict) +{ + dict_t *hosts = NULL; + char *strmatch = NULL; + int ret = -EINVAL; + struct export_item *exp_host = NULL; + data_t *hostdata = NULL; + + GF_VALIDATE_OR_GOTO (GF_EXP, line, out); + GF_VALIDATE_OR_GOTO (GF_EXP, host_dict, out); + + *host_dict = NULL; + + /* Initialize a parser with the line to parse and the regex used to + * parse it. + */ + ret = parser_set_string (hostname_parser, line); + if (ret < 0) { + goto out; + } + + while ((strmatch = parser_get_next_match (hostname_parser))) { + if (!hosts) { + /* Allocate a new dictto store the netgroups. */ + hosts = dict_new (); + GF_CHECK_ALLOC (hosts, ret, free_and_out); + } + + ret = __exp_line_ng_host_str_parse (strmatch, &exp_host); + + if (ret != 0) { + /* Parsing or other critical error, free allocated + * memory and exit. The caller will handle the errors. + */ + _exp_dict_destroy (hosts); + goto free_and_out; + } + + /* Insert export item structure into the hosts dict. */ + hostdata = bin_to_data (exp_host, sizeof (*exp_host)); + dict_set (hosts, exp_host->name, hostdata); + + + /* Free this matched string and continue parsing.*/ + GF_FREE (strmatch); + } + + /* If the hosts dict was not allocated, then we know that + * no matches were found. + */ + if (!exp_host) { + ret = GF_EXP_PARSE_ITEM_NOT_FOUND; + parser_unset_string (hostname_parser); + goto out; + } + + ret = GF_EXP_PARSE_SUCCESS; + *host_dict = hosts; + +free_and_out: + parser_unset_string (hostname_parser); + GF_FREE (strmatch); +out: + return ret; +} + + +/** + * __exp_line_dir_parse -- Extract directory name from a line in the exports + * file. + * + * @line : The line to parse + * @dirname : Double pointer to the string we need to hold the directory name. + * If the parsing failed, the string will point to NULL, otherwise + * it will point to a valid memory region that is allocated by + * this function. + * @check_ms: If this variable is set then we cross check the directory line + * with whats in gluster's vol files and reject them if they don't + * match. + * + * @return : success: GF_EXP_PARSE_SUCCESS + * failure: GF_EXP_PARSE_ITEM_FAILURE on parse failure, + * -EINVAL on bad arguments, -ENOMEM on allocation failures, + * GF_EXP_PARSE_ITEM_NOT_IN_MOUNT_STATE if we failed to match + * with gluster's mountstate. + * + * The caller is responsible for freeing memory allocated by this function + * + * Not for external use. + */ +static int +__exp_line_dir_parse (const char *line, char **dirname, struct mount3_state *ms) +{ + char *dir = NULL; + char *delim = NULL; + int ret = -EINVAL; + char *linedup = NULL; + struct mnt3_export *mnt3export = NULL; + size_t dirlen = 0; + + GF_VALIDATE_OR_GOTO (GF_EXP, line, out); + GF_VALIDATE_OR_GOTO (GF_EXP, dirname, out); + + /* Duplicate the line because we don't + * want to modify the original string. + */ + linedup = strdupa (line); + + /* We use strtok_r () here to split the string by space/tab and get the + * the result. We only need the first result of the split. + * a simple task. It is worth noting that dirnames always have to be + * validated against gluster's vol files so if they don't + * match it will be rejected. + */ + dir = linedup; + delim = linedup + strcspn (linedup, " \t"); + *delim = 0; + + if (ms) { + /* Match the directory name with an existing + * export in the mount state. + */ + mnt3export = mnt3_mntpath_to_export (ms, dir, _gf_true); + if (!mnt3export) { + gf_log (GF_EXP, GF_LOG_DEBUG, "%s not in mount state, " + "ignoring!", dir); + ret = GF_EXP_PARSE_ITEM_NOT_IN_MOUNT_STATE; + goto out; + } + } + + /* Directories can be 1024 bytes in length, check + * that the argument provided adheres to + * that restriction. + */ + if (strlen (dir) > DIR_MAX_LEN) { + ret = -EINVAL; + goto out; + } + + /* Copy the result of the split */ + dir = gf_strdup (dir); + GF_CHECK_ALLOC (dir, ret, out); + + /* Ensure that trailing slashes are stripped before storing the name */ + dirlen = strlen (dir); + if (dirlen > 0 && dir[dirlen - 1] == '/') + dir[dirlen - 1] = '\0'; + + + /* Set the argument to point to the allocated string */ + *dirname = dir; + ret = GF_EXP_PARSE_SUCCESS; +out: + return ret; +} + +/** + * _exp_line_parse -- Parse a line in an exports file into a structure + * that holds all the parts of the line. An exports + * structure has a dict of netgroups and a dict of hosts. + * + * An export line looks something like this /test @test(sec=sys,rw,anonuid=0) + * or /test @test(sec=sys,rw,anonuid=0) hostA(sec=sys,rw,anonuid=0), etc. + * + * We use regexes to parse the line into three separate pieces: + * 1) The directory (exports.h -- DIRECTORY_REGEX_PATTERN) + * 2) The netgroup if it exists (exports.h -- NETGROUP_REGEX_PATTERN) + * 3) The host if it exists (exports.h -- HOST_REGEX_PATTERN) + * + * In this case, the netgroup would be @test(sec=sys,rw,anonuid=0) + * and the host would be hostA(sec=sys,rw,anonuid=0). + * + * @line : The line to parse + * @dir : Double pointer to the struct we need to parse the line into. + * If the parsing failed, the struct will point to NULL, + * otherwise it will point to a valid memory region that is + * allocated by this function. + * @parse_full : This parameter tells us whether we should parse all the lines + * in the file, even if they are not present in gluster's config. + * The gluster config holds the volumes that it exports so + * if parse_full is set to FALSE then we will ensure that + * the export file structure holds only those volumes + * that gluster has exported. It is important to note that + * If gluster exports a volume named '/test', '/test' and all + * of its subdirectories that may be in the exports file + * are valid exports. + * @ms : The mount state that holds the list of volumes that gluster + * currently exports. + * + * @return : success: GF_EXP_PARSE_SUCCESS on success, -EINVAL on bad arguments, + * -ENOMEM on memory allocation errors, + * GF_EXP_PARSE_LINE_IGNORING if we ignored the line, + * GF_EXP_PARSE_ITEM_FAILURE if there was error parsing + * failure: NULL + * + * The caller is responsible for freeing memory allocated by this function + * The caller should free this memory using the _exp_dir_deinit () function. + * + * Not for external use. + */ +static int +_exp_line_parse (const char *line, struct export_dir **dir, + gf_boolean_t parse_full, struct mount3_state *ms) +{ + struct export_dir *expdir = NULL; + char *dirstr = NULL; + dict_t *netgroups = NULL; + dict_t *hosts = NULL; + int ret = -EINVAL; + gf_boolean_t netgroups_failed = _gf_false; + + GF_VALIDATE_OR_GOTO (GF_EXP, line, out); + GF_VALIDATE_OR_GOTO (GF_EXP, dir, out); + + if (*line == '#' || *line == ' ' || *line == '\t' + || *line == '\0' || *line == '\n') { + ret = GF_EXP_PARSE_LINE_IGNORING; + goto out; + } + + expdir = _export_dir_init (); + if (!expdir) { + *dir = NULL; + ret = -ENOMEM; + goto out; + } + + /* Get the directory string from the line */ + ret = __exp_line_dir_parse (line, &dirstr, ms); + if (ret < 0) { + gf_log (GF_EXP, GF_LOG_ERROR, "Parsing directory failed: %s", + strerror (-ret)); + /* If parsing the directory failed, + * we should simply fail because there's + * nothing else we can extract from the string to make + * the data valuable. + */ + goto free_and_out; + } + + /* Set the dir str */ + expdir->dir_name = dirstr; + + /* Parse the netgroup part of the string */ + ret = __exp_line_ng_parse (line, &netgroups); + if (ret < 0) { + gf_log (GF_EXP, GF_LOG_ERROR, "Critical error: %s", + strerror (-ret)); + /* Return values less than 0 + * indicate critical failures (null parameters, + * failure to allocate memory, etc). + */ + goto free_and_out; + } + if (ret != 0) { + if (ret == GF_EXP_PARSE_ITEM_FAILURE) + gf_log (GF_EXP, GF_LOG_WARNING, + "Error parsing netgroups for: %s", line); + /* Even though parsing failed for the netgroups we should let + * host parsing proceed. + */ + netgroups_failed = _gf_true; + } + + /* Parse the host part of the string */ + ret = __exp_line_host_parse (line, &hosts); + if (ret < 0) { + gf_log (GF_EXP, GF_LOG_ERROR, "Critical error: %s", + strerror (-ret)); + goto free_and_out; + } + if (ret != 0) { + if (ret == GF_EXP_PARSE_ITEM_FAILURE) + gf_log (GF_EXP, GF_LOG_WARNING, + "Error parsing hosts for: %s", line); + /* If netgroups parsing failed, AND + * host parsing failed, then theres something really + * wrong with this line, so we're just going to + * log it and fail out. + */ + if (netgroups_failed) + goto free_and_out; + } + + expdir->hosts = hosts; + expdir->netgroups = netgroups; + *dir = expdir; + goto out; + +free_and_out: + _export_dir_deinit (expdir); +out: + return ret; +} + +struct export_item * +exp_dir_get_netgroup (const struct export_dir *expdir, const char *netgroup) +{ + struct export_item *lookup_res = NULL; + data_t *dict_res = NULL; + + GF_VALIDATE_OR_GOTO (GF_EXP, expdir, out); + GF_VALIDATE_OR_GOTO (GF_EXP, netgroup, out); + + if (!expdir->netgroups) + goto out; + + dict_res = dict_get (expdir->netgroups, (char *)netgroup); + if (!dict_res) { + gf_log (GF_EXP, GF_LOG_DEBUG, "%s not found for %s", + netgroup, expdir->dir_name); + } + + lookup_res = (struct export_item *)dict_res->data; +out: + return lookup_res; +} +/** + * exp_dir_get_host -- Given a host string and an exports directory structure, + * find and return an struct export_item structure that + * represents the requested host. + * + * @expdir: Export directory to lookup from + * @host : Host string to lookup + * + * @return: success: Pointer to a export item structure + * failure: NULL + */ +struct export_item * +exp_dir_get_host (const struct export_dir *expdir, const char *host) +{ + struct export_item *lookup_res = NULL; + data_t *dict_res = NULL; + + GF_VALIDATE_OR_GOTO (GF_EXP, expdir, out); + GF_VALIDATE_OR_GOTO (GF_EXP, host, out); + + if (!expdir->hosts) + goto out; + + dict_res = dict_get (expdir->hosts, (char *)host); + if (!dict_res) { + gf_log (GF_EXP, GF_LOG_DEBUG, "%s not found for %s", + host, expdir->dir_name); + + /* Check if wildcards are allowed for the host */ + dict_res = dict_get (expdir->hosts, "*"); + if (!dict_res) { + goto out; + } + } + + lookup_res = (struct export_item *)dict_res->data; +out: + return lookup_res; +} + + +/** + * exp_file_get_dir -- Return an export dir given a directory name + * Does a lookup from the dict in the file structure. + * + * @file : Exports file structure to lookup from + * @dir : Directory name to lookup + * + * @return : success: Pointer to an export directory structure + * failure: NULL + */ +struct export_dir * +exp_file_get_dir (const struct exports_file *file, const char *dir) +{ + struct export_dir *lookup_res = NULL; + data_t *dict_res = NULL; + char *dirdup = NULL; + size_t dirlen = 0; + + GF_VALIDATE_OR_GOTO (GF_EXP, file, out); + GF_VALIDATE_OR_GOTO (GF_EXP, dir, out); + + dirlen = strlen (dir); + if (dirlen <= 0) + goto out; + + dirdup = (char *)dir; /* Point at the directory */ + + /* If directories don't contain a leading slash */ + if (*dir != '/') { + dirdup = alloca (dirlen + 2); /* Leading slash & null byte */ + snprintf (dirdup, dirlen + 2, "/%s", dir); + } + + dict_res = dict_get (file->exports_dict, dirdup); + if (!dict_res) { + gf_log (GF_EXP, GF_LOG_DEBUG, "%s not found in %s", dirdup, + file->filename); + goto out; + } + + lookup_res = (struct export_dir *)dict_res->data; +out: + return lookup_res; +} + +/** + * exp_file_parse -- Parse an exports file into a structure + * that can be looked up through simple + * function calls. + * + * @filepath: Path to the exports file + * @ms : Current mount state (useful to match with gluster vol files) + * + * @return : success: 0 + * failure: -1 on parsing failure, -EINVAL on bad arguments, + * -ENOMEM on allocation failures. + * + * The caller is responsible for freeing memory allocated by this function. + * The caller should free this memory using the exp_file_deinit () function. + * Calling GF_FREE ( ) on the pointer will NOT free all the allocated memory. + * + * Externally usable. + */ +int +exp_file_parse (const char *filepath, struct exports_file **expfile, + struct mount3_state *ms) +{ + FILE *fp = NULL; + struct exports_file *file = NULL; + size_t len = 0; + int ret = -EINVAL; + unsigned long line_number = 0; + char *line = NULL; + struct export_dir *expdir = NULL; + + /* Sets whether we we should parse the entire file or just that which + * is present in the mount state */ + gf_boolean_t parse_complete_file = _gf_false; + + GF_VALIDATE_OR_GOTO (GF_EXP, expfile, parse_done); + + if (!ms) { + /* If mount state is null that means that we + * should go through and parse the whole file + * since we don't have anything to compare against. + */ + parse_complete_file = _gf_true; + } + + fp = fopen (filepath, "r"); + if (!fp) { + ret = -errno; + goto parse_done; + } + + ret = _exp_init_parsers (); + if (ret < 0) + goto parse_done; + + /* Process the file line by line, with each line being parsed into + * an struct export_dir struct. If 'parse_complete_file' is set to TRUE + * then + */ + while (getline (&line, &len, fp) != -1) { + line_number++; /* Keeping track of line number allows us to + * to log which line numbers were wrong + */ + strtok (line, "\n"); /* removes the newline character from + * the line + */ + + /* Parse the line from the file into an struct export_dir + * structure. The process is as follows: + * Given a line like : + * "/vol @test(sec=sys,rw,anonuid=0) 10.35.11.31(sec=sys,rw)" + * + * This function will allocate an export dir and set its name + * to '/vol', using the function _exp_line_dir_parse (). + * + * Then it will extract the netgroups from the line, in this + * case it would be '@test(sec=sys,rw,anonuid=0)', and set the + * item structure's name to '@test'. + * It will also extract the options from that string and parse + * them into an struct export_options which will be pointed + * to by the item structure. This will be put into a dict + * which will be pointed to by the export directory structure. + * + * The same process happens above for the host string + * '10.35.11.32(sec=sys,rw)' + */ + ret = _exp_line_parse (line, &expdir, parse_complete_file, ms); + if (ret == -ENOMEM) { + /* If we get memory allocation errors, we really should + * not continue parsing, so just free the allocated + * memory and exit. + */ + goto free_and_done; + } + + if (ret < 0) { + gf_log (GF_EXP, GF_LOG_ERROR, + "Failed to parse line #%lu", line_number); + continue; /* Skip entering this line and continue */ + } + + if (ret == GF_EXP_PARSE_LINE_IGNORING) { + /* This just means the line was empty or started with a + * '#' or a ' ' and we are ignoring it. + */ + gf_log (GF_EXP, GF_LOG_DEBUG, + "Ignoring line #%lu because it started " + "with a %c", line_number, *line); + continue; + } + + if (!file) { + file = _exports_file_init (); + GF_CHECK_ALLOC_AND_LOG (GF_EXP, file, ret, + "Allocation error while " + "allocating file struct", + parse_done); + + file->filename = gf_strdup (filepath); + GF_CHECK_ALLOC_AND_LOG (GF_EXP, file, ret, + "Allocation error while " + "duping filepath", + free_and_done); + } + + /* If the parsing is successful store the export directory + * in the file structure. + */ + _exp_file_insert (file, expdir); + } + + /* line got allocated through getline(), don't use GF_FREE() for it */ + free (line); + + *expfile = file; + goto parse_done; + +free_and_done: + exp_file_deinit (file); + +parse_done: + if (fp) + fclose (fp); + _exp_deinit_parsers (); + return ret; +} diff --git a/xlators/nfs/server/src/exports.h b/xlators/nfs/server/src/exports.h new file mode 100644 index 00000000000..51a3cd668a4 --- /dev/null +++ b/xlators/nfs/server/src/exports.h @@ -0,0 +1,92 @@ +/* + Copyright 2014-present Facebook. All Rights Reserved + + This file is part of GlusterFS. + + Author : + Shreyas Siravara <shreyas.siravara@gmail.com> + + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. +*/ + +#ifndef _EXPORTS_H_ +#define _EXPORTS_H_ + +#include "nfs-mem-types.h" +#include "dict.h" +#include "nfs.h" + +#define GF_EXP GF_NFS"-exports" + +#define NETGROUP_REGEX_PATTERN "(@([a-zA-Z0-9\\(=, .])+)())" +#define HOSTNAME_REGEX_PATTERN "[[:space:]]([a-zA-Z0-9.\\(=,*/)]+)" +#define OPTIONS_REGEX_PATTERN "([a-zA-Z0-9=\\.]+)" + +#define NETGROUP_MAX_LEN 128 +#define FQDN_MAX_LEN 256 + +#define SEC_OPTION_MAX 10 +#define UID_MAX_LEN 6 + +#define DIR_MAX_LEN 1024 + +/* The following 2 definitions are in mount3.h + * but we don't want to include it because mount3.h + * depends on structs in this file so we get a cross + * dependency. + */ +struct mount3_state; + +extern struct mnt3_export * +mnt3_mntpath_to_export (struct mount3_state *ms, const char *dirpath, + gf_boolean_t export_parsing_match); + +struct export_options { + gf_boolean_t rw; /* Read-write option */ + gf_boolean_t nosuid; /* nosuid option */ + gf_boolean_t root; /* root option */ + char *anon_uid; /* anonuid option */ + char *sec_type; /* X, for sec=X */ +}; + +struct export_item { + char *name; /* Name of the export item */ + struct export_options *opts; /* NFS Options */ +}; + +struct export_dir { + char *dir_name; /* Directory */ + dict_t *netgroups; /* Dict of netgroups */ + dict_t *hosts; /* Dict of hosts */ +}; + +struct exports_file { + char *filename; /* Filename */ + dict_t *exports_dict; /* Dict of export_dir_t */ + dict_t *exports_map; /* Map of SuperFastHash(<export>) -> expdir */ +}; + +void +exp_file_deinit (struct exports_file *expfile); + +int +exp_file_parse (const char *filepath, struct exports_file **expfile, + struct mount3_state *ms); + +struct export_dir * +exp_file_get_dir (const struct exports_file *file, const char *dir); + +struct export_item * +exp_dir_get_host (const struct export_dir *expdir, const char *host); + +struct export_item * +exp_dir_get_netgroup (const struct export_dir *expdir, const char *netgroup); + +struct export_dir * +exp_file_dir_from_uuid (const struct exports_file *file, + const uuid_t export_uuid); + +#endif /* _EXPORTS_H_ */ diff --git a/xlators/nfs/server/src/nfs-mem-types.h b/xlators/nfs/server/src/nfs-mem-types.h index d9e2c9904c9..33adcf5e292 100644 --- a/xlators/nfs/server/src/nfs-mem-types.h +++ b/xlators/nfs/server/src/nfs-mem-types.h @@ -47,6 +47,7 @@ enum gf_nfs_mem_types_ { gf_nfs_mt_inode_ctx, gf_nfs_mt_auth_spec, gf_nfs_mt_netgroups, + gf_nfs_mt_exports, gf_nfs_mt_arr, gf_nfs_mt_end }; diff --git a/xlators/nfs/server/src/nfs.h b/xlators/nfs/server/src/nfs.h index fc745fbbdc4..4c51d11d49c 100644 --- a/xlators/nfs/server/src/nfs.h +++ b/xlators/nfs/server/src/nfs.h @@ -38,6 +38,9 @@ #define GF_NFS_DVM_ON 1 #define GF_NFS_DVM_OFF 0 +/* Disable using the exports file by default */ +#define GF_NFS_DEFAULT_EXPORT_AUTH 0 + /* This corresponds to the max 16 number of group IDs that are sent through an * RPC request. Since NFS is the only one going to set this, we can be safe * in keeping this size hardcoded. |