misc.c

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 *   Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org>
  4 *   Copyright (C) 2018 Samsung Electronics Co., Ltd.
  5 */
  6
  7#include <linux/kernel.h>
  8#include <linux/xattr.h>
  9#include <linux/fs.h>
 10#include <linux/unicode.h>
 11
 12#include "misc.h"
 13#include "smb_common.h"
 14#include "connection.h"
 15#include "vfs.h"
 16
 17#include "mgmt/share_config.h"
 18
 19/**
 20 * match_pattern() - compare a string with a pattern which might include
 21 * wildcard '*' and '?'
 22 * TODO : implement consideration about DOS_DOT, DOS_QM and DOS_STAR
 23 *
 24 * @str:	string to compare with a pattern
 25 * @len:	string length
 26 * @pattern:	pattern string which might include wildcard '*' and '?'
 27 *
 28 * Return:	0 if pattern matched with the string, otherwise non zero value
 29 */
 30int match_pattern(const char *str, size_t len, const char *pattern)
 31{
 32	const char *s = str;
 33	const char *p = pattern;
 34	bool star = false;
 35
 36	while (*s && len) {
 37		switch (*p) {
 38		case '?':
 39			s++;
 40			len--;
 41			p++;
 42			break;
 43		case '*':
 44			star = true;
 45			str = s;
 46			if (!*++p)
 47				return true;
 48			pattern = p;
 49			break;
 50		default:
 51			if (tolower(*s) == tolower(*p)) {
 52				s++;
 53				len--;
 54				p++;
 55			} else {
 56				if (!star)
 57					return false;
 58				str++;
 59				s = str;
 60				p = pattern;
 61			}
 62			break;
 63		}
 64	}
 65
 66	if (*p == '*')
 67		++p;
 68	return !*p;
 69}
 70
 71/*
 72 * is_char_allowed() - check for valid character
 73 * @ch:		input character to be checked
 74 *
 75 * Return:	1 if char is allowed, otherwise 0
 76 */
 77static inline int is_char_allowed(char ch)
 78{
 79	/* check for control chars, wildcards etc. */
 80	if (!(ch & 0x80) &&
 81	    (ch <= 0x1f ||
 82	     ch == '?' || ch == '"' || ch == '<' ||
 83	     ch == '>' || ch == '|' || ch == '*'))
 84		return 0;
 85
 86	return 1;
 87}
 88
 89int ksmbd_validate_filename(char *filename)
 90{
 91	while (*filename) {
 92		char c = *filename;
 93
 94		filename++;
 95		if (!is_char_allowed(c)) {
 96			ksmbd_debug(VFS, "File name validation failed: 0x%x\n", c);
 97			return -ENOENT;
 98		}
 99	}
100
101	return 0;
102}
103
104static int ksmbd_validate_stream_name(char *stream_name)
105{
106	while (*stream_name) {
107		char c = *stream_name;
108
109		stream_name++;
110		if (c == '/' || c == ':' || c == '\\') {
111			pr_err("Stream name validation failed: %c\n", c);
112			return -ENOENT;
113		}
114	}
115
116	return 0;
117}
118
119int parse_stream_name(char *filename, char **stream_name, int *s_type)
120{
121	char *stream_type;
122	char *s_name;
123	int rc = 0;
124
125	s_name = filename;
126	filename = strsep(&s_name, ":");
127	ksmbd_debug(SMB, "filename : %s, streams : %s\n", filename, s_name);
128	if (strchr(s_name, ':')) {
129		stream_type = s_name;
130		s_name = strsep(&stream_type, ":");
131
132		rc = ksmbd_validate_stream_name(s_name);
133		if (rc < 0) {
134			rc = -ENOENT;
135			goto out;
136		}
137
138		ksmbd_debug(SMB, "stream name : %s, stream type : %s\n", s_name,
139			    stream_type);
140		if (!strncasecmp("$data", stream_type, 5))
141			*s_type = DATA_STREAM;
142		else if (!strncasecmp("$index_allocation", stream_type, 17))
143			*s_type = DIR_STREAM;
144		else
145			rc = -ENOENT;
146	}
147
148	*stream_name = s_name;
149out:
150	return rc;
151}
152
153/**
154 * convert_to_nt_pathname() - extract and return windows path string
155 *      whose share directory prefix was removed from file path
156 * @share: ksmbd_share_config pointer
157 * @path: path to report
158 *
159 * Return : windows path string or error
160 */
161
162char *convert_to_nt_pathname(struct ksmbd_share_config *share,
163			     const struct path *path)
164{
165	char *pathname, *ab_pathname, *nt_pathname;
166	int share_path_len = share->path_sz;
167	size_t ab_pathname_len;
168	int prefix;
169
170	pathname = kmalloc(PATH_MAX, KSMBD_DEFAULT_GFP);
171	if (!pathname)
172		return ERR_PTR(-EACCES);
173
174	ab_pathname = d_path(path, pathname, PATH_MAX);
175	if (IS_ERR(ab_pathname)) {
176		nt_pathname = ERR_PTR(-EACCES);
177		goto free_pathname;
178	}
179
180	if (strncmp(ab_pathname, share->path, share_path_len)) {
181		nt_pathname = ERR_PTR(-EACCES);
182		goto free_pathname;
183	}
184
185	ab_pathname_len = strlen(&ab_pathname[share_path_len]);
186	prefix = ab_pathname[share_path_len] == '\0' ? 1 : 0;
187	nt_pathname = kmalloc(prefix + ab_pathname_len + 1, KSMBD_DEFAULT_GFP);
188	if (!nt_pathname) {
189		nt_pathname = ERR_PTR(-ENOMEM);
190		goto free_pathname;
191	}
192
193	if (prefix)
194		*nt_pathname = '/';
195	memcpy(nt_pathname + prefix, &ab_pathname[share_path_len],
196	       ab_pathname_len + 1);
197
198	ksmbd_conv_path_to_windows(nt_pathname);
199
200free_pathname:
201	kfree(pathname);
202	return nt_pathname;
203}
204
205int get_nlink(struct kstat *st)
206{
207	int nlink;
208
209	nlink = st->nlink;
210	if (S_ISDIR(st->mode))
211		nlink--;
212
213	return nlink;
214}
215
216void ksmbd_conv_path_to_unix(char *path)
217{
218	strreplace(path, '\\', '/');
219}
220
221void ksmbd_strip_last_slash(char *path)
222{
223	int len = strlen(path);
224
225	while (len && path[len - 1] == '/') {
226		path[len - 1] = '\0';
227		len--;
228	}
229}
230
231void ksmbd_conv_path_to_windows(char *path)
232{
233	strreplace(path, '/', '\\');
234}
235
236char *ksmbd_casefold_sharename(struct unicode_map *um, const char *name)
237{
238	char *cf_name;
239	int cf_len;
240
241	cf_name = kzalloc(KSMBD_REQ_MAX_SHARE_NAME, KSMBD_DEFAULT_GFP);
242	if (!cf_name)
243		return ERR_PTR(-ENOMEM);
244
245	if (IS_ENABLED(CONFIG_UNICODE) && um) {
246		const struct qstr q_name = {.name = name, .len = strlen(name)};
247
248		cf_len = utf8_casefold(um, &q_name, cf_name,
249				       KSMBD_REQ_MAX_SHARE_NAME);
250		if (cf_len < 0)
251			goto out_ascii;
252
253		return cf_name;
254	}
255
256out_ascii:
257	cf_len = strscpy(cf_name, name, KSMBD_REQ_MAX_SHARE_NAME);
258	if (cf_len < 0) {
259		kfree(cf_name);
260		return ERR_PTR(-E2BIG);
261	}
262
263	for (; *cf_name; ++cf_name)
264		*cf_name = isascii(*cf_name) ? tolower(*cf_name) : *cf_name;
265	return cf_name - cf_len;
266}
267
268/**
269 * ksmbd_extract_sharename() - get share name from tree connect request
270 * @um: pointer to a unicode_map structure for character encoding handling
271 * @treename:	buffer containing tree name and share name
272 *
273 * Return:      share name on success, otherwise error
274 */
275char *ksmbd_extract_sharename(struct unicode_map *um, const char *treename)
276{
277	const char *name = treename, *pos = strrchr(name, '\\');
278
279	if (pos)
280		name = (pos + 1);
281
282	/* caller has to free the memory */
283	return ksmbd_casefold_sharename(um, name);
284}
285
286/**
287 * convert_to_unix_name() - convert windows name to unix format
288 * @share:	ksmbd_share_config pointer
289 * @name:	file name that is relative to share
290 *
291 * Return:	converted name on success, otherwise NULL
292 */
293char *convert_to_unix_name(struct ksmbd_share_config *share, const char *name)
294{
295	int no_slash = 0, name_len, path_len;
296	char *new_name;
297
298	if (name[0] == '/')
299		name++;
300
301	path_len = share->path_sz;
302	name_len = strlen(name);
303	new_name = kmalloc(path_len + name_len + 2, KSMBD_DEFAULT_GFP);
304	if (!new_name)
305		return new_name;
306
307	memcpy(new_name, share->path, path_len);
308	if (new_name[path_len - 1] != '/') {
309		new_name[path_len] = '/';
310		no_slash = 1;
311	}
312
313	memcpy(new_name + path_len + no_slash, name, name_len);
314	path_len += name_len + no_slash;
315	new_name[path_len] = 0x00;
316	return new_name;
317}
318
319char *ksmbd_convert_dir_info_name(struct ksmbd_dir_info *d_info,
320				  const struct nls_table *local_nls,
321				  int *conv_len)
322{
323	char *conv;
324	int  sz = min(4 * d_info->name_len, PATH_MAX);
325
326	if (!sz)
327		return NULL;
328
329	conv = kmalloc(sz, KSMBD_DEFAULT_GFP);
330	if (!conv)
331		return NULL;
332
333	/* XXX */
334	*conv_len = smbConvertToUTF16((__le16 *)conv, d_info->name,
335				      d_info->name_len, local_nls, 0);
336	*conv_len *= 2;
337
338	/* We allocate buffer twice bigger than needed. */
339	conv[*conv_len] = 0x00;
340	conv[*conv_len + 1] = 0x00;
341	return conv;
342}
343
344/*
345 * Convert the NT UTC (based 1601-01-01, in hundred nanosecond units)
346 * into Unix UTC (based 1970-01-01, in seconds).
347 */
348struct timespec64 ksmbd_NTtimeToUnix(__le64 ntutc)
349{
350	struct timespec64 ts;
351
352	/* Subtract the NTFS time offset, then convert to 1s intervals. */
353	s64 t = le64_to_cpu(ntutc) - NTFS_TIME_OFFSET;
354	u64 abs_t;
355
356	/*
357	 * Unfortunately can not use normal 64 bit division on 32 bit arch, but
358	 * the alternative, do_div, does not work with negative numbers so have
359	 * to special case them
360	 */
361	if (t < 0) {
362		abs_t = -t;
363		ts.tv_nsec = do_div(abs_t, 10000000) * 100;
364		ts.tv_nsec = -ts.tv_nsec;
365		ts.tv_sec = -abs_t;
366	} else {
367		abs_t = t;
368		ts.tv_nsec = do_div(abs_t, 10000000) * 100;
369		ts.tv_sec = abs_t;
370	}
371
372	return ts;
373}
374
375/* Convert the Unix UTC into NT UTC. */
376inline u64 ksmbd_UnixTimeToNT(struct timespec64 t)
377{
378	/* Convert to 100ns intervals and then add the NTFS time offset. */
379	return (u64)t.tv_sec * 10000000 + t.tv_nsec / 100 + NTFS_TIME_OFFSET;
380}
381
382inline long long ksmbd_systime(void)
383{
384	struct timespec64	ts;
385
386	ktime_get_real_ts64(&ts);
387	return ksmbd_UnixTimeToNT(ts);
388}