kernel/compat/parser.c

/*
 * lib/parser.c - simple parser for mount, etc. options.
 *
 * This source code is licensed under the GNU General Public License,
 * Version 2.  See the file COPYING for more details.
 */

#include <linux/config.h>
#ifdef CONFIG_MODVERSIONS
#define MODVERSIONS
#include <linux/modversions.h>
#endif

#include "parser.h"

#include <linux/ctype.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/string.h>

/**
 * match_one: - Determines if a string matches a simple pattern
 * @s: the string to examine for presense of the pattern
 * @p: the string containing the pattern
 * @args: array of %MAX_OPT_ARGS &substring_t elements. Used to return match
 * locations.
 *
 * Description: Determines if the pattern @p is present in string @s. Can only
 * match extremely simple token=arg style patterns. If the pattern is found,
 * the location(s) of the arguments will be returned in the @args array.
 */
static int match_one(char *s, char *p, substring_t args[])
{
        char *meta;
        int argc = 0;

        if (!p)
                return 1;

        while(1) {
                int len = -1;
                meta = strchr(p, '%');
                if (!meta)
                        return strcmp(p, s) == 0;

                if (strncmp(p, s, meta-p))
                        return 0;

                s += meta - p;
                p = meta + 1;

                if (isdigit(*p))
                        len = simple_strtoul(p, &p, 10);
                else if (*p == '%') {
                        if (*s++ != '%')
                                return 0;
                        continue;
                }

                if (argc >= MAX_OPT_ARGS)
                        return 0;

                args[argc].from = s;
                switch (*p++) {
                case 's':
                        if (strlen(s) == 0)
                                return 0;
                        else if (len == -1 || len > strlen(s))
                                len = strlen(s);
                        args[argc].to = s + len;
                        break;
                case 'd':
                        simple_strtol(s, &args[argc].to, 0);
                        goto num;
                case 'u':
                        simple_strtoul(s, &args[argc].to, 0);
                        goto num;
                case 'o':
                        simple_strtoul(s, &args[argc].to, 8);
                        goto num;
                case 'x':
                        simple_strtoul(s, &args[argc].to, 16);
                num:
                        if (args[argc].to == args[argc].from)
                                return 0;
                        break;
                default:
                        return 0;
                }
                s = args[argc].to;
                argc++;
        }
}

/**
 * match_token: - Find a token (and optional args) in a string
 * @s: the string to examine for token/argument pairs
 * @table: match_table_t describing the set of allowed option tokens and the
 * arguments that may be associated with them. Must be terminated with a
 * &struct match_token whose pattern is set to the NULL pointer.
 * @args: array of %MAX_OPT_ARGS &substring_t elements. Used to return match
 * locations.
 *
 * Description: Detects which if any of a set of token strings has been passed
 * to it. Tokens can include up to MAX_OPT_ARGS instances of basic c-style
 * format identifiers which will be taken into account when matching the
 * tokens, and whose locations will be returned in the @args array.
 */
int match_token(char *s, match_table_t table, substring_t args[])
{
        struct match_token *p;

        for (p = table; !match_one(s, p->pattern, args) ; p++)
                ;

        return p->token;
}

/**
 * match_number: scan a number in the given base from a substring_t
 * @s: substring to be scanned
 * @result: resulting integer on success
 * @base: base to use when converting string
 *
 * Description: Given a &substring_t and a base, attempts to parse the substring
 * as a number in that base. On success, sets @result to the integer represented
 * by the string and returns 0. Returns either -ENOMEM or -EINVAL on failure.
 */
static int match_number(substring_t *s, int *result, int base)
{
        char *endp;
        char *buf;
        int ret;

        buf = kmalloc(s->to - s->from + 1, GFP_KERNEL);
        if (!buf)
                return -ENOMEM;
        memcpy(buf, s->from, s->to - s->from);
        buf[s->to - s->from] = '\0';
        *result = simple_strtol(buf, &endp, base);
        ret = 0;
        if (endp == buf)
                ret = -EINVAL;
        kfree(buf);
        return ret;
}

/**
 * match_int: - scan a decimal representation of an integer from a substring_t
 * @s: substring_t to be scanned
 * @result: resulting integer on success
 *
 * Description: Attempts to parse the &substring_t @s as a decimal integer. On
 * success, sets @result to the integer represented by the string and returns 0.
 * Returns either -ENOMEM or -EINVAL on failure.
 */
int match_int(substring_t *s, int *result)
{
        return match_number(s, result, 0);
}

