1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) 2018 Samsung Electronics Co., Ltd.
4 * Copyright (C) 2018 Namjae Jeon <linkinjeon@kernel.org>
7 #include "smb_common.h"
10 #include "smbstatus.h"
11 #include "connection.h"
12 #include "ksmbd_work.h"
13 #include "mgmt/user_session.h"
14 #include "mgmt/user_config.h"
15 #include "mgmt/tree_connect.h"
16 #include "mgmt/share_config.h"
18 /*for shortname implementation */
19 static const char basechars[43] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_-!@#$%";
20 #define MANGLE_BASE (sizeof(basechars) / sizeof(char) - 1)
21 #define MAGIC_CHAR '~'
23 #define mangle(V) ((char)(basechars[(V) % MANGLE_BASE]))
32 static struct smb_protocol smb1_protos[] = {
47 static struct smb_protocol smb2_protos[] = {
74 unsigned int ksmbd_server_side_copy_max_chunk_count(void)
79 unsigned int ksmbd_server_side_copy_max_chunk_size(void)
81 return (2U << 30) - 1;
84 unsigned int ksmbd_server_side_copy_max_total_size(void)
86 return (2U << 30) - 1;
89 inline int ksmbd_min_protocol(void)
94 inline int ksmbd_max_protocol(void)
99 int ksmbd_lookup_protocol_idx(char *str)
101 int offt = ARRAY_SIZE(smb1_protos) - 1;
102 int len = strlen(str);
105 if (!strncmp(str, smb1_protos[offt].prot, len)) {
106 ksmbd_debug(SMB, "selected %s dialect idx = %d\n",
107 smb1_protos[offt].prot, offt);
108 return smb1_protos[offt].index;
113 offt = ARRAY_SIZE(smb2_protos) - 1;
115 if (!strncmp(str, smb2_protos[offt].prot, len)) {
116 ksmbd_debug(SMB, "selected %s dialect idx = %d\n",
117 smb2_protos[offt].prot, offt);
118 return smb2_protos[offt].index;
126 * ksmbd_verify_smb_message() - check for valid smb2 request header
129 * check for valid smb signature and packet direction(request/response)
131 * Return: 0 on success, otherwise -EINVAL
133 int ksmbd_verify_smb_message(struct ksmbd_work *work)
135 struct smb2_hdr *smb2_hdr = ksmbd_req_buf_next(work);
138 if (smb2_hdr->ProtocolId == SMB2_PROTO_NUMBER)
139 return ksmbd_smb2_check_message(work);
141 hdr = work->request_buf;
142 if (*(__le32 *)hdr->Protocol == SMB1_PROTO_NUMBER &&
143 hdr->Command == SMB_COM_NEGOTIATE)
150 * ksmbd_smb_request() - check for valid smb request type
151 * @conn: connection instance
153 * Return: true on success, otherwise false
155 bool ksmbd_smb_request(struct ksmbd_conn *conn)
157 return conn->request_buf[0] == 0;
160 static bool supported_protocol(int idx)
162 if (idx == SMB2X_PROT &&
163 (server_conf.min_protocol >= SMB21_PROT ||
164 server_conf.max_protocol <= SMB311_PROT))
167 return (server_conf.min_protocol <= idx &&
168 idx <= server_conf.max_protocol);
171 static char *next_dialect(char *dialect, int *next_off, int bcount)
173 dialect = dialect + *next_off;
174 *next_off = strnlen(dialect, bcount);
175 if (dialect[*next_off] != '\0')
180 static int ksmbd_lookup_dialect_by_name(char *cli_dialects, __le16 byte_count)
182 int i, seq_num, bcount, next;
185 for (i = ARRAY_SIZE(smb1_protos) - 1; i >= 0; i--) {
188 dialect = cli_dialects;
189 bcount = le16_to_cpu(byte_count);
191 dialect = next_dialect(dialect, &next, bcount);
194 ksmbd_debug(SMB, "client requested dialect %s\n",
196 if (!strcmp(dialect, smb1_protos[i].name)) {
197 if (supported_protocol(smb1_protos[i].index)) {
199 "selected %s dialect\n",
200 smb1_protos[i].name);
201 if (smb1_protos[i].index == SMB1_PROT)
203 return smb1_protos[i].prot_id;
208 } while (bcount > 0);
214 int ksmbd_lookup_dialect_by_id(__le16 *cli_dialects, __le16 dialects_count)
219 for (i = ARRAY_SIZE(smb2_protos) - 1; i >= 0; i--) {
220 count = le16_to_cpu(dialects_count);
221 while (--count >= 0) {
222 ksmbd_debug(SMB, "client requested dialect 0x%x\n",
223 le16_to_cpu(cli_dialects[count]));
224 if (le16_to_cpu(cli_dialects[count]) !=
225 smb2_protos[i].prot_id)
228 if (supported_protocol(smb2_protos[i].index)) {
229 ksmbd_debug(SMB, "selected %s dialect\n",
230 smb2_protos[i].name);
231 return smb2_protos[i].prot_id;
239 static int ksmbd_negotiate_smb_dialect(void *buf)
241 int smb_buf_length = get_rfc1002_len(buf);
242 __le32 proto = ((struct smb2_hdr *)smb2_get_msg(buf))->ProtocolId;
244 if (proto == SMB2_PROTO_NUMBER) {
245 struct smb2_negotiate_req *req;
247 offsetof(struct smb2_negotiate_req, Dialects);
249 req = (struct smb2_negotiate_req *)smb2_get_msg(buf);
250 if (smb2_neg_size > smb_buf_length)
253 if (smb2_neg_size + le16_to_cpu(req->DialectCount) * sizeof(__le16) >
257 return ksmbd_lookup_dialect_by_id(req->Dialects,
261 proto = *(__le32 *)((struct smb_hdr *)buf)->Protocol;
262 if (proto == SMB1_PROTO_NUMBER) {
263 struct smb_negotiate_req *req;
265 req = (struct smb_negotiate_req *)buf;
266 if (le16_to_cpu(req->ByteCount) < 2)
269 if (offsetof(struct smb_negotiate_req, DialectsArray) - 4 +
270 le16_to_cpu(req->ByteCount) > smb_buf_length) {
274 return ksmbd_lookup_dialect_by_name(req->DialectsArray,
282 int ksmbd_init_smb_server(struct ksmbd_work *work)
284 struct ksmbd_conn *conn = work->conn;
286 if (conn->need_neg == false)
289 init_smb3_11_server(conn);
291 if (conn->ops->get_cmd_val(work) != SMB_COM_NEGOTIATE)
292 conn->need_neg = false;
296 int ksmbd_populate_dot_dotdot_entries(struct ksmbd_work *work, int info_level,
297 struct ksmbd_file *dir,
298 struct ksmbd_dir_info *d_info,
299 char *search_pattern,
300 int (*fn)(struct ksmbd_conn *, int,
301 struct ksmbd_dir_info *,
302 struct ksmbd_kstat *))
305 struct ksmbd_conn *conn = work->conn;
306 struct user_namespace *user_ns = file_mnt_user_ns(dir->filp);
308 for (i = 0; i < 2; i++) {
310 struct ksmbd_kstat ksmbd_kstat;
312 if (!dir->dot_dotdot[i]) { /* fill dot entry info */
315 d_info->name_len = 1;
318 d_info->name_len = 2;
321 if (!match_pattern(d_info->name, d_info->name_len,
323 dir->dot_dotdot[i] = 1;
327 ksmbd_kstat.kstat = &kstat;
328 ksmbd_vfs_fill_dentry_attrs(work,
330 dir->filp->f_path.dentry->d_parent,
332 rc = fn(conn, info_level, d_info, &ksmbd_kstat);
335 if (d_info->out_buf_len <= 0)
338 dir->dot_dotdot[i] = 1;
339 if (d_info->flags & SMB2_RETURN_SINGLE_ENTRY) {
340 d_info->out_buf_len = 0;
350 * ksmbd_extract_shortname() - get shortname from long filename
351 * @conn: connection instance
352 * @longname: source long filename
353 * @shortname: destination short filename
355 * Return: shortname length or 0 when source long name is '.' or '..'
356 * TODO: Though this function comforms the restriction of 8.3 Filename spec,
357 * but the result is different with Windows 7's one. need to check.
359 int ksmbd_extract_shortname(struct ksmbd_conn *conn, const char *longname,
363 char base[9], extension[4];
366 int extlen = 0, len = 0;
367 unsigned int csum = 0;
368 const unsigned char *ptr;
369 bool dot_present = true;
372 if ((*p == '.') || (!(strcmp(p, "..")))) {
373 /*no mangling required */
377 p = strrchr(longname, '.');
378 if (p == longname) { /*name starts with a dot*/
379 strscpy(extension, "___", strlen("___"));
383 while (*p && extlen < 3) {
385 extension[extlen++] = toupper(*p);
388 extension[extlen] = '\0';
399 while (*p && (baselen < 5)) {
401 base[baselen++] = toupper(*p);
405 base[baselen] = MAGIC_CHAR;
406 memcpy(out, base, baselen + 1);
409 len = strlen(longname);
410 for (; len > 0; len--, ptr++)
413 csum = csum % (MANGLE_BASE * MANGLE_BASE);
414 out[baselen + 1] = mangle(csum / MANGLE_BASE);
415 out[baselen + 2] = mangle(csum);
416 out[baselen + 3] = PERIOD;
419 memcpy(&out[baselen + 4], extension, 4);
421 out[baselen + 4] = '\0';
422 smbConvertToUTF16((__le16 *)shortname, out, PATH_MAX,
424 len = strlen(out) * 2;
428 static int __smb2_negotiate(struct ksmbd_conn *conn)
430 return (conn->dialect >= SMB21_PROT_ID &&
431 conn->dialect <= SMB311_PROT_ID);
434 static int smb_handle_negotiate(struct ksmbd_work *work)
436 struct smb_negotiate_rsp *neg_rsp = work->response_buf;
438 ksmbd_debug(SMB, "Unsupported SMB protocol\n");
439 neg_rsp->hdr.Status.CifsError = STATUS_INVALID_LOGON_TYPE;
443 int ksmbd_smb_negotiate_common(struct ksmbd_work *work, unsigned int command)
445 struct ksmbd_conn *conn = work->conn;
449 ksmbd_negotiate_smb_dialect(work->request_buf);
450 ksmbd_debug(SMB, "conn->dialect 0x%x\n", conn->dialect);
452 if (command == SMB2_NEGOTIATE_HE) {
453 struct smb2_hdr *smb2_hdr = smb2_get_msg(work->request_buf);
455 if (smb2_hdr->ProtocolId != SMB2_PROTO_NUMBER) {
456 ksmbd_debug(SMB, "Downgrade to SMB1 negotiation\n");
457 command = SMB_COM_NEGOTIATE;
461 if (command == SMB2_NEGOTIATE_HE && __smb2_negotiate(conn)) {
462 ret = smb2_handle_negotiate(work);
463 init_smb2_neg_rsp(work);
467 if (command == SMB_COM_NEGOTIATE) {
468 if (__smb2_negotiate(conn)) {
469 conn->need_neg = true;
470 init_smb3_11_server(conn);
471 init_smb2_neg_rsp(work);
472 ksmbd_debug(SMB, "Upgrade to SMB2 negotiation\n");
475 return smb_handle_negotiate(work);
478 pr_err("Unknown SMB negotiation command: %u\n", command);
482 enum SHARED_MODE_ERRORS {
491 static const char * const shared_mode_errors[] = {
492 "Current access mode does not permit SHARE_DELETE",
493 "Current access mode does not permit SHARE_READ",
494 "Current access mode does not permit SHARE_WRITE",
495 "Desired access mode does not permit FILE_READ",
496 "Desired access mode does not permit FILE_WRITE",
497 "Desired access mode does not permit FILE_DELETE",
500 static void smb_shared_mode_error(int error, struct ksmbd_file *prev_fp,
501 struct ksmbd_file *curr_fp)
503 ksmbd_debug(SMB, "%s\n", shared_mode_errors[error]);
504 ksmbd_debug(SMB, "Current mode: 0x%x Desired mode: 0x%x\n",
505 prev_fp->saccess, curr_fp->daccess);
508 int ksmbd_smb_check_shared_mode(struct file *filp, struct ksmbd_file *curr_fp)
511 struct ksmbd_file *prev_fp;
514 * Lookup fp in master fp list, and check desired access and
515 * shared mode between previous open and current open.
517 read_lock(&curr_fp->f_ci->m_lock);
518 list_for_each_entry(prev_fp, &curr_fp->f_ci->m_fp_list, node) {
519 if (file_inode(filp) != file_inode(prev_fp->filp))
522 if (filp == prev_fp->filp)
525 if (ksmbd_stream_fd(prev_fp) && ksmbd_stream_fd(curr_fp))
526 if (strcmp(prev_fp->stream.name, curr_fp->stream.name))
529 if (prev_fp->attrib_only != curr_fp->attrib_only)
532 if (!(prev_fp->saccess & FILE_SHARE_DELETE_LE) &&
533 curr_fp->daccess & FILE_DELETE_LE) {
534 smb_shared_mode_error(SHARE_DELETE_ERROR,
542 * Only check FILE_SHARE_DELETE if stream opened and
543 * normal file opened.
545 if (ksmbd_stream_fd(prev_fp) && !ksmbd_stream_fd(curr_fp))
548 if (!(prev_fp->saccess & FILE_SHARE_READ_LE) &&
549 curr_fp->daccess & (FILE_EXECUTE_LE | FILE_READ_DATA_LE)) {
550 smb_shared_mode_error(SHARE_READ_ERROR,
557 if (!(prev_fp->saccess & FILE_SHARE_WRITE_LE) &&
558 curr_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE)) {
559 smb_shared_mode_error(SHARE_WRITE_ERROR,
566 if (prev_fp->daccess & (FILE_EXECUTE_LE | FILE_READ_DATA_LE) &&
567 !(curr_fp->saccess & FILE_SHARE_READ_LE)) {
568 smb_shared_mode_error(FILE_READ_ERROR,
575 if (prev_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE) &&
576 !(curr_fp->saccess & FILE_SHARE_WRITE_LE)) {
577 smb_shared_mode_error(FILE_WRITE_ERROR,
584 if (prev_fp->daccess & FILE_DELETE_LE &&
585 !(curr_fp->saccess & FILE_SHARE_DELETE_LE)) {
586 smb_shared_mode_error(FILE_DELETE_ERROR,
593 read_unlock(&curr_fp->f_ci->m_lock);
598 bool is_asterisk(char *p)
600 return p && p[0] == '*';
603 int ksmbd_override_fsids(struct ksmbd_work *work)
605 struct ksmbd_session *sess = work->sess;
606 struct ksmbd_share_config *share = work->tcon->share_conf;
608 struct group_info *gi;
612 uid = user_uid(sess->user);
613 gid = user_gid(sess->user);
614 if (share->force_uid != KSMBD_SHARE_INVALID_UID)
615 uid = share->force_uid;
616 if (share->force_gid != KSMBD_SHARE_INVALID_GID)
617 gid = share->force_gid;
619 cred = prepare_kernel_cred(NULL);
623 cred->fsuid = make_kuid(current_user_ns(), uid);
624 cred->fsgid = make_kgid(current_user_ns(), gid);
626 gi = groups_alloc(0);
631 set_groups(cred, gi);
634 if (!uid_eq(cred->fsuid, GLOBAL_ROOT_UID))
635 cred->cap_effective = cap_drop_fs_set(cred->cap_effective);
637 WARN_ON(work->saved_cred);
638 work->saved_cred = override_creds(cred);
639 if (!work->saved_cred) {
646 void ksmbd_revert_fsids(struct ksmbd_work *work)
648 const struct cred *cred;
650 WARN_ON(!work->saved_cred);
652 cred = current_cred();
653 revert_creds(work->saved_cred);
655 work->saved_cred = NULL;
658 __le32 smb_map_generic_desired_access(__le32 daccess)
660 if (daccess & FILE_GENERIC_READ_LE) {
661 daccess |= cpu_to_le32(GENERIC_READ_FLAGS);
662 daccess &= ~FILE_GENERIC_READ_LE;
665 if (daccess & FILE_GENERIC_WRITE_LE) {
666 daccess |= cpu_to_le32(GENERIC_WRITE_FLAGS);
667 daccess &= ~FILE_GENERIC_WRITE_LE;
670 if (daccess & FILE_GENERIC_EXECUTE_LE) {
671 daccess |= cpu_to_le32(GENERIC_EXECUTE_FLAGS);
672 daccess &= ~FILE_GENERIC_EXECUTE_LE;
675 if (daccess & FILE_GENERIC_ALL_LE) {
676 daccess |= cpu_to_le32(GENERIC_ALL_FLAGS);
677 daccess &= ~FILE_GENERIC_ALL_LE;