| // SPDX-License-Identifier: GPL-2.0-or-later |
| /* |
| * Copyright (C) 2018 Samsung Electronics Co., Ltd. |
| * Copyright (C) 2018 Namjae Jeon <linkinjeon@kernel.org> |
| */ |
| |
| #include <linux/user_namespace.h> |
| |
| #include "smb_common.h" |
| #include "server.h" |
| #include "misc.h" |
| #include "smbstatus.h" |
| #include "connection.h" |
| #include "ksmbd_work.h" |
| #include "mgmt/user_session.h" |
| #include "mgmt/user_config.h" |
| #include "mgmt/tree_connect.h" |
| #include "mgmt/share_config.h" |
| |
| /*for shortname implementation */ |
| static const char basechars[43] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_-!@#$%"; |
| #define MANGLE_BASE (sizeof(basechars) / sizeof(char) - 1) |
| #define MAGIC_CHAR '~' |
| #define PERIOD '.' |
| #define mangle(V) ((char)(basechars[(V) % MANGLE_BASE])) |
| |
| struct smb_protocol { |
| int index; |
| char *name; |
| char *prot; |
| __u16 prot_id; |
| }; |
| |
| static struct smb_protocol smb1_protos[] = { |
| { |
| SMB21_PROT, |
| "\2SMB 2.1", |
| "SMB2_10", |
| SMB21_PROT_ID |
| }, |
| { |
| SMB2X_PROT, |
| "\2SMB 2.???", |
| "SMB2_22", |
| SMB2X_PROT_ID |
| }, |
| }; |
| |
| static struct smb_protocol smb2_protos[] = { |
| { |
| SMB21_PROT, |
| "\2SMB 2.1", |
| "SMB2_10", |
| SMB21_PROT_ID |
| }, |
| { |
| SMB30_PROT, |
| "\2SMB 3.0", |
| "SMB3_00", |
| SMB30_PROT_ID |
| }, |
| { |
| SMB302_PROT, |
| "\2SMB 3.02", |
| "SMB3_02", |
| SMB302_PROT_ID |
| }, |
| { |
| SMB311_PROT, |
| "\2SMB 3.1.1", |
| "SMB3_11", |
| SMB311_PROT_ID |
| }, |
| }; |
| |
| unsigned int ksmbd_server_side_copy_max_chunk_count(void) |
| { |
| return 256; |
| } |
| |
| unsigned int ksmbd_server_side_copy_max_chunk_size(void) |
| { |
| return (2U << 30) - 1; |
| } |
| |
| unsigned int ksmbd_server_side_copy_max_total_size(void) |
| { |
| return (2U << 30) - 1; |
| } |
| |
| inline int ksmbd_min_protocol(void) |
| { |
| return SMB21_PROT; |
| } |
| |
| inline int ksmbd_max_protocol(void) |
| { |
| return SMB311_PROT; |
| } |
| |
| int ksmbd_lookup_protocol_idx(char *str) |
| { |
| int offt = ARRAY_SIZE(smb1_protos) - 1; |
| int len = strlen(str); |
| |
| while (offt >= 0) { |
| if (!strncmp(str, smb1_protos[offt].prot, len)) { |
| ksmbd_debug(SMB, "selected %s dialect idx = %d\n", |
| smb1_protos[offt].prot, offt); |
| return smb1_protos[offt].index; |
| } |
| offt--; |
| } |
| |
| offt = ARRAY_SIZE(smb2_protos) - 1; |
| while (offt >= 0) { |
| if (!strncmp(str, smb2_protos[offt].prot, len)) { |
| ksmbd_debug(SMB, "selected %s dialect idx = %d\n", |
| smb2_protos[offt].prot, offt); |
| return smb2_protos[offt].index; |
| } |
| offt--; |
| } |
| return -1; |
| } |
| |
| /** |
| * ksmbd_verify_smb_message() - check for valid smb2 request header |
| * @work: smb work |
| * |
| * check for valid smb signature and packet direction(request/response) |
| * |
| * Return: 0 on success, otherwise -EINVAL |
| */ |
| int ksmbd_verify_smb_message(struct ksmbd_work *work) |
| { |
| struct smb2_hdr *smb2_hdr = ksmbd_req_buf_next(work); |
| struct smb_hdr *hdr; |
| |
| if (smb2_hdr->ProtocolId == SMB2_PROTO_NUMBER) |
| return ksmbd_smb2_check_message(work); |
| |
| hdr = work->request_buf; |
| if (*(__le32 *)hdr->Protocol == SMB1_PROTO_NUMBER && |
| hdr->Command == SMB_COM_NEGOTIATE) { |
| work->conn->outstanding_credits++; |
| return 0; |
| } |
| |
| return -EINVAL; |
| } |
| |
| /** |
| * ksmbd_smb_request() - check for valid smb request type |
| * @conn: connection instance |
| * |
| * Return: true on success, otherwise false |
| */ |
| bool ksmbd_smb_request(struct ksmbd_conn *conn) |
| { |
| __le32 *proto = (__le32 *)smb2_get_msg(conn->request_buf); |
| |
| if (*proto == SMB2_COMPRESSION_TRANSFORM_ID) { |
| pr_err_ratelimited("smb2 compression not support yet"); |
| return false; |
| } |
| |
| if (*proto != SMB1_PROTO_NUMBER && |
| *proto != SMB2_PROTO_NUMBER && |
| *proto != SMB2_TRANSFORM_PROTO_NUM) |
| return false; |
| |
| return true; |
| } |
| |
| static bool supported_protocol(int idx) |
| { |
| if (idx == SMB2X_PROT && |
| (server_conf.min_protocol >= SMB21_PROT || |
| server_conf.max_protocol <= SMB311_PROT)) |
| return true; |
| |
| return (server_conf.min_protocol <= idx && |
| idx <= server_conf.max_protocol); |
| } |
| |
| static char *next_dialect(char *dialect, int *next_off, int bcount) |
| { |
| dialect = dialect + *next_off; |
| *next_off = strnlen(dialect, bcount); |
| if (dialect[*next_off] != '\0') |
| return NULL; |
| return dialect; |
| } |
| |
| static int ksmbd_lookup_dialect_by_name(char *cli_dialects, __le16 byte_count) |
| { |
| int i, seq_num, bcount, next; |
| char *dialect; |
| |
| for (i = ARRAY_SIZE(smb1_protos) - 1; i >= 0; i--) { |
| seq_num = 0; |
| next = 0; |
| dialect = cli_dialects; |
| bcount = le16_to_cpu(byte_count); |
| do { |
| dialect = next_dialect(dialect, &next, bcount); |
| if (!dialect) |
| break; |
| ksmbd_debug(SMB, "client requested dialect %s\n", |
| dialect); |
| if (!strcmp(dialect, smb1_protos[i].name)) { |
| if (supported_protocol(smb1_protos[i].index)) { |
| ksmbd_debug(SMB, |
| "selected %s dialect\n", |
| smb1_protos[i].name); |
| if (smb1_protos[i].index == SMB1_PROT) |
| return seq_num; |
| return smb1_protos[i].prot_id; |
| } |
| } |
| seq_num++; |
| bcount -= (++next); |
| } while (bcount > 0); |
| } |
| |
| return BAD_PROT_ID; |
| } |
| |
| int ksmbd_lookup_dialect_by_id(__le16 *cli_dialects, __le16 dialects_count) |
| { |
| int i; |
| int count; |
| |
| for (i = ARRAY_SIZE(smb2_protos) - 1; i >= 0; i--) { |
| count = le16_to_cpu(dialects_count); |
| while (--count >= 0) { |
| ksmbd_debug(SMB, "client requested dialect 0x%x\n", |
| le16_to_cpu(cli_dialects[count])); |
| if (le16_to_cpu(cli_dialects[count]) != |
| smb2_protos[i].prot_id) |
| continue; |
| |
| if (supported_protocol(smb2_protos[i].index)) { |
| ksmbd_debug(SMB, "selected %s dialect\n", |
| smb2_protos[i].name); |
| return smb2_protos[i].prot_id; |
| } |
| } |
| } |
| |
| return BAD_PROT_ID; |
| } |
| |
| static int ksmbd_negotiate_smb_dialect(void *buf) |
| { |
| int smb_buf_length = get_rfc1002_len(buf); |
| __le32 proto = ((struct smb2_hdr *)smb2_get_msg(buf))->ProtocolId; |
| |
| if (proto == SMB2_PROTO_NUMBER) { |
| struct smb2_negotiate_req *req; |
| int smb2_neg_size = |
| offsetof(struct smb2_negotiate_req, Dialects); |
| |
| req = (struct smb2_negotiate_req *)smb2_get_msg(buf); |
| if (smb2_neg_size > smb_buf_length) |
| goto err_out; |
| |
| if (smb2_neg_size + le16_to_cpu(req->DialectCount) * sizeof(__le16) > |
| smb_buf_length) |
| goto err_out; |
| |
| return ksmbd_lookup_dialect_by_id(req->Dialects, |
| req->DialectCount); |
| } |
| |
| proto = *(__le32 *)((struct smb_hdr *)buf)->Protocol; |
| if (proto == SMB1_PROTO_NUMBER) { |
| struct smb_negotiate_req *req; |
| |
| req = (struct smb_negotiate_req *)buf; |
| if (le16_to_cpu(req->ByteCount) < 2) |
| goto err_out; |
| |
| if (offsetof(struct smb_negotiate_req, DialectsArray) - 4 + |
| le16_to_cpu(req->ByteCount) > smb_buf_length) { |
| goto err_out; |
| } |
| |
| return ksmbd_lookup_dialect_by_name(req->DialectsArray, |
| req->ByteCount); |
| } |
| |
| err_out: |
| return BAD_PROT_ID; |
| } |
| |
| #define SMB_COM_NEGOTIATE_EX 0x0 |
| |
| /** |
| * get_smb1_cmd_val() - get smb command value from smb header |
| * @work: smb work containing smb header |
| * |
| * Return: smb command value |
| */ |
| static u16 get_smb1_cmd_val(struct ksmbd_work *work) |
| { |
| return SMB_COM_NEGOTIATE_EX; |
| } |
| |
| /** |
| * init_smb1_rsp_hdr() - initialize smb negotiate response header |
| * @work: smb work containing smb request |
| * |
| * Return: 0 on success, otherwise -EINVAL |
| */ |
| static int init_smb1_rsp_hdr(struct ksmbd_work *work) |
| { |
| struct smb_hdr *rsp_hdr = (struct smb_hdr *)work->response_buf; |
| struct smb_hdr *rcv_hdr = (struct smb_hdr *)work->request_buf; |
| |
| /* |
| * Remove 4 byte direct TCP header. |
| */ |
| *(__be32 *)work->response_buf = |
| cpu_to_be32(sizeof(struct smb_hdr) - 4); |
| |
| rsp_hdr->Command = SMB_COM_NEGOTIATE; |
| *(__le32 *)rsp_hdr->Protocol = SMB1_PROTO_NUMBER; |
| rsp_hdr->Flags = SMBFLG_RESPONSE; |
| rsp_hdr->Flags2 = SMBFLG2_UNICODE | SMBFLG2_ERR_STATUS | |
| SMBFLG2_EXT_SEC | SMBFLG2_IS_LONG_NAME; |
| rsp_hdr->Pid = rcv_hdr->Pid; |
| rsp_hdr->Mid = rcv_hdr->Mid; |
| return 0; |
| } |
| |
| /** |
| * smb1_check_user_session() - check for valid session for a user |
| * @work: smb work containing smb request buffer |
| * |
| * Return: 0 on success, otherwise error |
| */ |
| static int smb1_check_user_session(struct ksmbd_work *work) |
| { |
| unsigned int cmd = work->conn->ops->get_cmd_val(work); |
| |
| if (cmd == SMB_COM_NEGOTIATE_EX) |
| return 0; |
| |
| return -EINVAL; |
| } |
| |
| /** |
| * smb1_allocate_rsp_buf() - allocate response buffer for a command |
| * @work: smb work containing smb request |
| * |
| * Return: 0 on success, otherwise -ENOMEM |
| */ |
| static int smb1_allocate_rsp_buf(struct ksmbd_work *work) |
| { |
| work->response_buf = kmalloc(MAX_CIFS_SMALL_BUFFER_SIZE, |
| GFP_KERNEL | __GFP_ZERO); |
| work->response_sz = MAX_CIFS_SMALL_BUFFER_SIZE; |
| |
| if (!work->response_buf) { |
| pr_err("Failed to allocate %u bytes buffer\n", |
| MAX_CIFS_SMALL_BUFFER_SIZE); |
| return -ENOMEM; |
| } |
| |
| return 0; |
| } |
| |
| static struct smb_version_ops smb1_server_ops = { |
| .get_cmd_val = get_smb1_cmd_val, |
| .init_rsp_hdr = init_smb1_rsp_hdr, |
| .allocate_rsp_buf = smb1_allocate_rsp_buf, |
| .check_user_session = smb1_check_user_session, |
| }; |
| |
| static int smb1_negotiate(struct ksmbd_work *work) |
| { |
| return ksmbd_smb_negotiate_common(work, SMB_COM_NEGOTIATE); |
| } |
| |
| static struct smb_version_cmds smb1_server_cmds[1] = { |
| [SMB_COM_NEGOTIATE_EX] = { .proc = smb1_negotiate, }, |
| }; |
| |
| static void init_smb1_server(struct ksmbd_conn *conn) |
| { |
| conn->ops = &smb1_server_ops; |
| conn->cmds = smb1_server_cmds; |
| conn->max_cmds = ARRAY_SIZE(smb1_server_cmds); |
| } |
| |
| void ksmbd_init_smb_server(struct ksmbd_work *work) |
| { |
| struct ksmbd_conn *conn = work->conn; |
| __le32 proto; |
| |
| if (conn->need_neg == false) |
| return; |
| |
| proto = *(__le32 *)((struct smb_hdr *)work->request_buf)->Protocol; |
| if (proto == SMB1_PROTO_NUMBER) |
| init_smb1_server(conn); |
| else |
| init_smb3_11_server(conn); |
| } |
| |
| int ksmbd_populate_dot_dotdot_entries(struct ksmbd_work *work, int info_level, |
| struct ksmbd_file *dir, |
| struct ksmbd_dir_info *d_info, |
| char *search_pattern, |
| int (*fn)(struct ksmbd_conn *, int, |
| struct ksmbd_dir_info *, |
| struct ksmbd_kstat *)) |
| { |
| int i, rc = 0; |
| struct ksmbd_conn *conn = work->conn; |
| struct mnt_idmap *idmap = file_mnt_idmap(dir->filp); |
| |
| for (i = 0; i < 2; i++) { |
| struct kstat kstat; |
| struct ksmbd_kstat ksmbd_kstat; |
| struct dentry *dentry; |
| |
| if (!dir->dot_dotdot[i]) { /* fill dot entry info */ |
| if (i == 0) { |
| d_info->name = "."; |
| d_info->name_len = 1; |
| dentry = dir->filp->f_path.dentry; |
| } else { |
| d_info->name = ".."; |
| d_info->name_len = 2; |
| dentry = dir->filp->f_path.dentry->d_parent; |
| } |
| |
| if (!match_pattern(d_info->name, d_info->name_len, |
| search_pattern)) { |
| dir->dot_dotdot[i] = 1; |
| continue; |
| } |
| |
| ksmbd_kstat.kstat = &kstat; |
| ksmbd_vfs_fill_dentry_attrs(work, |
| idmap, |
| dentry, |
| &ksmbd_kstat); |
| rc = fn(conn, info_level, d_info, &ksmbd_kstat); |
| if (rc) |
| break; |
| if (d_info->out_buf_len <= 0) |
| break; |
| |
| dir->dot_dotdot[i] = 1; |
| if (d_info->flags & SMB2_RETURN_SINGLE_ENTRY) { |
| d_info->out_buf_len = 0; |
| break; |
| } |
| } |
| } |
| |
| return rc; |
| } |
| |
| /** |
| * ksmbd_extract_shortname() - get shortname from long filename |
| * @conn: connection instance |
| * @longname: source long filename |
| * @shortname: destination short filename |
| * |
| * Return: shortname length or 0 when source long name is '.' or '..' |
| * TODO: Though this function comforms the restriction of 8.3 Filename spec, |
| * but the result is different with Windows 7's one. need to check. |
| */ |
| int ksmbd_extract_shortname(struct ksmbd_conn *conn, const char *longname, |
| char *shortname) |
| { |
| const char *p; |
| char base[9], extension[4]; |
| char out[13] = {0}; |
| int baselen = 0; |
| int extlen = 0, len = 0; |
| unsigned int csum = 0; |
| const unsigned char *ptr; |
| bool dot_present = true; |
| |
| p = longname; |
| if ((*p == '.') || (!(strcmp(p, "..")))) { |
| /*no mangling required */ |
| return 0; |
| } |
| |
| p = strrchr(longname, '.'); |
| if (p == longname) { /*name starts with a dot*/ |
| strscpy(extension, "___", strlen("___")); |
| } else { |
| if (p) { |
| p++; |
| while (*p && extlen < 3) { |
| if (*p != '.') |
| extension[extlen++] = toupper(*p); |
| p++; |
| } |
| extension[extlen] = '\0'; |
| } else { |
| dot_present = false; |
| } |
| } |
| |
| p = longname; |
| if (*p == '.') { |
| p++; |
| longname++; |
| } |
| while (*p && (baselen < 5)) { |
| if (*p != '.') |
| base[baselen++] = toupper(*p); |
| p++; |
| } |
| |
| base[baselen] = MAGIC_CHAR; |
| memcpy(out, base, baselen + 1); |
| |
| ptr = longname; |
| len = strlen(longname); |
| for (; len > 0; len--, ptr++) |
| csum += *ptr; |
| |
| csum = csum % (MANGLE_BASE * MANGLE_BASE); |
| out[baselen + 1] = mangle(csum / MANGLE_BASE); |
| out[baselen + 2] = mangle(csum); |
| out[baselen + 3] = PERIOD; |
| |
| if (dot_present) |
| memcpy(&out[baselen + 4], extension, 4); |
| else |
| out[baselen + 4] = '\0'; |
| smbConvertToUTF16((__le16 *)shortname, out, PATH_MAX, |
| conn->local_nls, 0); |
| len = strlen(out) * 2; |
| return len; |
| } |
| |
| static int __smb2_negotiate(struct ksmbd_conn *conn) |
| { |
| return (conn->dialect >= SMB20_PROT_ID && |
| conn->dialect <= SMB311_PROT_ID); |
| } |
| |
| static int smb_handle_negotiate(struct ksmbd_work *work) |
| { |
| struct smb_negotiate_rsp *neg_rsp = work->response_buf; |
| |
| ksmbd_debug(SMB, "Unsupported SMB1 protocol\n"); |
| |
| /* Add 2 byte bcc and 2 byte DialectIndex. */ |
| inc_rfc1001_len(work->response_buf, 4); |
| neg_rsp->hdr.Status.CifsError = STATUS_SUCCESS; |
| |
| neg_rsp->hdr.WordCount = 1; |
| neg_rsp->DialectIndex = cpu_to_le16(work->conn->dialect); |
| neg_rsp->ByteCount = 0; |
| return 0; |
| } |
| |
| int ksmbd_smb_negotiate_common(struct ksmbd_work *work, unsigned int command) |
| { |
| struct ksmbd_conn *conn = work->conn; |
| int ret; |
| |
| conn->dialect = |
| ksmbd_negotiate_smb_dialect(work->request_buf); |
| ksmbd_debug(SMB, "conn->dialect 0x%x\n", conn->dialect); |
| |
| if (command == SMB2_NEGOTIATE_HE) { |
| ret = smb2_handle_negotiate(work); |
| return ret; |
| } |
| |
| if (command == SMB_COM_NEGOTIATE) { |
| if (__smb2_negotiate(conn)) { |
| init_smb3_11_server(conn); |
| init_smb2_neg_rsp(work); |
| ksmbd_debug(SMB, "Upgrade to SMB2 negotiation\n"); |
| return 0; |
| } |
| return smb_handle_negotiate(work); |
| } |
| |
| pr_err("Unknown SMB negotiation command: %u\n", command); |
| return -EINVAL; |
| } |
| |
| enum SHARED_MODE_ERRORS { |
| SHARE_DELETE_ERROR, |
| SHARE_READ_ERROR, |
| SHARE_WRITE_ERROR, |
| FILE_READ_ERROR, |
| FILE_WRITE_ERROR, |
| FILE_DELETE_ERROR, |
| }; |
| |
| static const char * const shared_mode_errors[] = { |
| "Current access mode does not permit SHARE_DELETE", |
| "Current access mode does not permit SHARE_READ", |
| "Current access mode does not permit SHARE_WRITE", |
| "Desired access mode does not permit FILE_READ", |
| "Desired access mode does not permit FILE_WRITE", |
| "Desired access mode does not permit FILE_DELETE", |
| }; |
| |
| static void smb_shared_mode_error(int error, struct ksmbd_file *prev_fp, |
| struct ksmbd_file *curr_fp) |
| { |
| ksmbd_debug(SMB, "%s\n", shared_mode_errors[error]); |
| ksmbd_debug(SMB, "Current mode: 0x%x Desired mode: 0x%x\n", |
| prev_fp->saccess, curr_fp->daccess); |
| } |
| |
| int ksmbd_smb_check_shared_mode(struct file *filp, struct ksmbd_file *curr_fp) |
| { |
| int rc = 0; |
| struct ksmbd_file *prev_fp; |
| |
| /* |
| * Lookup fp in master fp list, and check desired access and |
| * shared mode between previous open and current open. |
| */ |
| read_lock(&curr_fp->f_ci->m_lock); |
| list_for_each_entry(prev_fp, &curr_fp->f_ci->m_fp_list, node) { |
| if (file_inode(filp) != file_inode(prev_fp->filp)) |
| continue; |
| |
| if (filp == prev_fp->filp) |
| continue; |
| |
| if (ksmbd_stream_fd(prev_fp) && ksmbd_stream_fd(curr_fp)) |
| if (strcmp(prev_fp->stream.name, curr_fp->stream.name)) |
| continue; |
| |
| if (prev_fp->attrib_only != curr_fp->attrib_only) |
| continue; |
| |
| if (!(prev_fp->saccess & FILE_SHARE_DELETE_LE) && |
| curr_fp->daccess & FILE_DELETE_LE) { |
| smb_shared_mode_error(SHARE_DELETE_ERROR, |
| prev_fp, |
| curr_fp); |
| rc = -EPERM; |
| break; |
| } |
| |
| /* |
| * Only check FILE_SHARE_DELETE if stream opened and |
| * normal file opened. |
| */ |
| if (ksmbd_stream_fd(prev_fp) && !ksmbd_stream_fd(curr_fp)) |
| continue; |
| |
| if (!(prev_fp->saccess & FILE_SHARE_READ_LE) && |
| curr_fp->daccess & (FILE_EXECUTE_LE | FILE_READ_DATA_LE)) { |
| smb_shared_mode_error(SHARE_READ_ERROR, |
| prev_fp, |
| curr_fp); |
| rc = -EPERM; |
| break; |
| } |
| |
| if (!(prev_fp->saccess & FILE_SHARE_WRITE_LE) && |
| curr_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE)) { |
| smb_shared_mode_error(SHARE_WRITE_ERROR, |
| prev_fp, |
| curr_fp); |
| rc = -EPERM; |
| break; |
| } |
| |
| if (prev_fp->daccess & (FILE_EXECUTE_LE | FILE_READ_DATA_LE) && |
| !(curr_fp->saccess & FILE_SHARE_READ_LE)) { |
| smb_shared_mode_error(FILE_READ_ERROR, |
| prev_fp, |
| curr_fp); |
| rc = -EPERM; |
| break; |
| } |
| |
| if (prev_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE) && |
| !(curr_fp->saccess & FILE_SHARE_WRITE_LE)) { |
| smb_shared_mode_error(FILE_WRITE_ERROR, |
| prev_fp, |
| curr_fp); |
| rc = -EPERM; |
| break; |
| } |
| |
| if (prev_fp->daccess & FILE_DELETE_LE && |
| !(curr_fp->saccess & FILE_SHARE_DELETE_LE)) { |
| smb_shared_mode_error(FILE_DELETE_ERROR, |
| prev_fp, |
| curr_fp); |
| rc = -EPERM; |
| break; |
| } |
| } |
| read_unlock(&curr_fp->f_ci->m_lock); |
| |
| return rc; |
| } |
| |
| bool is_asterisk(char *p) |
| { |
| return p && p[0] == '*'; |
| } |
| |
| int ksmbd_override_fsids(struct ksmbd_work *work) |
| { |
| struct ksmbd_session *sess = work->sess; |
| struct ksmbd_share_config *share = work->tcon->share_conf; |
| struct cred *cred; |
| struct group_info *gi; |
| unsigned int uid; |
| unsigned int gid; |
| |
| uid = user_uid(sess->user); |
| gid = user_gid(sess->user); |
| if (share->force_uid != KSMBD_SHARE_INVALID_UID) |
| uid = share->force_uid; |
| if (share->force_gid != KSMBD_SHARE_INVALID_GID) |
| gid = share->force_gid; |
| |
| cred = prepare_kernel_cred(&init_task); |
| if (!cred) |
| return -ENOMEM; |
| |
| cred->fsuid = make_kuid(&init_user_ns, uid); |
| cred->fsgid = make_kgid(&init_user_ns, gid); |
| |
| gi = groups_alloc(0); |
| if (!gi) { |
| abort_creds(cred); |
| return -ENOMEM; |
| } |
| set_groups(cred, gi); |
| put_group_info(gi); |
| |
| if (!uid_eq(cred->fsuid, GLOBAL_ROOT_UID)) |
| cred->cap_effective = cap_drop_fs_set(cred->cap_effective); |
| |
| WARN_ON(work->saved_cred); |
| work->saved_cred = override_creds(cred); |
| if (!work->saved_cred) { |
| abort_creds(cred); |
| return -EINVAL; |
| } |
| return 0; |
| } |
| |
| void ksmbd_revert_fsids(struct ksmbd_work *work) |
| { |
| const struct cred *cred; |
| |
| WARN_ON(!work->saved_cred); |
| |
| cred = current_cred(); |
| revert_creds(work->saved_cred); |
| put_cred(cred); |
| work->saved_cred = NULL; |
| } |
| |
| __le32 smb_map_generic_desired_access(__le32 daccess) |
| { |
| if (daccess & FILE_GENERIC_READ_LE) { |
| daccess |= cpu_to_le32(GENERIC_READ_FLAGS); |
| daccess &= ~FILE_GENERIC_READ_LE; |
| } |
| |
| if (daccess & FILE_GENERIC_WRITE_LE) { |
| daccess |= cpu_to_le32(GENERIC_WRITE_FLAGS); |
| daccess &= ~FILE_GENERIC_WRITE_LE; |
| } |
| |
| if (daccess & FILE_GENERIC_EXECUTE_LE) { |
| daccess |= cpu_to_le32(GENERIC_EXECUTE_FLAGS); |
| daccess &= ~FILE_GENERIC_EXECUTE_LE; |
| } |
| |
| if (daccess & FILE_GENERIC_ALL_LE) { |
| daccess |= cpu_to_le32(GENERIC_ALL_FLAGS); |
| daccess &= ~FILE_GENERIC_ALL_LE; |
| } |
| |
| return daccess; |
| } |