/**
 * match_octal: - scan an octal representation of an integer from a substring_t
 * @s: substring_t to be scanned
 * @result: resulting integer on success
 *
 * Description: Attempts to parse the &substring_t @s as an octal integer. On
 * success, sets @result to the integer represented by the string and returns
 * 0. Returns either -ENOMEM or -EINVAL on failure.
 */
int match_octal(substring_t *s, int *result)
{
        return match_number(s, result, 8);
}

/**
 * match_hex: - scan a hex representation of an integer from a substring_t
 * @s: substring_t to be scanned
 * @result: resulting integer on success
 *
 * Description: Attempts to parse the &substring_t @s as a hexadecimal integer.
 * On success, sets @result to the integer represented by the string and
 * returns 0. Returns either -ENOMEM or -EINVAL on failure.
 */
int match_hex(substring_t *s, int *result)
{
        return match_number(s, result, 16);
}

/**
 * match_strcpy: - copies the characters from a substring_t to a string
 * @to: string to copy characters to.
 * @s: &substring_t to copy
 *
 * Description: Copies the set of characters represented by the given
 * &substring_t @s to the c-style string @to. Caller guarantees that @to is
 * large enough to hold the characters of @s.
 */
void match_strcpy(char *to, substring_t *s)
{
        memcpy(to, s->from, s->to - s->from);
        to[s->to - s->from] = '\0';
}

/**
 * match_strdup: - allocate a new string with the contents of a substring_t
 * @s: &substring_t to copy
 *
 * Description: Allocates and returns a string filled with the contents of
 * the &substring_t @s. The caller is responsible for freeing the returned
 * string with kfree().
 */
char *match_strdup(substring_t *s)
{
        char *p = kmalloc(s->to - s->from + 1, GFP_KERNEL);
        if (p)
                match_strcpy(p, s);
        return p;
}

