xref: /openbmc/linux/fs/smb/server/smb_common.c (revision 9134211f) 
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *   Copyright (C) 2018 Samsung Electronics Co., Ltd.
4  *   Copyright (C) 2018 Namjae Jeon <linkinjeon@kernel.org>
5  */
6 
7 #include <linux/user_namespace.h>
8 
9 #include "smb_common.h"
10 #include "server.h"
11 #include "misc.h"
12 #include "smbstatus.h"
13 #include "connection.h"
14 #include "ksmbd_work.h"
15 #include "mgmt/user_session.h"
16 #include "mgmt/user_config.h"
17 #include "mgmt/tree_connect.h"
18 #include "mgmt/share_config.h"
19 
20 /*for shortname implementation */
21 static const char basechars[43] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_-!@#$%";
22 #define MANGLE_BASE (sizeof(basechars) / sizeof(char) - 1)
23 #define MAGIC_CHAR '~'
24 #define PERIOD '.'
25 #define mangle(V) ((char)(basechars[(V) % MANGLE_BASE]))
26 
27 struct smb_protocol {
28 	int		index;
29 	char		*name;
30 	char		*prot;
31 	__u16		prot_id;
32 };
33 
34 static struct smb_protocol smb1_protos[] = {
35 	{
36 		SMB21_PROT,
37 		"\2SMB 2.1",
38 		"SMB2_10",
39 		SMB21_PROT_ID
40 	},
41 	{
42 		SMB2X_PROT,
43 		"\2SMB 2.???",
44 		"SMB2_22",
45 		SMB2X_PROT_ID
46 	},
47 };
48 
49 static struct smb_protocol smb2_protos[] = {
50 	{
51 		SMB21_PROT,
52 		"\2SMB 2.1",
53 		"SMB2_10",
54 		SMB21_PROT_ID
55 	},
56 	{
57 		SMB30_PROT,
58 		"\2SMB 3.0",
59 		"SMB3_00",
60 		SMB30_PROT_ID
61 	},
62 	{
63 		SMB302_PROT,
64 		"\2SMB 3.02",
65 		"SMB3_02",
66 		SMB302_PROT_ID
67 	},
68 	{
69 		SMB311_PROT,
70 		"\2SMB 3.1.1",
71 		"SMB3_11",
72 		SMB311_PROT_ID
73 	},
74 };
75 
76 unsigned int ksmbd_server_side_copy_max_chunk_count(void)
77 {
78 	return 256;
79 }
80 
81 unsigned int ksmbd_server_side_copy_max_chunk_size(void)
82 {
83 	return (2U << 30) - 1;
84 }
85 
86 unsigned int ksmbd_server_side_copy_max_total_size(void)
87 {
88 	return (2U << 30) - 1;
89 }
90 
91 inline int ksmbd_min_protocol(void)
92 {
93 	return SMB21_PROT;
94 }
95 
96 inline int ksmbd_max_protocol(void)
97 {
98 	return SMB311_PROT;
99 }
100 
101 int ksmbd_lookup_protocol_idx(char *str)
102 {
103 	int offt = ARRAY_SIZE(smb1_protos) - 1;
104 	int len = strlen(str);
105 
106 	while (offt >= 0) {
107 		if (!strncmp(str, smb1_protos[offt].prot, len)) {
108 			ksmbd_debug(SMB, "selected %s dialect idx = %d\n",
109 				    smb1_protos[offt].prot, offt);
110 			return smb1_protos[offt].index;
111 		}
112 		offt--;
113 	}
114 
115 	offt = ARRAY_SIZE(smb2_protos) - 1;
116 	while (offt >= 0) {
117 		if (!strncmp(str, smb2_protos[offt].prot, len)) {
118 			ksmbd_debug(SMB, "selected %s dialect idx = %d\n",
119 				    smb2_protos[offt].prot, offt);
120 			return smb2_protos[offt].index;
121 		}
122 		offt--;
123 	}
124 	return -1;
125 }
126 
127 /**
128  * ksmbd_verify_smb_message() - check for valid smb2 request header
129  * @work:	smb work
130  *
131  * check for valid smb signature and packet direction(request/response)
132  *
133  * Return:      0 on success, otherwise -EINVAL
134  */
135 int ksmbd_verify_smb_message(struct ksmbd_work *work)
136 {
137 	struct smb2_hdr *smb2_hdr = ksmbd_req_buf_next(work);
138 	struct smb_hdr *hdr;
139 
140 	if (smb2_hdr->ProtocolId == SMB2_PROTO_NUMBER)
141 		return ksmbd_smb2_check_message(work);
142 
143 	hdr = work->request_buf;
144 	if (*(__le32 *)hdr->Protocol == SMB1_PROTO_NUMBER &&
145 	    hdr->Command == SMB_COM_NEGOTIATE) {
146 		work->conn->outstanding_credits++;
147 		return 0;
148 	}
149 
150 	return -EINVAL;
151 }
152 
153 /**
154  * ksmbd_smb_request() - check for valid smb request type
155  * @conn:	connection instance
156  *
157  * Return:      true on success, otherwise false
158  */
159 bool ksmbd_smb_request(struct ksmbd_conn *conn)
160 {
161 	__le32 *proto = (__le32 *)smb2_get_msg(conn->request_buf);
162 
163 	if (*proto == SMB2_COMPRESSION_TRANSFORM_ID) {
164 		pr_err_ratelimited("smb2 compression not support yet");
165 		return false;
166 	}
167 
168 	if (*proto != SMB1_PROTO_NUMBER &&
169 	    *proto != SMB2_PROTO_NUMBER &&
170 	    *proto != SMB2_TRANSFORM_PROTO_NUM)
171 		return false;
172 
173 	return true;
174 }
175 
176 static bool supported_protocol(int idx)
177 {
178 	if (idx == SMB2X_PROT &&
179 	    (server_conf.min_protocol >= SMB21_PROT ||
180 	     server_conf.max_protocol <= SMB311_PROT))
181 		return true;
182 
183 	return (server_conf.min_protocol <= idx &&
184 		idx <= server_conf.max_protocol);
185 }
186 
187 static char *next_dialect(char *dialect, int *next_off, int bcount)
188 {
189 	dialect = dialect + *next_off;
190 	*next_off = strnlen(dialect, bcount);
191 	if (dialect[*next_off] != '\0')
192 		return NULL;
193 	return dialect;
194 }
195 
196 static int ksmbd_lookup_dialect_by_name(char *cli_dialects, __le16 byte_count)
197 {
198 	int i, seq_num, bcount, next;
199 	char *dialect;
200 
201 	for (i = ARRAY_SIZE(smb1_protos) - 1; i >= 0; i--) {
202 		seq_num = 0;
203 		next = 0;
204 		dialect = cli_dialects;
205 		bcount = le16_to_cpu(byte_count);
206 		do {
207 			dialect = next_dialect(dialect, &next, bcount);
208 			if (!dialect)
209 				break;
210 			ksmbd_debug(SMB, "client requested dialect %s\n",
211 				    dialect);
212 			if (!strcmp(dialect, smb1_protos[i].name)) {
213 				if (supported_protocol(smb1_protos[i].index)) {
214 					ksmbd_debug(SMB,
215 						    "selected %s dialect\n",
216 						    smb1_protos[i].name);
217 					if (smb1_protos[i].index == SMB1_PROT)
218 						return seq_num;
219 					return smb1_protos[i].prot_id;
220 				}
221 			}
222 			seq_num++;
223 			bcount -= (++next);
224 		} while (bcount > 0);
225 	}
226 
227 	return BAD_PROT_ID;
228 }
229 
230 int ksmbd_lookup_dialect_by_id(__le16 *cli_dialects, __le16 dialects_count)
231 {
232 	int i;
233 	int count;
234 
235 	for (i = ARRAY_SIZE(smb2_protos) - 1; i >= 0; i--) {
236 		count = le16_to_cpu(dialects_count);
237 		while (--count >= 0) {
238 			ksmbd_debug(SMB, "client requested dialect 0x%x\n",
239 				    le16_to_cpu(cli_dialects[count]));
240 			if (le16_to_cpu(cli_dialects[count]) !=
241 					smb2_protos[i].prot_id)
242 				continue;
243 
244 			if (supported_protocol(smb2_protos[i].index)) {
245 				ksmbd_debug(SMB, "selected %s dialect\n",
246 					    smb2_protos[i].name);
247 				return smb2_protos[i].prot_id;
248 			}
249 		}
250 	}
251 
252 	return BAD_PROT_ID;
253 }
254 
255 static int ksmbd_negotiate_smb_dialect(void *buf)
256 {
257 	int smb_buf_length = get_rfc1002_len(buf);
258 	__le32 proto = ((struct smb2_hdr *)smb2_get_msg(buf))->ProtocolId;
259 
260 	if (proto == SMB2_PROTO_NUMBER) {
261 		struct smb2_negotiate_req *req;
262 		int smb2_neg_size =
263 			offsetof(struct smb2_negotiate_req, Dialects);
264 
265 		req = (struct smb2_negotiate_req *)smb2_get_msg(buf);
266 		if (smb2_neg_size > smb_buf_length)
267 			goto err_out;
268 
269 		if (struct_size(req, Dialects, le16_to_cpu(req->DialectCount)) >
270 		    smb_buf_length)
271 			goto err_out;
272 
273 		return ksmbd_lookup_dialect_by_id(req->Dialects,
274 						  req->DialectCount);
275 	}
276 
277 	proto = *(__le32 *)((struct smb_hdr *)buf)->Protocol;
278 	if (proto == SMB1_PROTO_NUMBER) {
279 		struct smb_negotiate_req *req;
280 
281 		req = (struct smb_negotiate_req *)buf;
282 		if (le16_to_cpu(req->ByteCount) < 2)
283 			goto err_out;
284 
285 		if (offsetof(struct smb_negotiate_req, DialectsArray) - 4 +
286 			le16_to_cpu(req->ByteCount) > smb_buf_length) {
287 			goto err_out;
288 		}
289 
290 		return ksmbd_lookup_dialect_by_name(req->DialectsArray,
291 						    req->ByteCount);
292 	}
293 
294 err_out:
295 	return BAD_PROT_ID;
296 }
297 
298 #define SMB_COM_NEGOTIATE_EX	0x0
299 
300 /**
301  * get_smb1_cmd_val() - get smb command value from smb header
302  * @work:	smb work containing smb header
303  *
304  * Return:      smb command value
305  */
306 static u16 get_smb1_cmd_val(struct ksmbd_work *work)
307 {
308 	return SMB_COM_NEGOTIATE_EX;
309 }
310 
311 /**
312  * init_smb1_rsp_hdr() - initialize smb negotiate response header
313  * @work:	smb work containing smb request
314  *
315  * Return:      0 on success, otherwise -EINVAL
316  */
317 static int init_smb1_rsp_hdr(struct ksmbd_work *work)
318 {
319 	struct smb_hdr *rsp_hdr = (struct smb_hdr *)work->response_buf;
320 	struct smb_hdr *rcv_hdr = (struct smb_hdr *)work->request_buf;
321 
322 	/*
323 	 * Remove 4 byte direct TCP header.
324 	 */
325 	*(__be32 *)work->response_buf =
326 		cpu_to_be32(sizeof(struct smb_hdr) - 4);
327 
328 	rsp_hdr->Command = SMB_COM_NEGOTIATE;
329 	*(__le32 *)rsp_hdr->Protocol = SMB1_PROTO_NUMBER;
330 	rsp_hdr->Flags = SMBFLG_RESPONSE;
331 	rsp_hdr->Flags2 = SMBFLG2_UNICODE | SMBFLG2_ERR_STATUS |
332 		SMBFLG2_EXT_SEC | SMBFLG2_IS_LONG_NAME;
333 	rsp_hdr->Pid = rcv_hdr->Pid;
334 	rsp_hdr->Mid = rcv_hdr->Mid;
335 	return 0;
336 }
337 
338 /**
339  * smb1_check_user_session() - check for valid session for a user
340  * @work:	smb work containing smb request buffer
341  *
342  * Return:      0 on success, otherwise error
343  */
344 static int smb1_check_user_session(struct ksmbd_work *work)
345 {
346 	unsigned int cmd = work->conn->ops->get_cmd_val(work);
347 
348 	if (cmd == SMB_COM_NEGOTIATE_EX)
349 		return 0;
350 
351 	return -EINVAL;
352 }
353 
354 /**
355  * smb1_allocate_rsp_buf() - allocate response buffer for a command
356  * @work:	smb work containing smb request
357  *
358  * Return:      0 on success, otherwise -ENOMEM
359  */
360 static int smb1_allocate_rsp_buf(struct ksmbd_work *work)
361 {
362 	work->response_buf = kzalloc(MAX_CIFS_SMALL_BUFFER_SIZE,
363 			GFP_KERNEL);
364 	work->response_sz = MAX_CIFS_SMALL_BUFFER_SIZE;
365 
366 	if (!work->response_buf) {
367 		pr_err("Failed to allocate %u bytes buffer\n",
368 				MAX_CIFS_SMALL_BUFFER_SIZE);
369 		return -ENOMEM;
370 	}
371 
372 	return 0;
373 }
374 
375 static struct smb_version_ops smb1_server_ops = {
376 	.get_cmd_val = get_smb1_cmd_val,
377 	.init_rsp_hdr = init_smb1_rsp_hdr,
378 	.allocate_rsp_buf = smb1_allocate_rsp_buf,
379 	.check_user_session = smb1_check_user_session,
380 };
381 
382 static int smb1_negotiate(struct ksmbd_work *work)
383 {
384 	return ksmbd_smb_negotiate_common(work, SMB_COM_NEGOTIATE);
385 }
386 
387 static struct smb_version_cmds smb1_server_cmds[1] = {
388 	[SMB_COM_NEGOTIATE_EX]	= { .proc = smb1_negotiate, },
389 };
390 
391 static void init_smb1_server(struct ksmbd_conn *conn)
392 {
393 	conn->ops = &smb1_server_ops;
394 	conn->cmds = smb1_server_cmds;
395 	conn->max_cmds = ARRAY_SIZE(smb1_server_cmds);
396 }
397 
398 void ksmbd_init_smb_server(struct ksmbd_work *work)
399 {
400 	struct ksmbd_conn *conn = work->conn;
401 	__le32 proto;
402 
403 	if (conn->need_neg == false)
404 		return;
405 
406 	proto = *(__le32 *)((struct smb_hdr *)work->request_buf)->Protocol;
407 	if (proto == SMB1_PROTO_NUMBER)
408 		init_smb1_server(conn);
409 	else
410 		init_smb3_11_server(conn);
411 }
412 
413 int ksmbd_populate_dot_dotdot_entries(struct ksmbd_work *work, int info_level,
414 				      struct ksmbd_file *dir,
415 				      struct ksmbd_dir_info *d_info,
416 				      char *search_pattern,
417 				      int (*fn)(struct ksmbd_conn *, int,
418 						struct ksmbd_dir_info *,
419 						struct ksmbd_kstat *))
420 {
421 	int i, rc = 0;
422 	struct ksmbd_conn *conn = work->conn;
423 	struct mnt_idmap *idmap = file_mnt_idmap(dir->filp);
424 
425 	for (i = 0; i < 2; i++) {
426 		struct kstat kstat;
427 		struct ksmbd_kstat ksmbd_kstat;
428 		struct dentry *dentry;
429 
430 		if (!dir->dot_dotdot[i]) { /* fill dot entry info */
431 			if (i == 0) {
432 				d_info->name = ".";
433 				d_info->name_len = 1;
434 				dentry = dir->filp->f_path.dentry;
435 			} else {
436 				d_info->name = "..";
437 				d_info->name_len = 2;
438 				dentry = dir->filp->f_path.dentry->d_parent;
439 			}
440 
441 			if (!match_pattern(d_info->name, d_info->name_len,
442 					   search_pattern)) {
443 				dir->dot_dotdot[i] = 1;
444 				continue;
445 			}
446 
447 			ksmbd_kstat.kstat = &kstat;
448 			ksmbd_vfs_fill_dentry_attrs(work,
449 						    idmap,
450 						    dentry,
451 						    &ksmbd_kstat);
452 			rc = fn(conn, info_level, d_info, &ksmbd_kstat);
453 			if (rc)
454 				break;
455 			if (d_info->out_buf_len <= 0)
456 				break;
457 
458 			dir->dot_dotdot[i] = 1;
459 			if (d_info->flags & SMB2_RETURN_SINGLE_ENTRY) {
460 				d_info->out_buf_len = 0;
461 				break;
462 			}
463 		}
464 	}
465 
466 	return rc;
467 }
468 
469 /**
470  * ksmbd_extract_shortname() - get shortname from long filename
471  * @conn:	connection instance
472  * @longname:	source long filename
473  * @shortname:	destination short filename
474  *
475  * Return:	shortname length or 0 when source long name is '.' or '..'
476  * TODO: Though this function comforms the restriction of 8.3 Filename spec,
477  * but the result is different with Windows 7's one. need to check.
478  */
479 int ksmbd_extract_shortname(struct ksmbd_conn *conn, const char *longname,
480 			    char *shortname)
481 {
482 	const char *p;
483 	char base[9], extension[4];
484 	char out[13] = {0};
485 	int baselen = 0;
486 	int extlen = 0, len = 0;
487 	unsigned int csum = 0;
488 	const unsigned char *ptr;
489 	bool dot_present = true;
490 
491 	p = longname;
492 	if ((*p == '.') || (!(strcmp(p, "..")))) {
493 		/*no mangling required */
494 		return 0;
495 	}
496 
497 	p = strrchr(longname, '.');
498 	if (p == longname) { /*name starts with a dot*/
499 		strscpy(extension, "___", strlen("___"));
500 	} else {
501 		if (p) {
502 			p++;
503 			while (*p && extlen < 3) {
504 				if (*p != '.')
505 					extension[extlen++] = toupper(*p);
506 				p++;
507 			}
508 			extension[extlen] = '\0';
509 		} else {
510 			dot_present = false;
511 		}
512 	}
513 
514 	p = longname;
515 	if (*p == '.') {
516 		p++;
517 		longname++;
518 	}
519 	while (*p && (baselen < 5)) {
520 		if (*p != '.')
521 			base[baselen++] = toupper(*p);
522 		p++;
523 	}
524 
525 	base[baselen] = MAGIC_CHAR;
526 	memcpy(out, base, baselen + 1);
527 
528 	ptr = longname;
529 	len = strlen(longname);
530 	for (; len > 0; len--, ptr++)
531 		csum += *ptr;
532 
533 	csum = csum % (MANGLE_BASE * MANGLE_BASE);
534 	out[baselen + 1] = mangle(csum / MANGLE_BASE);
535 	out[baselen + 2] = mangle(csum);
536 	out[baselen + 3] = PERIOD;
537 
538 	if (dot_present)
539 		memcpy(out + baselen + 4, extension, 4);
540 	else
541 		out[baselen + 4] = '\0';
542 	smbConvertToUTF16((__le16 *)shortname, out, PATH_MAX,
543 			  conn->local_nls, 0);
544 	len = strlen(out) * 2;
545 	return len;
546 }
547 
548 static int __smb2_negotiate(struct ksmbd_conn *conn)
549 {
550 	return (conn->dialect >= SMB20_PROT_ID &&
551 		conn->dialect <= SMB311_PROT_ID);
552 }
553 
554 static int smb_handle_negotiate(struct ksmbd_work *work)
555 {
556 	struct smb_negotiate_rsp *neg_rsp = work->response_buf;
557 
558 	ksmbd_debug(SMB, "Unsupported SMB1 protocol\n");
559 
560 	/* Add 2 byte bcc and 2 byte DialectIndex. */
561 	inc_rfc1001_len(work->response_buf, 4);
562 	neg_rsp->hdr.Status.CifsError = STATUS_SUCCESS;
563 
564 	neg_rsp->hdr.WordCount = 1;
565 	neg_rsp->DialectIndex = cpu_to_le16(work->conn->dialect);
566 	neg_rsp->ByteCount = 0;
567 	return 0;
568 }
569 
570 int ksmbd_smb_negotiate_common(struct ksmbd_work *work, unsigned int command)
571 {
572 	struct ksmbd_conn *conn = work->conn;
573 	int ret;
574 
575 	conn->dialect =
576 		ksmbd_negotiate_smb_dialect(work->request_buf);
577 	ksmbd_debug(SMB, "conn->dialect 0x%x\n", conn->dialect);
578 
579 	if (command == SMB2_NEGOTIATE_HE) {
580 		ret = smb2_handle_negotiate(work);
581 		return ret;
582 	}
583 
584 	if (command == SMB_COM_NEGOTIATE) {
585 		if (__smb2_negotiate(conn)) {
586 			init_smb3_11_server(conn);
587 			init_smb2_neg_rsp(work);
588 			ksmbd_debug(SMB, "Upgrade to SMB2 negotiation\n");
589 			return 0;
590 		}
591 		return smb_handle_negotiate(work);
592 	}
593 
594 	pr_err("Unknown SMB negotiation command: %u\n", command);
595 	return -EINVAL;
596 }
597 
598 enum SHARED_MODE_ERRORS {
599 	SHARE_DELETE_ERROR,
600 	SHARE_READ_ERROR,
601 	SHARE_WRITE_ERROR,
602 	FILE_READ_ERROR,
603 	FILE_WRITE_ERROR,
604 	FILE_DELETE_ERROR,
605 };
606 
607 static const char * const shared_mode_errors[] = {
608 	"Current access mode does not permit SHARE_DELETE",
609 	"Current access mode does not permit SHARE_READ",
610 	"Current access mode does not permit SHARE_WRITE",
611 	"Desired access mode does not permit FILE_READ",
612 	"Desired access mode does not permit FILE_WRITE",
613 	"Desired access mode does not permit FILE_DELETE",
614 };
615 
616 static void smb_shared_mode_error(int error, struct ksmbd_file *prev_fp,
617 				  struct ksmbd_file *curr_fp)
618 {
619 	ksmbd_debug(SMB, "%s\n", shared_mode_errors[error]);
620 	ksmbd_debug(SMB, "Current mode: 0x%x Desired mode: 0x%x\n",
621 		    prev_fp->saccess, curr_fp->daccess);
622 }
623 
624 int ksmbd_smb_check_shared_mode(struct file *filp, struct ksmbd_file *curr_fp)
625 {
626 	int rc = 0;
627 	struct ksmbd_file *prev_fp;
628 
629 	/*
630 	 * Lookup fp in master fp list, and check desired access and
631 	 * shared mode between previous open and current open.
632 	 */
633 	read_lock(&curr_fp->f_ci->m_lock);
634 	list_for_each_entry(prev_fp, &curr_fp->f_ci->m_fp_list, node) {
635 		if (file_inode(filp) != file_inode(prev_fp->filp))
636 			continue;
637 
638 		if (filp == prev_fp->filp)
639 			continue;
640 
641 		if (ksmbd_stream_fd(prev_fp) && ksmbd_stream_fd(curr_fp))
642 			if (strcmp(prev_fp->stream.name, curr_fp->stream.name))
643 				continue;
644 
645 		if (prev_fp->attrib_only != curr_fp->attrib_only)
646 			continue;
647 
648 		if (!(prev_fp->saccess & FILE_SHARE_DELETE_LE) &&
649 		    curr_fp->daccess & FILE_DELETE_LE) {
650 			smb_shared_mode_error(SHARE_DELETE_ERROR,
651 					      prev_fp,
652 					      curr_fp);
653 			rc = -EPERM;
654 			break;
655 		}
656 
657 		/*
658 		 * Only check FILE_SHARE_DELETE if stream opened and
659 		 * normal file opened.
660 		 */
661 		if (ksmbd_stream_fd(prev_fp) && !ksmbd_stream_fd(curr_fp))
662 			continue;
663 
664 		if (!(prev_fp->saccess & FILE_SHARE_READ_LE) &&
665 		    curr_fp->daccess & (FILE_EXECUTE_LE | FILE_READ_DATA_LE)) {
666 			smb_shared_mode_error(SHARE_READ_ERROR,
667 					      prev_fp,
668 					      curr_fp);
669 			rc = -EPERM;
670 			break;
671 		}
672 
673 		if (!(prev_fp->saccess & FILE_SHARE_WRITE_LE) &&
674 		    curr_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE)) {
675 			smb_shared_mode_error(SHARE_WRITE_ERROR,
676 					      prev_fp,
677 					      curr_fp);
678 			rc = -EPERM;
679 			break;
680 		}
681 
682 		if (prev_fp->daccess & (FILE_EXECUTE_LE | FILE_READ_DATA_LE) &&
683 		    !(curr_fp->saccess & FILE_SHARE_READ_LE)) {
684 			smb_shared_mode_error(FILE_READ_ERROR,
685 					      prev_fp,
686 					      curr_fp);
687 			rc = -EPERM;
688 			break;
689 		}
690 
691 		if (prev_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE) &&
692 		    !(curr_fp->saccess & FILE_SHARE_WRITE_LE)) {
693 			smb_shared_mode_error(FILE_WRITE_ERROR,
694 					      prev_fp,
695 					      curr_fp);
696 			rc = -EPERM;
697 			break;
698 		}
699 
700 		if (prev_fp->daccess & FILE_DELETE_LE &&
701 		    !(curr_fp->saccess & FILE_SHARE_DELETE_LE)) {
702 			smb_shared_mode_error(FILE_DELETE_ERROR,
703 					      prev_fp,
704 					      curr_fp);
705 			rc = -EPERM;
706 			break;
707 		}
708 	}
709 	read_unlock(&curr_fp->f_ci->m_lock);
710 
711 	return rc;
712 }
713 
714 bool is_asterisk(char *p)
715 {
716 	return p && p[0] == '*';
717 }
718 
719 int ksmbd_override_fsids(struct ksmbd_work *work)
720 {
721 	struct ksmbd_session *sess = work->sess;
722 	struct ksmbd_share_config *share = work->tcon->share_conf;
723 	struct cred *cred;
724 	struct group_info *gi;
725 	unsigned int uid;
726 	unsigned int gid;
727 
728 	uid = user_uid(sess->user);
729 	gid = user_gid(sess->user);
730 	if (share->force_uid != KSMBD_SHARE_INVALID_UID)
731 		uid = share->force_uid;
732 	if (share->force_gid != KSMBD_SHARE_INVALID_GID)
733 		gid = share->force_gid;
734 
735 	cred = prepare_kernel_cred(&init_task);
736 	if (!cred)
737 		return -ENOMEM;
738 
739 	cred->fsuid = make_kuid(&init_user_ns, uid);
740 	cred->fsgid = make_kgid(&init_user_ns, gid);
741 
742 	gi = groups_alloc(0);
743 	if (!gi) {
744 		abort_creds(cred);
745 		return -ENOMEM;
746 	}
747 	set_groups(cred, gi);
748 	put_group_info(gi);
749 
750 	if (!uid_eq(cred->fsuid, GLOBAL_ROOT_UID))
751 		cred->cap_effective = cap_drop_fs_set(cred->cap_effective);
752 
753 	WARN_ON(work->saved_cred);
754 	work->saved_cred = override_creds(cred);
755 	if (!work->saved_cred) {
756 		abort_creds(cred);
757 		return -EINVAL;
758 	}
759 	return 0;
760 }
761 
762 void ksmbd_revert_fsids(struct ksmbd_work *work)
763 {
764 	const struct cred *cred;
765 
766 	WARN_ON(!work->saved_cred);
767 
768 	cred = current_cred();
769 	revert_creds(work->saved_cred);
770 	put_cred(cred);
771 	work->saved_cred = NULL;
772 }
773 
774 __le32 smb_map_generic_desired_access(__le32 daccess)
775 {
776 	if (daccess & FILE_GENERIC_READ_LE) {
777 		daccess |= cpu_to_le32(GENERIC_READ_FLAGS);
778 		daccess &= ~FILE_GENERIC_READ_LE;
779 	}
780 
781 	if (daccess & FILE_GENERIC_WRITE_LE) {
782 		daccess |= cpu_to_le32(GENERIC_WRITE_FLAGS);
783 		daccess &= ~FILE_GENERIC_WRITE_LE;
784 	}
785 
786 	if (daccess & FILE_GENERIC_EXECUTE_LE) {
787 		daccess |= cpu_to_le32(GENERIC_EXECUTE_FLAGS);
788 		daccess &= ~FILE_GENERIC_EXECUTE_LE;
789 	}
790 
791 	if (daccess & FILE_GENERIC_ALL_LE) {
792 		daccess |= cpu_to_le32(GENERIC_ALL_FLAGS);
793 		daccess &= ~FILE_GENERIC_ALL_LE;
794 	}
795 
796 	return daccess;
797 }
798