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;
162
163 if (conn->request_buf[0] != 0)
164 return false;
165
166 proto = (__le32 *)smb2_get_msg(conn->request_buf);
167 if (*proto == SMB2_COMPRESSION_TRANSFORM_ID) {
168 pr_err_ratelimited("smb2 compression not support yet");
169 return false;
170 }
171
172 if (*proto != SMB1_PROTO_NUMBER &&
173 *proto != SMB2_PROTO_NUMBER &&
174 *proto != SMB2_TRANSFORM_PROTO_NUM)
175 return false;
176
177 return true;
178 }
179
180 static bool supported_protocol(int idx)
181 {
182 if (idx == SMB2X_PROT &&
183 (server_conf.min_protocol >= SMB21_PROT ||
184 server_conf.max_protocol <= SMB311_PROT))
185 return true;
186
187 return (server_conf.min_protocol <= idx &&
188 idx <= server_conf.max_protocol);
189 }
190
191 static char *next_dialect(char *dialect, int *next_off, int bcount)
192 {
193 dialect = dialect + *next_off;
194 *next_off = strnlen(dialect, bcount);
195 if (dialect[*next_off] != '\0')
196 return NULL;
197 return dialect;
198 }
199
200 static int ksmbd_lookup_dialect_by_name(char *cli_dialects, __le16 byte_count)
201 {
202 int i, seq_num, bcount, next;
203 char *dialect;
204
205 for (i = ARRAY_SIZE(smb1_protos) - 1; i >= 0; i--) {
206 seq_num = 0;
207 next = 0;
208 dialect = cli_dialects;
209 bcount = le16_to_cpu(byte_count);
210 do {
211 dialect = next_dialect(dialect, &next, bcount);
212 if (!dialect)
213 break;
214 ksmbd_debug(SMB, "client requested dialect %s\n",
215 dialect);
216 if (!strcmp(dialect, smb1_protos[i].name)) {
217 if (supported_protocol(smb1_protos[i].index)) {
218 ksmbd_debug(SMB,
219 "selected %s dialect\n",
220 smb1_protos[i].name);
221 if (smb1_protos[i].index == SMB1_PROT)
222 return seq_num;
223 return smb1_protos[i].prot_id;
224 }
225 }
226 seq_num++;
227 bcount -= (++next);
228 } while (bcount > 0);
229 }
230
231 return BAD_PROT_ID;
232 }
233
234 int ksmbd_lookup_dialect_by_id(__le16 *cli_dialects, __le16 dialects_count)
235 {
236 int i;
237 int count;
238
239 for (i = ARRAY_SIZE(smb2_protos) - 1; i >= 0; i--) {
240 count = le16_to_cpu(dialects_count);
241 while (--count >= 0) {
242 ksmbd_debug(SMB, "client requested dialect 0x%x\n",
243 le16_to_cpu(cli_dialects[count]));
244 if (le16_to_cpu(cli_dialects[count]) !=
245 smb2_protos[i].prot_id)
246 continue;
247
248 if (supported_protocol(smb2_protos[i].index)) {
249 ksmbd_debug(SMB, "selected %s dialect\n",
250 smb2_protos[i].name);
251 return smb2_protos[i].prot_id;
252 }
253 }
254 }
255
256 return BAD_PROT_ID;
257 }
258
259 static int ksmbd_negotiate_smb_dialect(void *buf)
260 {
261 int smb_buf_length = get_rfc1002_len(buf);
262 __le32 proto = ((struct smb2_hdr *)smb2_get_msg(buf))->ProtocolId;
263
264 if (proto == SMB2_PROTO_NUMBER) {
265 struct smb2_negotiate_req *req;
266 int smb2_neg_size =
267 offsetof(struct smb2_negotiate_req, Dialects);
268
269 req = (struct smb2_negotiate_req *)smb2_get_msg(buf);
270 if (smb2_neg_size > smb_buf_length)
271 goto err_out;
272
273 if (struct_size(req, Dialects, le16_to_cpu(req->DialectCount)) >
274 smb_buf_length)
275 goto err_out;
276
277 return ksmbd_lookup_dialect_by_id(req->Dialects,
278 req->DialectCount);
279 }
280
281 proto = *(__le32 *)((struct smb_hdr *)buf)->Protocol;
282 if (proto == SMB1_PROTO_NUMBER) {
283 struct smb_negotiate_req *req;
284
285 req = (struct smb_negotiate_req *)buf;
286 if (le16_to_cpu(req->ByteCount) < 2)
287 goto err_out;
288
289 if (offsetof(struct smb_negotiate_req, DialectsArray) - 4 +
290 le16_to_cpu(req->ByteCount) > smb_buf_length) {
291 goto err_out;
292 }
293
294 return ksmbd_lookup_dialect_by_name(req->DialectsArray,
295 req->ByteCount);
296 }
297
298 err_out:
299 return BAD_PROT_ID;
300 }
301
302 #define SMB_COM_NEGOTIATE_EX 0x0
303
304 /**
305 * get_smb1_cmd_val() - get smb command value from smb header
306 * @work: smb work containing smb header
307 *
308 * Return: smb command value
309 */
310 static u16 get_smb1_cmd_val(struct ksmbd_work *work)
311 {
312 return SMB_COM_NEGOTIATE_EX;
313 }
314
315 /**
316 * init_smb1_rsp_hdr() - initialize smb negotiate response header
317 * @work: smb work containing smb request
318 *
319 * Return: 0 on success, otherwise -EINVAL
320 */
321 static int init_smb1_rsp_hdr(struct ksmbd_work *work)
322 {
323 struct smb_hdr *rsp_hdr = (struct smb_hdr *)work->response_buf;
324 struct smb_hdr *rcv_hdr = (struct smb_hdr *)work->request_buf;
325
326 rsp_hdr->Command = SMB_COM_NEGOTIATE;
327 *(__le32 *)rsp_hdr->Protocol = SMB1_PROTO_NUMBER;
328 rsp_hdr->Flags = SMBFLG_RESPONSE;
329 rsp_hdr->Flags2 = SMBFLG2_UNICODE | SMBFLG2_ERR_STATUS |
330 SMBFLG2_EXT_SEC | SMBFLG2_IS_LONG_NAME;
331 rsp_hdr->Pid = rcv_hdr->Pid;
332 rsp_hdr->Mid = rcv_hdr->Mid;
333 return 0;
334 }
335
336 /**
337 * smb1_check_user_session() - check for valid session for a user
338 * @work: smb work containing smb request buffer
339 *
340 * Return: 0 on success, otherwise error
341 */
342 static int smb1_check_user_session(struct ksmbd_work *work)
343 {
344 unsigned int cmd = work->conn->ops->get_cmd_val(work);
345
346 if (cmd == SMB_COM_NEGOTIATE_EX)
347 return 0;
348
349 return -EINVAL;
350 }
351
352 /**
353 * smb1_allocate_rsp_buf() - allocate response buffer for a command
354 * @work: smb work containing smb request
355 *
356 * Return: 0 on success, otherwise -ENOMEM
357 */
358 static int smb1_allocate_rsp_buf(struct ksmbd_work *work)
359 {
360 work->response_buf = kzalloc(MAX_CIFS_SMALL_BUFFER_SIZE,
361 GFP_KERNEL);
362 work->response_sz = MAX_CIFS_SMALL_BUFFER_SIZE;
363
364 if (!work->response_buf) {
365 pr_err("Failed to allocate %u bytes buffer\n",
366 MAX_CIFS_SMALL_BUFFER_SIZE);
367 return -ENOMEM;
368 }
369
370 return 0;
371 }
372
373 /**
374 * set_smb1_rsp_status() - set error type in smb response header
375 * @work: smb work containing smb response header
376 * @err: error code to set in response
377 */
378 static void set_smb1_rsp_status(struct ksmbd_work *work, __le32 err)
379 {
380 work->send_no_response = 1;
381 }
382
383 static struct smb_version_ops smb1_server_ops = {
384 .get_cmd_val = get_smb1_cmd_val,
385 .init_rsp_hdr = init_smb1_rsp_hdr,
386 .allocate_rsp_buf = smb1_allocate_rsp_buf,
387 .check_user_session = smb1_check_user_session,
388 .set_rsp_status = set_smb1_rsp_status,
389 };
390
391 static int smb1_negotiate(struct ksmbd_work *work)
392 {
393 return ksmbd_smb_negotiate_common(work, SMB_COM_NEGOTIATE);
394 }
395
396 static struct smb_version_cmds smb1_server_cmds[1] = {
397 [SMB_COM_NEGOTIATE_EX] = { .proc = smb1_negotiate, },
398 };
399
400 static int init_smb1_server(struct ksmbd_conn *conn)
401 {
402 conn->ops = &smb1_server_ops;
403 conn->cmds = smb1_server_cmds;
404 conn->max_cmds = ARRAY_SIZE(smb1_server_cmds);
405 return 0;
406 }
407
408 int ksmbd_init_smb_server(struct ksmbd_work *work)
409 {
410 struct ksmbd_conn *conn = work->conn;
411 __le32 proto;
412
413 proto = *(__le32 *)((struct smb_hdr *)work->request_buf)->Protocol;
414 if (conn->need_neg == false) {
415 if (proto == SMB1_PROTO_NUMBER)
416 return -EINVAL;
417 return 0;
418 }
419
420 if (proto == SMB1_PROTO_NUMBER)
421 return init_smb1_server(conn);
422 return init_smb3_11_server(conn);
423 }
424
425 int ksmbd_populate_dot_dotdot_entries(struct ksmbd_work *work, int info_level,
426 struct ksmbd_file *dir,
427 struct ksmbd_dir_info *d_info,
428 char *search_pattern,
429 int (*fn)(struct ksmbd_conn *, int,
430 struct ksmbd_dir_info *,
431 struct ksmbd_kstat *))
432 {
433 int i, rc = 0;
434 struct ksmbd_conn *conn = work->conn;
435 struct mnt_idmap *idmap = file_mnt_idmap(dir->filp);
436
437 for (i = 0; i < 2; i++) {
438 struct kstat kstat;
439 struct ksmbd_kstat ksmbd_kstat;
440 struct dentry *dentry;
441
442 if (!dir->dot_dotdot[i]) { /* fill dot entry info */
443 if (i == 0) {
444 d_info->name = ".";
445 d_info->name_len = 1;
446 dentry = dir->filp->f_path.dentry;
447 } else {
448 d_info->name = "..";
449 d_info->name_len = 2;
450 dentry = dir->filp->f_path.dentry->d_parent;
451 }
452
453 if (!match_pattern(d_info->name, d_info->name_len,
454 search_pattern)) {
455 dir->dot_dotdot[i] = 1;
456 continue;
457 }
458
459 ksmbd_kstat.kstat = &kstat;
460 rc = ksmbd_vfs_fill_dentry_attrs(work,
461 idmap,
462 dentry,
463 &ksmbd_kstat);
464 if (rc)
465 break;
466
467 rc = fn(conn, info_level, d_info, &ksmbd_kstat);
468 if (rc)
469 break;
470 if (d_info->out_buf_len <= 0)
471 break;
472
473 dir->dot_dotdot[i] = 1;
474 if (d_info->flags & SMB2_RETURN_SINGLE_ENTRY) {
475 d_info->out_buf_len = 0;
476 break;
477 }
478 }
479 }
480
481 return rc;
482 }
483
484 /**
485 * ksmbd_extract_shortname() - get shortname from long filename
486 * @conn: connection instance
487 * @longname: source long filename
488 * @shortname: destination short filename
489 *
490 * Return: shortname length or 0 when source long name is '.' or '..'
491 * TODO: Though this function comforms the restriction of 8.3 Filename spec,
492 * but the result is different with Windows 7's one. need to check.
493 */
494 int ksmbd_extract_shortname(struct ksmbd_conn *conn, const char *longname,
495 char *shortname)
496 {
497 const char *p;
498 char base[9], extension[4];
499 char out[13] = {0};
500 int baselen = 0;
501 int extlen = 0, len = 0;
502 unsigned int csum = 0;
503 const unsigned char *ptr;
504 bool dot_present = true;
505
506 p = longname;
507 if ((*p == '.') || (!(strcmp(p, "..")))) {
508 /*no mangling required */
509 return 0;
510 }
511
512 p = strrchr(longname, '.');
513 if (p == longname) { /*name starts with a dot*/
514 strscpy(extension, "___", strlen("___"));
515 } else {
516 if (p) {
517 p++;
518 while (*p && extlen < 3) {
519 if (*p != '.')
520 extension[extlen++] = toupper(*p);
521 p++;
522 }
523 extension[extlen] = '\0';
524 } else {
525 dot_present = false;
526 }
527 }
528
529 p = longname;
530 if (*p == '.') {
531 p++;
532 longname++;
533 }
534 while (*p && (baselen < 5)) {
535 if (*p != '.')
536 base[baselen++] = toupper(*p);
537 p++;
538 }
539
540 base[baselen] = MAGIC_CHAR;
541 memcpy(out, base, baselen + 1);
542
543 ptr = longname;
544 len = strlen(longname);
545 for (; len > 0; len--, ptr++)
546 csum += *ptr;
547
548 csum = csum % (MANGLE_BASE * MANGLE_BASE);
549 out[baselen + 1] = mangle(csum / MANGLE_BASE);
550 out[baselen + 2] = mangle(csum);
551 out[baselen + 3] = PERIOD;
552
553 if (dot_present)
554 memcpy(out + baselen + 4, extension, 4);
555 else
556 out[baselen + 4] = '\0';
557 smbConvertToUTF16((__le16 *)shortname, out, PATH_MAX,
558 conn->local_nls, 0);
559 len = strlen(out) * 2;
560 return len;
561 }
562
563 static int __smb2_negotiate(struct ksmbd_conn *conn)
564 {
565 return (conn->dialect >= SMB20_PROT_ID &&
566 conn->dialect <= SMB311_PROT_ID);
567 }
568
569 static int smb_handle_negotiate(struct ksmbd_work *work)
570 {
571 struct smb_negotiate_rsp *neg_rsp = work->response_buf;
572
573 ksmbd_debug(SMB, "Unsupported SMB1 protocol\n");
574
575 if (ksmbd_iov_pin_rsp(work, (void *)neg_rsp,
576 sizeof(struct smb_negotiate_rsp) - 4))
577 return -ENOMEM;
578
579 neg_rsp->hdr.Status.CifsError = STATUS_SUCCESS;
580 neg_rsp->hdr.WordCount = 1;
581 neg_rsp->DialectIndex = cpu_to_le16(work->conn->dialect);
582 neg_rsp->ByteCount = 0;
583 return 0;
584 }
585
586 int ksmbd_smb_negotiate_common(struct ksmbd_work *work, unsigned int command)
587 {
588 struct ksmbd_conn *conn = work->conn;
589 int ret;
590
591 conn->dialect =
592 ksmbd_negotiate_smb_dialect(work->request_buf);
593 ksmbd_debug(SMB, "conn->dialect 0x%x\n", conn->dialect);
594
595 if (command == SMB2_NEGOTIATE_HE) {
596 ret = smb2_handle_negotiate(work);
597 return ret;
598 }
599
600 if (command == SMB_COM_NEGOTIATE) {
601 if (__smb2_negotiate(conn)) {
602 init_smb3_11_server(conn);
603 init_smb2_neg_rsp(work);
604 ksmbd_debug(SMB, "Upgrade to SMB2 negotiation\n");
605 return 0;
606 }
607 return smb_handle_negotiate(work);
608 }
609
610 pr_err("Unknown SMB negotiation command: %u\n", command);
611 return -EINVAL;
612 }
613
614 enum SHARED_MODE_ERRORS {
615 SHARE_DELETE_ERROR,
616 SHARE_READ_ERROR,
617 SHARE_WRITE_ERROR,
618 FILE_READ_ERROR,
619 FILE_WRITE_ERROR,
620 FILE_DELETE_ERROR,
621 };
622
623 static const char * const shared_mode_errors[] = {
624 "Current access mode does not permit SHARE_DELETE",
625 "Current access mode does not permit SHARE_READ",
626 "Current access mode does not permit SHARE_WRITE",
627 "Desired access mode does not permit FILE_READ",
628 "Desired access mode does not permit FILE_WRITE",
629 "Desired access mode does not permit FILE_DELETE",
630 };
631
632 static void smb_shared_mode_error(int error, struct ksmbd_file *prev_fp,
633 struct ksmbd_file *curr_fp)
634 {
635 ksmbd_debug(SMB, "%s\n", shared_mode_errors[error]);
636 ksmbd_debug(SMB, "Current mode: 0x%x Desired mode: 0x%x\n",
637 prev_fp->saccess, curr_fp->daccess);
638 }
639
640 int ksmbd_smb_check_shared_mode(struct file *filp, struct ksmbd_file *curr_fp)
641 {
642 int rc = 0;
643 struct ksmbd_file *prev_fp;
644
645 /*
646 * Lookup fp in master fp list, and check desired access and
647 * shared mode between previous open and current open.
648 */
649 down_read(&curr_fp->f_ci->m_lock);
650 list_for_each_entry(prev_fp, &curr_fp->f_ci->m_fp_list, node) {
651 if (file_inode(filp) != file_inode(prev_fp->filp))
652 continue;
653
654 if (filp == prev_fp->filp)
655 continue;
656
657 if (ksmbd_stream_fd(prev_fp) && ksmbd_stream_fd(curr_fp))
658 if (strcmp(prev_fp->stream.name, curr_fp->stream.name))
659 continue;
660
661 if (prev_fp->attrib_only != curr_fp->attrib_only)
662 continue;
663
664 if (!(prev_fp->saccess & FILE_SHARE_DELETE_LE) &&
665 curr_fp->daccess & FILE_DELETE_LE) {
666 smb_shared_mode_error(SHARE_DELETE_ERROR,
667 prev_fp,
668 curr_fp);
669 rc = -EPERM;
670 break;
671 }
672
673 /*
674 * Only check FILE_SHARE_DELETE if stream opened and
675 * normal file opened.
676 */
677 if (ksmbd_stream_fd(prev_fp) && !ksmbd_stream_fd(curr_fp))
678 continue;
679
680 if (!(prev_fp->saccess & FILE_SHARE_READ_LE) &&
681 curr_fp->daccess & (FILE_EXECUTE_LE | FILE_READ_DATA_LE)) {
682 smb_shared_mode_error(SHARE_READ_ERROR,
683 prev_fp,
684 curr_fp);
685 rc = -EPERM;
686 break;
687 }
688
689 if (!(prev_fp->saccess & FILE_SHARE_WRITE_LE) &&
690 curr_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE)) {
691 smb_shared_mode_error(SHARE_WRITE_ERROR,
692 prev_fp,
693 curr_fp);
694 rc = -EPERM;
695 break;
696 }
697
698 if (prev_fp->daccess & (FILE_EXECUTE_LE | FILE_READ_DATA_LE) &&
699 !(curr_fp->saccess & FILE_SHARE_READ_LE)) {
700 smb_shared_mode_error(FILE_READ_ERROR,
701 prev_fp,
702 curr_fp);
703 rc = -EPERM;
704 break;
705 }
706
707 if (prev_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE) &&
708 !(curr_fp->saccess & FILE_SHARE_WRITE_LE)) {
709 smb_shared_mode_error(FILE_WRITE_ERROR,
710 prev_fp,
711 curr_fp);
712 rc = -EPERM;
713 break;
714 }
715
716 if (prev_fp->daccess & FILE_DELETE_LE &&
717 !(curr_fp->saccess & FILE_SHARE_DELETE_LE)) {
718 smb_shared_mode_error(FILE_DELETE_ERROR,
719 prev_fp,
720 curr_fp);
721 rc = -EPERM;
722 break;
723 }
724 }
725 up_read(&curr_fp->f_ci->m_lock);
726
727 return rc;
728 }
729
730 bool is_asterisk(char *p)
731 {
732 return p && p[0] == '*';
733 }
734
735 int __ksmbd_override_fsids(struct ksmbd_work *work,
736 struct ksmbd_share_config *share)
737 {
738 struct ksmbd_session *sess = work->sess;
739 struct cred *cred;
740 struct group_info *gi;
741 unsigned int uid;
742 unsigned int gid;
743
744 uid = user_uid(sess->user);
745 gid = user_gid(sess->user);
746 if (share->force_uid != KSMBD_SHARE_INVALID_UID)
747 uid = share->force_uid;
748 if (share->force_gid != KSMBD_SHARE_INVALID_GID)
749 gid = share->force_gid;
750
751 cred = prepare_kernel_cred(&init_task);
752 if (!cred)
753 return -ENOMEM;
754
755 cred->fsuid = make_kuid(&init_user_ns, uid);
756 cred->fsgid = make_kgid(&init_user_ns, gid);
757
758 gi = groups_alloc(0);
759 if (!gi) {
760 abort_creds(cred);
761 return -ENOMEM;
762 }
763 set_groups(cred, gi);
764 put_group_info(gi);
765
766 if (!uid_eq(cred->fsuid, GLOBAL_ROOT_UID))
767 cred->cap_effective = cap_drop_fs_set(cred->cap_effective);
768
769 WARN_ON(work->saved_cred);
770 work->saved_cred = override_creds(cred);
771 if (!work->saved_cred) {
772 abort_creds(cred);
773 return -EINVAL;
774 }
775 return 0;
776 }
777
778 int ksmbd_override_fsids(struct ksmbd_work *work)
779 {
780 return __ksmbd_override_fsids(work, work->tcon->share_conf);
781 }
782
783 void ksmbd_revert_fsids(struct ksmbd_work *work)
784 {
785 const struct cred *cred;
786
787 WARN_ON(!work->saved_cred);
788
789 cred = current_cred();
790 revert_creds(work->saved_cred);
791 put_cred(cred);
792 work->saved_cred = NULL;
793 }
794
795 __le32 smb_map_generic_desired_access(__le32 daccess)
796 {
797 if (daccess & FILE_GENERIC_READ_LE) {
798 daccess |= cpu_to_le32(GENERIC_READ_FLAGS);
799 daccess &= ~FILE_GENERIC_READ_LE;
800 }
801
802 if (daccess & FILE_GENERIC_WRITE_LE) {
803 daccess |= cpu_to_le32(GENERIC_WRITE_FLAGS);
804 daccess &= ~FILE_GENERIC_WRITE_LE;
805 }
806
807 if (daccess & FILE_GENERIC_EXECUTE_LE) {
808 daccess |= cpu_to_le32(GENERIC_EXECUTE_FLAGS);
809 daccess &= ~FILE_GENERIC_EXECUTE_LE;
810 }
811
812 if (daccess & FILE_GENERIC_ALL_LE) {
813 daccess |= cpu_to_le32(GENERIC_ALL_FLAGS);
814 daccess &= ~FILE_GENERIC_ALL_LE;
815 }
816
817 return daccess;
818 }
819
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.