1	dpavlin	4	/*
2			* lib/parser.c - simple parser for mount, etc. options.
3			*
4			* This source code is licensed under the GNU General Public License,
5			* Version 2. See the file COPYING for more details.
6			*/
7
8			#include <linux/config.h>
9			#ifdef CONFIG_MODVERSIONS
10			#define MODVERSIONS
11			#include <linux/modversions.h>
12			#endif
13
14			#include "parser.h"
15
16			#include <linux/ctype.h>
17			#include <linux/module.h>
18			#include <linux/slab.h>
19			#include <linux/string.h>
20
21			/**
22			* match_one: - Determines if a string matches a simple pattern
23			* @s: the string to examine for presense of the pattern
24			* @p: the string containing the pattern
25			* @args: array of %MAX_OPT_ARGS &substring_t elements. Used to return match
26			* locations.
27			*
28			* Description: Determines if the pattern @p is present in string @s. Can only
29			* match extremely simple token=arg style patterns. If the pattern is found,
30			* the location(s) of the arguments will be returned in the @args array.
31			*/
32			static int match_one(char s, char p, substring_t args[])
33			{
34			char *meta;
35			int argc = 0;
36
37			if (!p)
38			return 1;
39
40			while(1) {
41			int len = -1;
42			meta = strchr(p, '%');
43			if (!meta)
44			return strcmp(p, s) == 0;
45
46			if (strncmp(p, s, meta-p))
47			return 0;
48
49			s += meta - p;
50			p = meta + 1;
51
52			if (isdigit(*p))
53			len = simple_strtoul(p, &p, 10);
54			else if (*p == '%') {
55			if (*s++ != '%')
56			return 0;
57			continue;
58			}
59
60			if (argc >= MAX_OPT_ARGS)
61			return 0;
62
63			args[argc].from = s;
64			switch (*p++) {
65			case 's':
66			if (strlen(s) == 0)
67			return 0;
68			else if (len == -1 \|\| len > strlen(s))
69			len = strlen(s);
70			args[argc].to = s + len;
71			break;
72			case 'd':
73			simple_strtol(s, &args[argc].to, 0);
74			goto num;
75			case 'u':
76			simple_strtoul(s, &args[argc].to, 0);
77			goto num;
78			case 'o':
79			simple_strtoul(s, &args[argc].to, 8);
80			goto num;
81			case 'x':
82			simple_strtoul(s, &args[argc].to, 16);
83			num:
84			if (args[argc].to == args[argc].from)
85			return 0;
86			break;
87			default:
88			return 0;
89			}
90			s = args[argc].to;
91			argc++;
92			}
93			}
94
95			/**
96			* match_token: - Find a token (and optional args) in a string
97			* @s: the string to examine for token/argument pairs
98			* @table: match_table_t describing the set of allowed option tokens and the
99			* arguments that may be associated with them. Must be terminated with a
100			* &struct match_token whose pattern is set to the NULL pointer.
101			* @args: array of %MAX_OPT_ARGS &substring_t elements. Used to return match
102			* locations.
103			*
104			* Description: Detects which if any of a set of token strings has been passed
105			* to it. Tokens can include up to MAX_OPT_ARGS instances of basic c-style
106			* format identifiers which will be taken into account when matching the
107			* tokens, and whose locations will be returned in the @args array.
108			*/
109			int match_token(char *s, match_table_t table, substring_t args[])
110			{
111			struct match_token *p;
112
113			for (p = table; !match_one(s, p->pattern, args) ; p++)
114			;
115
116			return p->token;
117			}
118
119			/**
120			* match_number: scan a number in the given base from a substring_t
121			* @s: substring to be scanned
122			* @result: resulting integer on success
123			* @base: base to use when converting string
124			*
125			* Description: Given a &substring_t and a base, attempts to parse the substring
126			* as a number in that base. On success, sets @result to the integer represented
127			* by the string and returns 0. Returns either -ENOMEM or -EINVAL on failure.
128			*/
129			static int match_number(substring_t s, int result, int base)
130			{
131			char *endp;
132			char *buf;
133			int ret;
134
135			buf = kmalloc(s->to - s->from + 1, GFP_KERNEL);
136			if (!buf)
137			return -ENOMEM;
138			memcpy(buf, s->from, s->to - s->from);
139			buf[s->to - s->from] = '\0';
140			*result = simple_strtol(buf, &endp, base);
141			ret = 0;
142			if (endp == buf)
143			ret = -EINVAL;
144			kfree(buf);
145			return ret;
146			}
147
148			/**
149			* match_int: - scan a decimal representation of an integer from a substring_t
150			* @s: substring_t to be scanned
151			* @result: resulting integer on success
152			*
153			* Description: Attempts to parse the &substring_t @s as a decimal integer. On
154			* success, sets @result to the integer represented by the string and returns 0.
155			* Returns either -ENOMEM or -EINVAL on failure.
156			*/
157			int match_int(substring_t s, int result)
158			{
159			return match_number(s, result, 0);
160			}
161
162			/**
163			* match_octal: - scan an octal representation of an integer from a substring_t
164			* @s: substring_t to be scanned
165			* @result: resulting integer on success
166			*
167			* Description: Attempts to parse the &substring_t @s as an octal integer. On
168			* success, sets @result to the integer represented by the string and returns
169			* 0. Returns either -ENOMEM or -EINVAL on failure.
170			*/
171			int match_octal(substring_t s, int result)
172			{
173			return match_number(s, result, 8);
174			}
175
176			/**
177			* match_hex: - scan a hex representation of an integer from a substring_t
178			* @s: substring_t to be scanned
179			* @result: resulting integer on success
180			*
181			* Description: Attempts to parse the &substring_t @s as a hexadecimal integer.
182			* On success, sets @result to the integer represented by the string and
183			* returns 0. Returns either -ENOMEM or -EINVAL on failure.
184			*/
185			int match_hex(substring_t s, int result)
186			{
187			return match_number(s, result, 16);
188			}
189
190			/**
191			* match_strcpy: - copies the characters from a substring_t to a string
192			* @to: string to copy characters to.
193			* @s: &substring_t to copy
194			*
195			* Description: Copies the set of characters represented by the given
196			* &substring_t @s to the c-style string @to. Caller guarantees that @to is
197			* large enough to hold the characters of @s.
198			*/
199			void match_strcpy(char to, substring_t s)
200			{
201			memcpy(to, s->from, s->to - s->from);
202			to[s->to - s->from] = '\0';
203			}
204
205			/**
206			* match_strdup: - allocate a new string with the contents of a substring_t
207			* @s: &substring_t to copy
208			*
209			* Description: Allocates and returns a string filled with the contents of
210			* the &substring_t @s. The caller is responsible for freeing the returned
211			* string with kfree().
212			*/
213			char match_strdup(substring_t s)
214			{
215			char *p = kmalloc(s->to - s->from + 1, GFP_KERNEL);
216			if (p)
217			match_strcpy(p, s);
218			return p;
219			}
220