138c8a9a5SSteve French // SPDX-License-Identifier: GPL-2.0-or-later 238c8a9a5SSteve French /* 338c8a9a5SSteve French * Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org> 438c8a9a5SSteve French * Copyright (C) 2018 Samsung Electronics Co., Ltd. 538c8a9a5SSteve French */ 638c8a9a5SSteve French 738c8a9a5SSteve French #include <linux/inetdevice.h> 838c8a9a5SSteve French #include <net/addrconf.h> 938c8a9a5SSteve French #include <linux/syscalls.h> 1038c8a9a5SSteve French #include <linux/namei.h> 1138c8a9a5SSteve French #include <linux/statfs.h> 1238c8a9a5SSteve French #include <linux/ethtool.h> 1338c8a9a5SSteve French #include <linux/falloc.h> 1438c8a9a5SSteve French #include <linux/mount.h> 1538c8a9a5SSteve French #include <linux/filelock.h> 1638c8a9a5SSteve French 1738c8a9a5SSteve French #include "glob.h" 1838c8a9a5SSteve French #include "smbfsctl.h" 1938c8a9a5SSteve French #include "oplock.h" 2038c8a9a5SSteve French #include "smbacl.h" 2138c8a9a5SSteve French 2238c8a9a5SSteve French #include "auth.h" 2338c8a9a5SSteve French #include "asn1.h" 2438c8a9a5SSteve French #include "connection.h" 2538c8a9a5SSteve French #include "transport_ipc.h" 2638c8a9a5SSteve French #include "transport_rdma.h" 2738c8a9a5SSteve French #include "vfs.h" 2838c8a9a5SSteve French #include "vfs_cache.h" 2938c8a9a5SSteve French #include "misc.h" 3038c8a9a5SSteve French 3138c8a9a5SSteve French #include "server.h" 3238c8a9a5SSteve French #include "smb_common.h" 3338c8a9a5SSteve French #include "smbstatus.h" 3438c8a9a5SSteve French #include "ksmbd_work.h" 3538c8a9a5SSteve French #include "mgmt/user_config.h" 3638c8a9a5SSteve French #include "mgmt/share_config.h" 3738c8a9a5SSteve French #include "mgmt/tree_connect.h" 3838c8a9a5SSteve French #include "mgmt/user_session.h" 3938c8a9a5SSteve French #include "mgmt/ksmbd_ida.h" 4038c8a9a5SSteve French #include "ndr.h" 4138c8a9a5SSteve French 4238c8a9a5SSteve French static void __wbuf(struct ksmbd_work *work, void **req, void **rsp) 4338c8a9a5SSteve French { 4438c8a9a5SSteve French if (work->next_smb2_rcv_hdr_off) { 4538c8a9a5SSteve French *req = ksmbd_req_buf_next(work); 4638c8a9a5SSteve French *rsp = ksmbd_resp_buf_next(work); 4738c8a9a5SSteve French } else { 4838c8a9a5SSteve French *req = smb2_get_msg(work->request_buf); 4938c8a9a5SSteve French *rsp = smb2_get_msg(work->response_buf); 5038c8a9a5SSteve French } 5138c8a9a5SSteve French } 5238c8a9a5SSteve French 5338c8a9a5SSteve French #define WORK_BUFFERS(w, rq, rs) __wbuf((w), (void **)&(rq), (void **)&(rs)) 5438c8a9a5SSteve French 5538c8a9a5SSteve French /** 5638c8a9a5SSteve French * check_session_id() - check for valid session id in smb header 5738c8a9a5SSteve French * @conn: connection instance 5838c8a9a5SSteve French * @id: session id from smb header 5938c8a9a5SSteve French * 6038c8a9a5SSteve French * Return: 1 if valid session id, otherwise 0 6138c8a9a5SSteve French */ 6238c8a9a5SSteve French static inline bool check_session_id(struct ksmbd_conn *conn, u64 id) 6338c8a9a5SSteve French { 6438c8a9a5SSteve French struct ksmbd_session *sess; 6538c8a9a5SSteve French 6638c8a9a5SSteve French if (id == 0 || id == -1) 6738c8a9a5SSteve French return false; 6838c8a9a5SSteve French 6938c8a9a5SSteve French sess = ksmbd_session_lookup_all(conn, id); 7038c8a9a5SSteve French if (sess) 7138c8a9a5SSteve French return true; 7238c8a9a5SSteve French pr_err("Invalid user session id: %llu\n", id); 7338c8a9a5SSteve French return false; 7438c8a9a5SSteve French } 7538c8a9a5SSteve French 7638c8a9a5SSteve French struct channel *lookup_chann_list(struct ksmbd_session *sess, struct ksmbd_conn *conn) 7738c8a9a5SSteve French { 7838c8a9a5SSteve French return xa_load(&sess->ksmbd_chann_list, (long)conn); 7938c8a9a5SSteve French } 8038c8a9a5SSteve French 8138c8a9a5SSteve French /** 8238c8a9a5SSteve French * smb2_get_ksmbd_tcon() - get tree connection information using a tree id. 8338c8a9a5SSteve French * @work: smb work 8438c8a9a5SSteve French * 8538c8a9a5SSteve French * Return: 0 if there is a tree connection matched or these are 8638c8a9a5SSteve French * skipable commands, otherwise error 8738c8a9a5SSteve French */ 8838c8a9a5SSteve French int smb2_get_ksmbd_tcon(struct ksmbd_work *work) 8938c8a9a5SSteve French { 9038c8a9a5SSteve French struct smb2_hdr *req_hdr = smb2_get_msg(work->request_buf); 9138c8a9a5SSteve French unsigned int cmd = le16_to_cpu(req_hdr->Command); 9238c8a9a5SSteve French int tree_id; 9338c8a9a5SSteve French 9438c8a9a5SSteve French if (cmd == SMB2_TREE_CONNECT_HE || 9538c8a9a5SSteve French cmd == SMB2_CANCEL_HE || 9638c8a9a5SSteve French cmd == SMB2_LOGOFF_HE) { 9738c8a9a5SSteve French ksmbd_debug(SMB, "skip to check tree connect request\n"); 9838c8a9a5SSteve French return 0; 9938c8a9a5SSteve French } 10038c8a9a5SSteve French 10138c8a9a5SSteve French if (xa_empty(&work->sess->tree_conns)) { 10238c8a9a5SSteve French ksmbd_debug(SMB, "NO tree connected\n"); 10338c8a9a5SSteve French return -ENOENT; 10438c8a9a5SSteve French } 10538c8a9a5SSteve French 10638c8a9a5SSteve French tree_id = le32_to_cpu(req_hdr->Id.SyncId.TreeId); 1075005bcb4SNamjae Jeon 1085005bcb4SNamjae Jeon /* 1095005bcb4SNamjae Jeon * If request is not the first in Compound request, 1105005bcb4SNamjae Jeon * Just validate tree id in header with work->tcon->id. 1115005bcb4SNamjae Jeon */ 1125005bcb4SNamjae Jeon if (work->next_smb2_rcv_hdr_off) { 1135005bcb4SNamjae Jeon if (!work->tcon) { 1145005bcb4SNamjae Jeon pr_err("The first operation in the compound does not have tcon\n"); 1155005bcb4SNamjae Jeon return -EINVAL; 1165005bcb4SNamjae Jeon } 1175005bcb4SNamjae Jeon if (work->tcon->id != tree_id) { 1185005bcb4SNamjae Jeon pr_err("tree id(%u) is different with id(%u) in first operation\n", 1195005bcb4SNamjae Jeon tree_id, work->tcon->id); 1205005bcb4SNamjae Jeon return -EINVAL; 1215005bcb4SNamjae Jeon } 1225005bcb4SNamjae Jeon return 1; 1235005bcb4SNamjae Jeon } 1245005bcb4SNamjae Jeon 12538c8a9a5SSteve French work->tcon = ksmbd_tree_conn_lookup(work->sess, tree_id); 12638c8a9a5SSteve French if (!work->tcon) { 12738c8a9a5SSteve French pr_err("Invalid tid %d\n", tree_id); 1285005bcb4SNamjae Jeon return -ENOENT; 12938c8a9a5SSteve French } 13038c8a9a5SSteve French 13138c8a9a5SSteve French return 1; 13238c8a9a5SSteve French } 13338c8a9a5SSteve French 13438c8a9a5SSteve French /** 13538c8a9a5SSteve French * smb2_set_err_rsp() - set error response code on smb response 13638c8a9a5SSteve French * @work: smb work containing response buffer 13738c8a9a5SSteve French */ 13838c8a9a5SSteve French void smb2_set_err_rsp(struct ksmbd_work *work) 13938c8a9a5SSteve French { 14038c8a9a5SSteve French struct smb2_err_rsp *err_rsp; 14138c8a9a5SSteve French 14238c8a9a5SSteve French if (work->next_smb2_rcv_hdr_off) 14338c8a9a5SSteve French err_rsp = ksmbd_resp_buf_next(work); 14438c8a9a5SSteve French else 14538c8a9a5SSteve French err_rsp = smb2_get_msg(work->response_buf); 14638c8a9a5SSteve French 14738c8a9a5SSteve French if (err_rsp->hdr.Status != STATUS_STOPPED_ON_SYMLINK) { 14838c8a9a5SSteve French err_rsp->StructureSize = SMB2_ERROR_STRUCTURE_SIZE2_LE; 14938c8a9a5SSteve French err_rsp->ErrorContextCount = 0; 15038c8a9a5SSteve French err_rsp->Reserved = 0; 15138c8a9a5SSteve French err_rsp->ByteCount = 0; 15238c8a9a5SSteve French err_rsp->ErrorData[0] = 0; 15338c8a9a5SSteve French inc_rfc1001_len(work->response_buf, SMB2_ERROR_STRUCTURE_SIZE2); 15438c8a9a5SSteve French } 15538c8a9a5SSteve French } 15638c8a9a5SSteve French 15738c8a9a5SSteve French /** 15838c8a9a5SSteve French * is_smb2_neg_cmd() - is it smb2 negotiation command 15938c8a9a5SSteve French * @work: smb work containing smb header 16038c8a9a5SSteve French * 16138c8a9a5SSteve French * Return: true if smb2 negotiation command, otherwise false 16238c8a9a5SSteve French */ 16338c8a9a5SSteve French bool is_smb2_neg_cmd(struct ksmbd_work *work) 16438c8a9a5SSteve French { 16538c8a9a5SSteve French struct smb2_hdr *hdr = smb2_get_msg(work->request_buf); 16638c8a9a5SSteve French 16738c8a9a5SSteve French /* is it SMB2 header ? */ 16838c8a9a5SSteve French if (hdr->ProtocolId != SMB2_PROTO_NUMBER) 16938c8a9a5SSteve French return false; 17038c8a9a5SSteve French 17138c8a9a5SSteve French /* make sure it is request not response message */ 17238c8a9a5SSteve French if (hdr->Flags & SMB2_FLAGS_SERVER_TO_REDIR) 17338c8a9a5SSteve French return false; 17438c8a9a5SSteve French 17538c8a9a5SSteve French if (hdr->Command != SMB2_NEGOTIATE) 17638c8a9a5SSteve French return false; 17738c8a9a5SSteve French 17838c8a9a5SSteve French return true; 17938c8a9a5SSteve French } 18038c8a9a5SSteve French 18138c8a9a5SSteve French /** 18238c8a9a5SSteve French * is_smb2_rsp() - is it smb2 response 18338c8a9a5SSteve French * @work: smb work containing smb response buffer 18438c8a9a5SSteve French * 18538c8a9a5SSteve French * Return: true if smb2 response, otherwise false 18638c8a9a5SSteve French */ 18738c8a9a5SSteve French bool is_smb2_rsp(struct ksmbd_work *work) 18838c8a9a5SSteve French { 18938c8a9a5SSteve French struct smb2_hdr *hdr = smb2_get_msg(work->response_buf); 19038c8a9a5SSteve French 19138c8a9a5SSteve French /* is it SMB2 header ? */ 19238c8a9a5SSteve French if (hdr->ProtocolId != SMB2_PROTO_NUMBER) 19338c8a9a5SSteve French return false; 19438c8a9a5SSteve French 19538c8a9a5SSteve French /* make sure it is response not request message */ 19638c8a9a5SSteve French if (!(hdr->Flags & SMB2_FLAGS_SERVER_TO_REDIR)) 19738c8a9a5SSteve French return false; 19838c8a9a5SSteve French 19938c8a9a5SSteve French return true; 20038c8a9a5SSteve French } 20138c8a9a5SSteve French 20238c8a9a5SSteve French /** 20338c8a9a5SSteve French * get_smb2_cmd_val() - get smb command code from smb header 20438c8a9a5SSteve French * @work: smb work containing smb request buffer 20538c8a9a5SSteve French * 20638c8a9a5SSteve French * Return: smb2 request command value 20738c8a9a5SSteve French */ 20838c8a9a5SSteve French u16 get_smb2_cmd_val(struct ksmbd_work *work) 20938c8a9a5SSteve French { 21038c8a9a5SSteve French struct smb2_hdr *rcv_hdr; 21138c8a9a5SSteve French 21238c8a9a5SSteve French if (work->next_smb2_rcv_hdr_off) 21338c8a9a5SSteve French rcv_hdr = ksmbd_req_buf_next(work); 21438c8a9a5SSteve French else 21538c8a9a5SSteve French rcv_hdr = smb2_get_msg(work->request_buf); 21638c8a9a5SSteve French return le16_to_cpu(rcv_hdr->Command); 21738c8a9a5SSteve French } 21838c8a9a5SSteve French 21938c8a9a5SSteve French /** 22038c8a9a5SSteve French * set_smb2_rsp_status() - set error response code on smb2 header 22138c8a9a5SSteve French * @work: smb work containing response buffer 22238c8a9a5SSteve French * @err: error response code 22338c8a9a5SSteve French */ 22438c8a9a5SSteve French void set_smb2_rsp_status(struct ksmbd_work *work, __le32 err) 22538c8a9a5SSteve French { 22638c8a9a5SSteve French struct smb2_hdr *rsp_hdr; 22738c8a9a5SSteve French 22838c8a9a5SSteve French if (work->next_smb2_rcv_hdr_off) 22938c8a9a5SSteve French rsp_hdr = ksmbd_resp_buf_next(work); 23038c8a9a5SSteve French else 23138c8a9a5SSteve French rsp_hdr = smb2_get_msg(work->response_buf); 23238c8a9a5SSteve French rsp_hdr->Status = err; 23338c8a9a5SSteve French smb2_set_err_rsp(work); 23438c8a9a5SSteve French } 23538c8a9a5SSteve French 23638c8a9a5SSteve French /** 23738c8a9a5SSteve French * init_smb2_neg_rsp() - initialize smb2 response for negotiate command 23838c8a9a5SSteve French * @work: smb work containing smb request buffer 23938c8a9a5SSteve French * 24038c8a9a5SSteve French * smb2 negotiate response is sent in reply of smb1 negotiate command for 24138c8a9a5SSteve French * dialect auto-negotiation. 24238c8a9a5SSteve French */ 24338c8a9a5SSteve French int init_smb2_neg_rsp(struct ksmbd_work *work) 24438c8a9a5SSteve French { 24538c8a9a5SSteve French struct smb2_hdr *rsp_hdr; 24638c8a9a5SSteve French struct smb2_negotiate_rsp *rsp; 24738c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 24838c8a9a5SSteve French 24938c8a9a5SSteve French *(__be32 *)work->response_buf = 25038c8a9a5SSteve French cpu_to_be32(conn->vals->header_size); 25138c8a9a5SSteve French 25238c8a9a5SSteve French rsp_hdr = smb2_get_msg(work->response_buf); 25338c8a9a5SSteve French memset(rsp_hdr, 0, sizeof(struct smb2_hdr) + 2); 25438c8a9a5SSteve French rsp_hdr->ProtocolId = SMB2_PROTO_NUMBER; 25538c8a9a5SSteve French rsp_hdr->StructureSize = SMB2_HEADER_STRUCTURE_SIZE; 25638c8a9a5SSteve French rsp_hdr->CreditRequest = cpu_to_le16(2); 25738c8a9a5SSteve French rsp_hdr->Command = SMB2_NEGOTIATE; 25838c8a9a5SSteve French rsp_hdr->Flags = (SMB2_FLAGS_SERVER_TO_REDIR); 25938c8a9a5SSteve French rsp_hdr->NextCommand = 0; 26038c8a9a5SSteve French rsp_hdr->MessageId = 0; 26138c8a9a5SSteve French rsp_hdr->Id.SyncId.ProcessId = 0; 26238c8a9a5SSteve French rsp_hdr->Id.SyncId.TreeId = 0; 26338c8a9a5SSteve French rsp_hdr->SessionId = 0; 26438c8a9a5SSteve French memset(rsp_hdr->Signature, 0, 16); 26538c8a9a5SSteve French 26638c8a9a5SSteve French rsp = smb2_get_msg(work->response_buf); 26738c8a9a5SSteve French 26838c8a9a5SSteve French WARN_ON(ksmbd_conn_good(conn)); 26938c8a9a5SSteve French 27038c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(65); 27138c8a9a5SSteve French ksmbd_debug(SMB, "conn->dialect 0x%x\n", conn->dialect); 27238c8a9a5SSteve French rsp->DialectRevision = cpu_to_le16(conn->dialect); 27338c8a9a5SSteve French /* Not setting conn guid rsp->ServerGUID, as it 27438c8a9a5SSteve French * not used by client for identifying connection 27538c8a9a5SSteve French */ 27638c8a9a5SSteve French rsp->Capabilities = cpu_to_le32(conn->vals->capabilities); 27738c8a9a5SSteve French /* Default Max Message Size till SMB2.0, 64K*/ 27838c8a9a5SSteve French rsp->MaxTransactSize = cpu_to_le32(conn->vals->max_trans_size); 27938c8a9a5SSteve French rsp->MaxReadSize = cpu_to_le32(conn->vals->max_read_size); 28038c8a9a5SSteve French rsp->MaxWriteSize = cpu_to_le32(conn->vals->max_write_size); 28138c8a9a5SSteve French 28238c8a9a5SSteve French rsp->SystemTime = cpu_to_le64(ksmbd_systime()); 28338c8a9a5SSteve French rsp->ServerStartTime = 0; 28438c8a9a5SSteve French 28538c8a9a5SSteve French rsp->SecurityBufferOffset = cpu_to_le16(128); 28638c8a9a5SSteve French rsp->SecurityBufferLength = cpu_to_le16(AUTH_GSS_LENGTH); 28738c8a9a5SSteve French ksmbd_copy_gss_neg_header((char *)(&rsp->hdr) + 28838c8a9a5SSteve French le16_to_cpu(rsp->SecurityBufferOffset)); 28938c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 29038c8a9a5SSteve French sizeof(struct smb2_negotiate_rsp) - 29138c8a9a5SSteve French sizeof(struct smb2_hdr) + AUTH_GSS_LENGTH); 29238c8a9a5SSteve French rsp->SecurityMode = SMB2_NEGOTIATE_SIGNING_ENABLED_LE; 29338c8a9a5SSteve French if (server_conf.signing == KSMBD_CONFIG_OPT_MANDATORY) 29438c8a9a5SSteve French rsp->SecurityMode |= SMB2_NEGOTIATE_SIGNING_REQUIRED_LE; 29538c8a9a5SSteve French conn->use_spnego = true; 29638c8a9a5SSteve French 29738c8a9a5SSteve French ksmbd_conn_set_need_negotiate(conn); 29838c8a9a5SSteve French return 0; 29938c8a9a5SSteve French } 30038c8a9a5SSteve French 30138c8a9a5SSteve French /** 30238c8a9a5SSteve French * smb2_set_rsp_credits() - set number of credits in response buffer 30338c8a9a5SSteve French * @work: smb work containing smb response buffer 30438c8a9a5SSteve French */ 30538c8a9a5SSteve French int smb2_set_rsp_credits(struct ksmbd_work *work) 30638c8a9a5SSteve French { 30738c8a9a5SSteve French struct smb2_hdr *req_hdr = ksmbd_req_buf_next(work); 30838c8a9a5SSteve French struct smb2_hdr *hdr = ksmbd_resp_buf_next(work); 30938c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 31038c8a9a5SSteve French unsigned short credits_requested, aux_max; 31138c8a9a5SSteve French unsigned short credit_charge, credits_granted = 0; 31238c8a9a5SSteve French 31338c8a9a5SSteve French if (work->send_no_response) 31438c8a9a5SSteve French return 0; 31538c8a9a5SSteve French 31638c8a9a5SSteve French hdr->CreditCharge = req_hdr->CreditCharge; 31738c8a9a5SSteve French 31838c8a9a5SSteve French if (conn->total_credits > conn->vals->max_credits) { 31938c8a9a5SSteve French hdr->CreditRequest = 0; 32038c8a9a5SSteve French pr_err("Total credits overflow: %d\n", conn->total_credits); 32138c8a9a5SSteve French return -EINVAL; 32238c8a9a5SSteve French } 32338c8a9a5SSteve French 32438c8a9a5SSteve French credit_charge = max_t(unsigned short, 32538c8a9a5SSteve French le16_to_cpu(req_hdr->CreditCharge), 1); 32638c8a9a5SSteve French if (credit_charge > conn->total_credits) { 32738c8a9a5SSteve French ksmbd_debug(SMB, "Insufficient credits granted, given: %u, granted: %u\n", 32838c8a9a5SSteve French credit_charge, conn->total_credits); 32938c8a9a5SSteve French return -EINVAL; 33038c8a9a5SSteve French } 33138c8a9a5SSteve French 33238c8a9a5SSteve French conn->total_credits -= credit_charge; 33338c8a9a5SSteve French conn->outstanding_credits -= credit_charge; 33438c8a9a5SSteve French credits_requested = max_t(unsigned short, 33538c8a9a5SSteve French le16_to_cpu(req_hdr->CreditRequest), 1); 33638c8a9a5SSteve French 33738c8a9a5SSteve French /* according to smb2.credits smbtorture, Windows server 33838c8a9a5SSteve French * 2016 or later grant up to 8192 credits at once. 33938c8a9a5SSteve French * 34038c8a9a5SSteve French * TODO: Need to adjuct CreditRequest value according to 34138c8a9a5SSteve French * current cpu load 34238c8a9a5SSteve French */ 34338c8a9a5SSteve French if (hdr->Command == SMB2_NEGOTIATE) 34438c8a9a5SSteve French aux_max = 1; 34538c8a9a5SSteve French else 34684c5aa47SNamjae Jeon aux_max = conn->vals->max_credits - conn->total_credits; 34738c8a9a5SSteve French credits_granted = min_t(unsigned short, credits_requested, aux_max); 34838c8a9a5SSteve French 34938c8a9a5SSteve French conn->total_credits += credits_granted; 35038c8a9a5SSteve French work->credits_granted += credits_granted; 35138c8a9a5SSteve French 35238c8a9a5SSteve French if (!req_hdr->NextCommand) { 35338c8a9a5SSteve French /* Update CreditRequest in last request */ 35438c8a9a5SSteve French hdr->CreditRequest = cpu_to_le16(work->credits_granted); 35538c8a9a5SSteve French } 35638c8a9a5SSteve French ksmbd_debug(SMB, 35738c8a9a5SSteve French "credits: requested[%d] granted[%d] total_granted[%d]\n", 35838c8a9a5SSteve French credits_requested, credits_granted, 35938c8a9a5SSteve French conn->total_credits); 36038c8a9a5SSteve French return 0; 36138c8a9a5SSteve French } 36238c8a9a5SSteve French 36338c8a9a5SSteve French /** 36438c8a9a5SSteve French * init_chained_smb2_rsp() - initialize smb2 chained response 36538c8a9a5SSteve French * @work: smb work containing smb response buffer 36638c8a9a5SSteve French */ 36738c8a9a5SSteve French static void init_chained_smb2_rsp(struct ksmbd_work *work) 36838c8a9a5SSteve French { 36938c8a9a5SSteve French struct smb2_hdr *req = ksmbd_req_buf_next(work); 37038c8a9a5SSteve French struct smb2_hdr *rsp = ksmbd_resp_buf_next(work); 37138c8a9a5SSteve French struct smb2_hdr *rsp_hdr; 37238c8a9a5SSteve French struct smb2_hdr *rcv_hdr; 37338c8a9a5SSteve French int next_hdr_offset = 0; 37438c8a9a5SSteve French int len, new_len; 37538c8a9a5SSteve French 37638c8a9a5SSteve French /* Len of this response = updated RFC len - offset of previous cmd 37738c8a9a5SSteve French * in the compound rsp 37838c8a9a5SSteve French */ 37938c8a9a5SSteve French 38038c8a9a5SSteve French /* Storing the current local FID which may be needed by subsequent 38138c8a9a5SSteve French * command in the compound request 38238c8a9a5SSteve French */ 38338c8a9a5SSteve French if (req->Command == SMB2_CREATE && rsp->Status == STATUS_SUCCESS) { 38438c8a9a5SSteve French work->compound_fid = ((struct smb2_create_rsp *)rsp)->VolatileFileId; 38538c8a9a5SSteve French work->compound_pfid = ((struct smb2_create_rsp *)rsp)->PersistentFileId; 38638c8a9a5SSteve French work->compound_sid = le64_to_cpu(rsp->SessionId); 38738c8a9a5SSteve French } 38838c8a9a5SSteve French 38938c8a9a5SSteve French len = get_rfc1002_len(work->response_buf) - work->next_smb2_rsp_hdr_off; 39038c8a9a5SSteve French next_hdr_offset = le32_to_cpu(req->NextCommand); 39138c8a9a5SSteve French 39238c8a9a5SSteve French new_len = ALIGN(len, 8); 39338c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 39438c8a9a5SSteve French sizeof(struct smb2_hdr) + new_len - len); 39538c8a9a5SSteve French rsp->NextCommand = cpu_to_le32(new_len); 39638c8a9a5SSteve French 39738c8a9a5SSteve French work->next_smb2_rcv_hdr_off += next_hdr_offset; 39838c8a9a5SSteve French work->next_smb2_rsp_hdr_off += new_len; 39938c8a9a5SSteve French ksmbd_debug(SMB, 40038c8a9a5SSteve French "Compound req new_len = %d rcv off = %d rsp off = %d\n", 40138c8a9a5SSteve French new_len, work->next_smb2_rcv_hdr_off, 40238c8a9a5SSteve French work->next_smb2_rsp_hdr_off); 40338c8a9a5SSteve French 40438c8a9a5SSteve French rsp_hdr = ksmbd_resp_buf_next(work); 40538c8a9a5SSteve French rcv_hdr = ksmbd_req_buf_next(work); 40638c8a9a5SSteve French 40738c8a9a5SSteve French if (!(rcv_hdr->Flags & SMB2_FLAGS_RELATED_OPERATIONS)) { 40838c8a9a5SSteve French ksmbd_debug(SMB, "related flag should be set\n"); 40938c8a9a5SSteve French work->compound_fid = KSMBD_NO_FID; 41038c8a9a5SSteve French work->compound_pfid = KSMBD_NO_FID; 41138c8a9a5SSteve French } 41238c8a9a5SSteve French memset((char *)rsp_hdr, 0, sizeof(struct smb2_hdr) + 2); 41338c8a9a5SSteve French rsp_hdr->ProtocolId = SMB2_PROTO_NUMBER; 41438c8a9a5SSteve French rsp_hdr->StructureSize = SMB2_HEADER_STRUCTURE_SIZE; 41538c8a9a5SSteve French rsp_hdr->Command = rcv_hdr->Command; 41638c8a9a5SSteve French 41738c8a9a5SSteve French /* 41838c8a9a5SSteve French * Message is response. We don't grant oplock yet. 41938c8a9a5SSteve French */ 42038c8a9a5SSteve French rsp_hdr->Flags = (SMB2_FLAGS_SERVER_TO_REDIR | 42138c8a9a5SSteve French SMB2_FLAGS_RELATED_OPERATIONS); 42238c8a9a5SSteve French rsp_hdr->NextCommand = 0; 42338c8a9a5SSteve French rsp_hdr->MessageId = rcv_hdr->MessageId; 42438c8a9a5SSteve French rsp_hdr->Id.SyncId.ProcessId = rcv_hdr->Id.SyncId.ProcessId; 42538c8a9a5SSteve French rsp_hdr->Id.SyncId.TreeId = rcv_hdr->Id.SyncId.TreeId; 42638c8a9a5SSteve French rsp_hdr->SessionId = rcv_hdr->SessionId; 42738c8a9a5SSteve French memcpy(rsp_hdr->Signature, rcv_hdr->Signature, 16); 42838c8a9a5SSteve French } 42938c8a9a5SSteve French 43038c8a9a5SSteve French /** 43138c8a9a5SSteve French * is_chained_smb2_message() - check for chained command 43238c8a9a5SSteve French * @work: smb work containing smb request buffer 43338c8a9a5SSteve French * 43438c8a9a5SSteve French * Return: true if chained request, otherwise false 43538c8a9a5SSteve French */ 43638c8a9a5SSteve French bool is_chained_smb2_message(struct ksmbd_work *work) 43738c8a9a5SSteve French { 43838c8a9a5SSteve French struct smb2_hdr *hdr = smb2_get_msg(work->request_buf); 43938c8a9a5SSteve French unsigned int len, next_cmd; 44038c8a9a5SSteve French 44138c8a9a5SSteve French if (hdr->ProtocolId != SMB2_PROTO_NUMBER) 44238c8a9a5SSteve French return false; 44338c8a9a5SSteve French 44438c8a9a5SSteve French hdr = ksmbd_req_buf_next(work); 44538c8a9a5SSteve French next_cmd = le32_to_cpu(hdr->NextCommand); 44638c8a9a5SSteve French if (next_cmd > 0) { 44738c8a9a5SSteve French if ((u64)work->next_smb2_rcv_hdr_off + next_cmd + 44838c8a9a5SSteve French __SMB2_HEADER_STRUCTURE_SIZE > 44938c8a9a5SSteve French get_rfc1002_len(work->request_buf)) { 45038c8a9a5SSteve French pr_err("next command(%u) offset exceeds smb msg size\n", 45138c8a9a5SSteve French next_cmd); 45238c8a9a5SSteve French return false; 45338c8a9a5SSteve French } 45438c8a9a5SSteve French 45538c8a9a5SSteve French if ((u64)get_rfc1002_len(work->response_buf) + MAX_CIFS_SMALL_BUFFER_SIZE > 45638c8a9a5SSteve French work->response_sz) { 45738c8a9a5SSteve French pr_err("next response offset exceeds response buffer size\n"); 45838c8a9a5SSteve French return false; 45938c8a9a5SSteve French } 46038c8a9a5SSteve French 46138c8a9a5SSteve French ksmbd_debug(SMB, "got SMB2 chained command\n"); 46238c8a9a5SSteve French init_chained_smb2_rsp(work); 46338c8a9a5SSteve French return true; 46438c8a9a5SSteve French } else if (work->next_smb2_rcv_hdr_off) { 46538c8a9a5SSteve French /* 46638c8a9a5SSteve French * This is last request in chained command, 46738c8a9a5SSteve French * align response to 8 byte 46838c8a9a5SSteve French */ 46938c8a9a5SSteve French len = ALIGN(get_rfc1002_len(work->response_buf), 8); 47038c8a9a5SSteve French len = len - get_rfc1002_len(work->response_buf); 47138c8a9a5SSteve French if (len) { 47238c8a9a5SSteve French ksmbd_debug(SMB, "padding len %u\n", len); 47338c8a9a5SSteve French inc_rfc1001_len(work->response_buf, len); 47438c8a9a5SSteve French if (work->aux_payload_sz) 47538c8a9a5SSteve French work->aux_payload_sz += len; 47638c8a9a5SSteve French } 47738c8a9a5SSteve French } 47838c8a9a5SSteve French return false; 47938c8a9a5SSteve French } 48038c8a9a5SSteve French 48138c8a9a5SSteve French /** 48238c8a9a5SSteve French * init_smb2_rsp_hdr() - initialize smb2 response 48338c8a9a5SSteve French * @work: smb work containing smb request buffer 48438c8a9a5SSteve French * 48538c8a9a5SSteve French * Return: 0 48638c8a9a5SSteve French */ 48738c8a9a5SSteve French int init_smb2_rsp_hdr(struct ksmbd_work *work) 48838c8a9a5SSteve French { 48938c8a9a5SSteve French struct smb2_hdr *rsp_hdr = smb2_get_msg(work->response_buf); 49038c8a9a5SSteve French struct smb2_hdr *rcv_hdr = smb2_get_msg(work->request_buf); 49138c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 49238c8a9a5SSteve French 49338c8a9a5SSteve French memset(rsp_hdr, 0, sizeof(struct smb2_hdr) + 2); 49438c8a9a5SSteve French *(__be32 *)work->response_buf = 49538c8a9a5SSteve French cpu_to_be32(conn->vals->header_size); 49638c8a9a5SSteve French rsp_hdr->ProtocolId = rcv_hdr->ProtocolId; 49738c8a9a5SSteve French rsp_hdr->StructureSize = SMB2_HEADER_STRUCTURE_SIZE; 49838c8a9a5SSteve French rsp_hdr->Command = rcv_hdr->Command; 49938c8a9a5SSteve French 50038c8a9a5SSteve French /* 50138c8a9a5SSteve French * Message is response. We don't grant oplock yet. 50238c8a9a5SSteve French */ 50338c8a9a5SSteve French rsp_hdr->Flags = (SMB2_FLAGS_SERVER_TO_REDIR); 50438c8a9a5SSteve French rsp_hdr->NextCommand = 0; 50538c8a9a5SSteve French rsp_hdr->MessageId = rcv_hdr->MessageId; 50638c8a9a5SSteve French rsp_hdr->Id.SyncId.ProcessId = rcv_hdr->Id.SyncId.ProcessId; 50738c8a9a5SSteve French rsp_hdr->Id.SyncId.TreeId = rcv_hdr->Id.SyncId.TreeId; 50838c8a9a5SSteve French rsp_hdr->SessionId = rcv_hdr->SessionId; 50938c8a9a5SSteve French memcpy(rsp_hdr->Signature, rcv_hdr->Signature, 16); 51038c8a9a5SSteve French 51138c8a9a5SSteve French return 0; 51238c8a9a5SSteve French } 51338c8a9a5SSteve French 51438c8a9a5SSteve French /** 51538c8a9a5SSteve French * smb2_allocate_rsp_buf() - allocate smb2 response buffer 51638c8a9a5SSteve French * @work: smb work containing smb request buffer 51738c8a9a5SSteve French * 51838c8a9a5SSteve French * Return: 0 on success, otherwise -ENOMEM 51938c8a9a5SSteve French */ 52038c8a9a5SSteve French int smb2_allocate_rsp_buf(struct ksmbd_work *work) 52138c8a9a5SSteve French { 52238c8a9a5SSteve French struct smb2_hdr *hdr = smb2_get_msg(work->request_buf); 52338c8a9a5SSteve French size_t small_sz = MAX_CIFS_SMALL_BUFFER_SIZE; 52438c8a9a5SSteve French size_t large_sz = small_sz + work->conn->vals->max_trans_size; 52538c8a9a5SSteve French size_t sz = small_sz; 52638c8a9a5SSteve French int cmd = le16_to_cpu(hdr->Command); 52738c8a9a5SSteve French 52838c8a9a5SSteve French if (cmd == SMB2_IOCTL_HE || cmd == SMB2_QUERY_DIRECTORY_HE) 52938c8a9a5SSteve French sz = large_sz; 53038c8a9a5SSteve French 53138c8a9a5SSteve French if (cmd == SMB2_QUERY_INFO_HE) { 53238c8a9a5SSteve French struct smb2_query_info_req *req; 53338c8a9a5SSteve French 53438c8a9a5SSteve French req = smb2_get_msg(work->request_buf); 53538c8a9a5SSteve French if ((req->InfoType == SMB2_O_INFO_FILE && 53638c8a9a5SSteve French (req->FileInfoClass == FILE_FULL_EA_INFORMATION || 53738c8a9a5SSteve French req->FileInfoClass == FILE_ALL_INFORMATION)) || 53838c8a9a5SSteve French req->InfoType == SMB2_O_INFO_SECURITY) 53938c8a9a5SSteve French sz = large_sz; 54038c8a9a5SSteve French } 54138c8a9a5SSteve French 54238c8a9a5SSteve French /* allocate large response buf for chained commands */ 54338c8a9a5SSteve French if (le32_to_cpu(hdr->NextCommand) > 0) 54438c8a9a5SSteve French sz = large_sz; 54538c8a9a5SSteve French 54681a94b27SNamjae Jeon work->response_buf = kvzalloc(sz, GFP_KERNEL); 54738c8a9a5SSteve French if (!work->response_buf) 54838c8a9a5SSteve French return -ENOMEM; 54938c8a9a5SSteve French 55038c8a9a5SSteve French work->response_sz = sz; 55138c8a9a5SSteve French return 0; 55238c8a9a5SSteve French } 55338c8a9a5SSteve French 55438c8a9a5SSteve French /** 55538c8a9a5SSteve French * smb2_check_user_session() - check for valid session for a user 55638c8a9a5SSteve French * @work: smb work containing smb request buffer 55738c8a9a5SSteve French * 55838c8a9a5SSteve French * Return: 0 on success, otherwise error 55938c8a9a5SSteve French */ 56038c8a9a5SSteve French int smb2_check_user_session(struct ksmbd_work *work) 56138c8a9a5SSteve French { 56238c8a9a5SSteve French struct smb2_hdr *req_hdr = smb2_get_msg(work->request_buf); 56338c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 56438c8a9a5SSteve French unsigned int cmd = conn->ops->get_cmd_val(work); 56538c8a9a5SSteve French unsigned long long sess_id; 56638c8a9a5SSteve French 56738c8a9a5SSteve French /* 56838c8a9a5SSteve French * SMB2_ECHO, SMB2_NEGOTIATE, SMB2_SESSION_SETUP command do not 56938c8a9a5SSteve French * require a session id, so no need to validate user session's for 57038c8a9a5SSteve French * these commands. 57138c8a9a5SSteve French */ 57238c8a9a5SSteve French if (cmd == SMB2_ECHO_HE || cmd == SMB2_NEGOTIATE_HE || 57338c8a9a5SSteve French cmd == SMB2_SESSION_SETUP_HE) 57438c8a9a5SSteve French return 0; 57538c8a9a5SSteve French 57638c8a9a5SSteve French if (!ksmbd_conn_good(conn)) 5775005bcb4SNamjae Jeon return -EIO; 57838c8a9a5SSteve French 57938c8a9a5SSteve French sess_id = le64_to_cpu(req_hdr->SessionId); 5805005bcb4SNamjae Jeon 5815005bcb4SNamjae Jeon /* 5825005bcb4SNamjae Jeon * If request is not the first in Compound request, 5835005bcb4SNamjae Jeon * Just validate session id in header with work->sess->id. 5845005bcb4SNamjae Jeon */ 5855005bcb4SNamjae Jeon if (work->next_smb2_rcv_hdr_off) { 5865005bcb4SNamjae Jeon if (!work->sess) { 5875005bcb4SNamjae Jeon pr_err("The first operation in the compound does not have sess\n"); 5885005bcb4SNamjae Jeon return -EINVAL; 5895005bcb4SNamjae Jeon } 5905005bcb4SNamjae Jeon if (work->sess->id != sess_id) { 5915005bcb4SNamjae Jeon pr_err("session id(%llu) is different with the first operation(%lld)\n", 5925005bcb4SNamjae Jeon sess_id, work->sess->id); 5935005bcb4SNamjae Jeon return -EINVAL; 5945005bcb4SNamjae Jeon } 5955005bcb4SNamjae Jeon return 1; 5965005bcb4SNamjae Jeon } 5975005bcb4SNamjae Jeon 59838c8a9a5SSteve French /* Check for validity of user session */ 59938c8a9a5SSteve French work->sess = ksmbd_session_lookup_all(conn, sess_id); 60038c8a9a5SSteve French if (work->sess) 60138c8a9a5SSteve French return 1; 60238c8a9a5SSteve French ksmbd_debug(SMB, "Invalid user session, Uid %llu\n", sess_id); 6035005bcb4SNamjae Jeon return -ENOENT; 60438c8a9a5SSteve French } 60538c8a9a5SSteve French 60638c8a9a5SSteve French static void destroy_previous_session(struct ksmbd_conn *conn, 60738c8a9a5SSteve French struct ksmbd_user *user, u64 id) 60838c8a9a5SSteve French { 60938c8a9a5SSteve French struct ksmbd_session *prev_sess = ksmbd_session_lookup_slowpath(id); 61038c8a9a5SSteve French struct ksmbd_user *prev_user; 61138c8a9a5SSteve French struct channel *chann; 61238c8a9a5SSteve French long index; 61338c8a9a5SSteve French 61438c8a9a5SSteve French if (!prev_sess) 61538c8a9a5SSteve French return; 61638c8a9a5SSteve French 61738c8a9a5SSteve French prev_user = prev_sess->user; 61838c8a9a5SSteve French 61938c8a9a5SSteve French if (!prev_user || 62038c8a9a5SSteve French strcmp(user->name, prev_user->name) || 62138c8a9a5SSteve French user->passkey_sz != prev_user->passkey_sz || 62238c8a9a5SSteve French memcmp(user->passkey, prev_user->passkey, user->passkey_sz)) 62338c8a9a5SSteve French return; 62438c8a9a5SSteve French 62538c8a9a5SSteve French prev_sess->state = SMB2_SESSION_EXPIRED; 62638c8a9a5SSteve French xa_for_each(&prev_sess->ksmbd_chann_list, index, chann) 62738c8a9a5SSteve French ksmbd_conn_set_exiting(chann->conn); 62838c8a9a5SSteve French } 62938c8a9a5SSteve French 63038c8a9a5SSteve French /** 63138c8a9a5SSteve French * smb2_get_name() - get filename string from on the wire smb format 63238c8a9a5SSteve French * @src: source buffer 63338c8a9a5SSteve French * @maxlen: maxlen of source string 63438c8a9a5SSteve French * @local_nls: nls_table pointer 63538c8a9a5SSteve French * 63638c8a9a5SSteve French * Return: matching converted filename on success, otherwise error ptr 63738c8a9a5SSteve French */ 63838c8a9a5SSteve French static char * 63938c8a9a5SSteve French smb2_get_name(const char *src, const int maxlen, struct nls_table *local_nls) 64038c8a9a5SSteve French { 64138c8a9a5SSteve French char *name; 64238c8a9a5SSteve French 64338c8a9a5SSteve French name = smb_strndup_from_utf16(src, maxlen, 1, local_nls); 64438c8a9a5SSteve French if (IS_ERR(name)) { 64538c8a9a5SSteve French pr_err("failed to get name %ld\n", PTR_ERR(name)); 64638c8a9a5SSteve French return name; 64738c8a9a5SSteve French } 64838c8a9a5SSteve French 64938c8a9a5SSteve French ksmbd_conv_path_to_unix(name); 65038c8a9a5SSteve French ksmbd_strip_last_slash(name); 65138c8a9a5SSteve French return name; 65238c8a9a5SSteve French } 65338c8a9a5SSteve French 65438c8a9a5SSteve French int setup_async_work(struct ksmbd_work *work, void (*fn)(void **), void **arg) 65538c8a9a5SSteve French { 65638c8a9a5SSteve French struct smb2_hdr *rsp_hdr; 65738c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 65838c8a9a5SSteve French int id; 65938c8a9a5SSteve French 66038c8a9a5SSteve French rsp_hdr = smb2_get_msg(work->response_buf); 66138c8a9a5SSteve French rsp_hdr->Flags |= SMB2_FLAGS_ASYNC_COMMAND; 66238c8a9a5SSteve French 66338c8a9a5SSteve French id = ksmbd_acquire_async_msg_id(&conn->async_ida); 66438c8a9a5SSteve French if (id < 0) { 66538c8a9a5SSteve French pr_err("Failed to alloc async message id\n"); 66638c8a9a5SSteve French return id; 66738c8a9a5SSteve French } 66838c8a9a5SSteve French work->asynchronous = true; 66938c8a9a5SSteve French work->async_id = id; 67038c8a9a5SSteve French rsp_hdr->Id.AsyncId = cpu_to_le64(id); 67138c8a9a5SSteve French 67238c8a9a5SSteve French ksmbd_debug(SMB, 67338c8a9a5SSteve French "Send interim Response to inform async request id : %d\n", 67438c8a9a5SSteve French work->async_id); 67538c8a9a5SSteve French 67638c8a9a5SSteve French work->cancel_fn = fn; 67738c8a9a5SSteve French work->cancel_argv = arg; 67838c8a9a5SSteve French 67938c8a9a5SSteve French if (list_empty(&work->async_request_entry)) { 68038c8a9a5SSteve French spin_lock(&conn->request_lock); 68138c8a9a5SSteve French list_add_tail(&work->async_request_entry, &conn->async_requests); 68238c8a9a5SSteve French spin_unlock(&conn->request_lock); 68338c8a9a5SSteve French } 68438c8a9a5SSteve French 68538c8a9a5SSteve French return 0; 68638c8a9a5SSteve French } 68738c8a9a5SSteve French 68838c8a9a5SSteve French void release_async_work(struct ksmbd_work *work) 68938c8a9a5SSteve French { 69038c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 69138c8a9a5SSteve French 69238c8a9a5SSteve French spin_lock(&conn->request_lock); 69338c8a9a5SSteve French list_del_init(&work->async_request_entry); 69438c8a9a5SSteve French spin_unlock(&conn->request_lock); 69538c8a9a5SSteve French 69638c8a9a5SSteve French work->asynchronous = 0; 69738c8a9a5SSteve French work->cancel_fn = NULL; 69838c8a9a5SSteve French kfree(work->cancel_argv); 69938c8a9a5SSteve French work->cancel_argv = NULL; 70038c8a9a5SSteve French if (work->async_id) { 70138c8a9a5SSteve French ksmbd_release_id(&conn->async_ida, work->async_id); 70238c8a9a5SSteve French work->async_id = 0; 70338c8a9a5SSteve French } 70438c8a9a5SSteve French } 70538c8a9a5SSteve French 70638c8a9a5SSteve French void smb2_send_interim_resp(struct ksmbd_work *work, __le32 status) 70738c8a9a5SSteve French { 70838c8a9a5SSteve French struct smb2_hdr *rsp_hdr; 70938c8a9a5SSteve French 71038c8a9a5SSteve French rsp_hdr = smb2_get_msg(work->response_buf); 71138c8a9a5SSteve French smb2_set_err_rsp(work); 71238c8a9a5SSteve French rsp_hdr->Status = status; 71338c8a9a5SSteve French 71438c8a9a5SSteve French work->multiRsp = 1; 71538c8a9a5SSteve French ksmbd_conn_write(work); 71638c8a9a5SSteve French rsp_hdr->Status = 0; 71738c8a9a5SSteve French work->multiRsp = 0; 71838c8a9a5SSteve French } 71938c8a9a5SSteve French 72038c8a9a5SSteve French static __le32 smb2_get_reparse_tag_special_file(umode_t mode) 72138c8a9a5SSteve French { 72238c8a9a5SSteve French if (S_ISDIR(mode) || S_ISREG(mode)) 72338c8a9a5SSteve French return 0; 72438c8a9a5SSteve French 72538c8a9a5SSteve French if (S_ISLNK(mode)) 72638c8a9a5SSteve French return IO_REPARSE_TAG_LX_SYMLINK_LE; 72738c8a9a5SSteve French else if (S_ISFIFO(mode)) 72838c8a9a5SSteve French return IO_REPARSE_TAG_LX_FIFO_LE; 72938c8a9a5SSteve French else if (S_ISSOCK(mode)) 73038c8a9a5SSteve French return IO_REPARSE_TAG_AF_UNIX_LE; 73138c8a9a5SSteve French else if (S_ISCHR(mode)) 73238c8a9a5SSteve French return IO_REPARSE_TAG_LX_CHR_LE; 73338c8a9a5SSteve French else if (S_ISBLK(mode)) 73438c8a9a5SSteve French return IO_REPARSE_TAG_LX_BLK_LE; 73538c8a9a5SSteve French 73638c8a9a5SSteve French return 0; 73738c8a9a5SSteve French } 73838c8a9a5SSteve French 73938c8a9a5SSteve French /** 74038c8a9a5SSteve French * smb2_get_dos_mode() - get file mode in dos format from unix mode 74138c8a9a5SSteve French * @stat: kstat containing file mode 74238c8a9a5SSteve French * @attribute: attribute flags 74338c8a9a5SSteve French * 74438c8a9a5SSteve French * Return: converted dos mode 74538c8a9a5SSteve French */ 74638c8a9a5SSteve French static int smb2_get_dos_mode(struct kstat *stat, int attribute) 74738c8a9a5SSteve French { 74838c8a9a5SSteve French int attr = 0; 74938c8a9a5SSteve French 75038c8a9a5SSteve French if (S_ISDIR(stat->mode)) { 75138c8a9a5SSteve French attr = FILE_ATTRIBUTE_DIRECTORY | 75238c8a9a5SSteve French (attribute & (FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM)); 75338c8a9a5SSteve French } else { 75438c8a9a5SSteve French attr = (attribute & 0x00005137) | FILE_ATTRIBUTE_ARCHIVE; 75538c8a9a5SSteve French attr &= ~(FILE_ATTRIBUTE_DIRECTORY); 75638c8a9a5SSteve French if (S_ISREG(stat->mode) && (server_conf.share_fake_fscaps & 75738c8a9a5SSteve French FILE_SUPPORTS_SPARSE_FILES)) 75838c8a9a5SSteve French attr |= FILE_ATTRIBUTE_SPARSE_FILE; 75938c8a9a5SSteve French 76038c8a9a5SSteve French if (smb2_get_reparse_tag_special_file(stat->mode)) 76138c8a9a5SSteve French attr |= FILE_ATTRIBUTE_REPARSE_POINT; 76238c8a9a5SSteve French } 76338c8a9a5SSteve French 76438c8a9a5SSteve French return attr; 76538c8a9a5SSteve French } 76638c8a9a5SSteve French 76738c8a9a5SSteve French static void build_preauth_ctxt(struct smb2_preauth_neg_context *pneg_ctxt, 76838c8a9a5SSteve French __le16 hash_id) 76938c8a9a5SSteve French { 77038c8a9a5SSteve French pneg_ctxt->ContextType = SMB2_PREAUTH_INTEGRITY_CAPABILITIES; 77138c8a9a5SSteve French pneg_ctxt->DataLength = cpu_to_le16(38); 77238c8a9a5SSteve French pneg_ctxt->HashAlgorithmCount = cpu_to_le16(1); 77338c8a9a5SSteve French pneg_ctxt->Reserved = cpu_to_le32(0); 77438c8a9a5SSteve French pneg_ctxt->SaltLength = cpu_to_le16(SMB311_SALT_SIZE); 77538c8a9a5SSteve French get_random_bytes(pneg_ctxt->Salt, SMB311_SALT_SIZE); 77638c8a9a5SSteve French pneg_ctxt->HashAlgorithms = hash_id; 77738c8a9a5SSteve French } 77838c8a9a5SSteve French 77938c8a9a5SSteve French static void build_encrypt_ctxt(struct smb2_encryption_neg_context *pneg_ctxt, 78038c8a9a5SSteve French __le16 cipher_type) 78138c8a9a5SSteve French { 78238c8a9a5SSteve French pneg_ctxt->ContextType = SMB2_ENCRYPTION_CAPABILITIES; 78338c8a9a5SSteve French pneg_ctxt->DataLength = cpu_to_le16(4); 78438c8a9a5SSteve French pneg_ctxt->Reserved = cpu_to_le32(0); 78538c8a9a5SSteve French pneg_ctxt->CipherCount = cpu_to_le16(1); 78638c8a9a5SSteve French pneg_ctxt->Ciphers[0] = cipher_type; 78738c8a9a5SSteve French } 78838c8a9a5SSteve French 78938c8a9a5SSteve French static void build_sign_cap_ctxt(struct smb2_signing_capabilities *pneg_ctxt, 79038c8a9a5SSteve French __le16 sign_algo) 79138c8a9a5SSteve French { 79238c8a9a5SSteve French pneg_ctxt->ContextType = SMB2_SIGNING_CAPABILITIES; 79338c8a9a5SSteve French pneg_ctxt->DataLength = 79438c8a9a5SSteve French cpu_to_le16((sizeof(struct smb2_signing_capabilities) + 2) 79538c8a9a5SSteve French - sizeof(struct smb2_neg_context)); 79638c8a9a5SSteve French pneg_ctxt->Reserved = cpu_to_le32(0); 79738c8a9a5SSteve French pneg_ctxt->SigningAlgorithmCount = cpu_to_le16(1); 79838c8a9a5SSteve French pneg_ctxt->SigningAlgorithms[0] = sign_algo; 79938c8a9a5SSteve French } 80038c8a9a5SSteve French 80138c8a9a5SSteve French static void build_posix_ctxt(struct smb2_posix_neg_context *pneg_ctxt) 80238c8a9a5SSteve French { 80338c8a9a5SSteve French pneg_ctxt->ContextType = SMB2_POSIX_EXTENSIONS_AVAILABLE; 80438c8a9a5SSteve French pneg_ctxt->DataLength = cpu_to_le16(POSIX_CTXT_DATA_LEN); 80538c8a9a5SSteve French /* SMB2_CREATE_TAG_POSIX is "0x93AD25509CB411E7B42383DE968BCD7C" */ 80638c8a9a5SSteve French pneg_ctxt->Name[0] = 0x93; 80738c8a9a5SSteve French pneg_ctxt->Name[1] = 0xAD; 80838c8a9a5SSteve French pneg_ctxt->Name[2] = 0x25; 80938c8a9a5SSteve French pneg_ctxt->Name[3] = 0x50; 81038c8a9a5SSteve French pneg_ctxt->Name[4] = 0x9C; 81138c8a9a5SSteve French pneg_ctxt->Name[5] = 0xB4; 81238c8a9a5SSteve French pneg_ctxt->Name[6] = 0x11; 81338c8a9a5SSteve French pneg_ctxt->Name[7] = 0xE7; 81438c8a9a5SSteve French pneg_ctxt->Name[8] = 0xB4; 81538c8a9a5SSteve French pneg_ctxt->Name[9] = 0x23; 81638c8a9a5SSteve French pneg_ctxt->Name[10] = 0x83; 81738c8a9a5SSteve French pneg_ctxt->Name[11] = 0xDE; 81838c8a9a5SSteve French pneg_ctxt->Name[12] = 0x96; 81938c8a9a5SSteve French pneg_ctxt->Name[13] = 0x8B; 82038c8a9a5SSteve French pneg_ctxt->Name[14] = 0xCD; 82138c8a9a5SSteve French pneg_ctxt->Name[15] = 0x7C; 82238c8a9a5SSteve French } 82338c8a9a5SSteve French 82438c8a9a5SSteve French static void assemble_neg_contexts(struct ksmbd_conn *conn, 82538c8a9a5SSteve French struct smb2_negotiate_rsp *rsp, 82638c8a9a5SSteve French void *smb2_buf_len) 82738c8a9a5SSteve French { 82838c8a9a5SSteve French char * const pneg_ctxt = (char *)rsp + 82938c8a9a5SSteve French le32_to_cpu(rsp->NegotiateContextOffset); 83038c8a9a5SSteve French int neg_ctxt_cnt = 1; 83138c8a9a5SSteve French int ctxt_size; 83238c8a9a5SSteve French 83338c8a9a5SSteve French ksmbd_debug(SMB, 83438c8a9a5SSteve French "assemble SMB2_PREAUTH_INTEGRITY_CAPABILITIES context\n"); 83538c8a9a5SSteve French build_preauth_ctxt((struct smb2_preauth_neg_context *)pneg_ctxt, 83638c8a9a5SSteve French conn->preauth_info->Preauth_HashId); 83738c8a9a5SSteve French inc_rfc1001_len(smb2_buf_len, AUTH_GSS_PADDING); 83838c8a9a5SSteve French ctxt_size = sizeof(struct smb2_preauth_neg_context); 83938c8a9a5SSteve French 84038c8a9a5SSteve French if (conn->cipher_type) { 84138c8a9a5SSteve French /* Round to 8 byte boundary */ 84238c8a9a5SSteve French ctxt_size = round_up(ctxt_size, 8); 84338c8a9a5SSteve French ksmbd_debug(SMB, 84438c8a9a5SSteve French "assemble SMB2_ENCRYPTION_CAPABILITIES context\n"); 84538c8a9a5SSteve French build_encrypt_ctxt((struct smb2_encryption_neg_context *) 84638c8a9a5SSteve French (pneg_ctxt + ctxt_size), 84738c8a9a5SSteve French conn->cipher_type); 84838c8a9a5SSteve French neg_ctxt_cnt++; 84938c8a9a5SSteve French ctxt_size += sizeof(struct smb2_encryption_neg_context) + 2; 85038c8a9a5SSteve French } 85138c8a9a5SSteve French 85238c8a9a5SSteve French /* compression context not yet supported */ 85338c8a9a5SSteve French WARN_ON(conn->compress_algorithm != SMB3_COMPRESS_NONE); 85438c8a9a5SSteve French 85538c8a9a5SSteve French if (conn->posix_ext_supported) { 85638c8a9a5SSteve French ctxt_size = round_up(ctxt_size, 8); 85738c8a9a5SSteve French ksmbd_debug(SMB, 85838c8a9a5SSteve French "assemble SMB2_POSIX_EXTENSIONS_AVAILABLE context\n"); 85938c8a9a5SSteve French build_posix_ctxt((struct smb2_posix_neg_context *) 86038c8a9a5SSteve French (pneg_ctxt + ctxt_size)); 86138c8a9a5SSteve French neg_ctxt_cnt++; 86238c8a9a5SSteve French ctxt_size += sizeof(struct smb2_posix_neg_context); 86338c8a9a5SSteve French } 86438c8a9a5SSteve French 86538c8a9a5SSteve French if (conn->signing_negotiated) { 86638c8a9a5SSteve French ctxt_size = round_up(ctxt_size, 8); 86738c8a9a5SSteve French ksmbd_debug(SMB, 86838c8a9a5SSteve French "assemble SMB2_SIGNING_CAPABILITIES context\n"); 86938c8a9a5SSteve French build_sign_cap_ctxt((struct smb2_signing_capabilities *) 87038c8a9a5SSteve French (pneg_ctxt + ctxt_size), 87138c8a9a5SSteve French conn->signing_algorithm); 87238c8a9a5SSteve French neg_ctxt_cnt++; 87338c8a9a5SSteve French ctxt_size += sizeof(struct smb2_signing_capabilities) + 2; 87438c8a9a5SSteve French } 87538c8a9a5SSteve French 87638c8a9a5SSteve French rsp->NegotiateContextCount = cpu_to_le16(neg_ctxt_cnt); 87738c8a9a5SSteve French inc_rfc1001_len(smb2_buf_len, ctxt_size); 87838c8a9a5SSteve French } 87938c8a9a5SSteve French 88038c8a9a5SSteve French static __le32 decode_preauth_ctxt(struct ksmbd_conn *conn, 88138c8a9a5SSteve French struct smb2_preauth_neg_context *pneg_ctxt, 8820512a5f8SKuan-Ting Chen int ctxt_len) 88338c8a9a5SSteve French { 88438c8a9a5SSteve French /* 88538c8a9a5SSteve French * sizeof(smb2_preauth_neg_context) assumes SMB311_SALT_SIZE Salt, 88638c8a9a5SSteve French * which may not be present. Only check for used HashAlgorithms[1]. 88738c8a9a5SSteve French */ 8880512a5f8SKuan-Ting Chen if (ctxt_len < 8890512a5f8SKuan-Ting Chen sizeof(struct smb2_neg_context) + MIN_PREAUTH_CTXT_DATA_LEN) 89038c8a9a5SSteve French return STATUS_INVALID_PARAMETER; 89138c8a9a5SSteve French 89238c8a9a5SSteve French if (pneg_ctxt->HashAlgorithms != SMB2_PREAUTH_INTEGRITY_SHA512) 89338c8a9a5SSteve French return STATUS_NO_PREAUTH_INTEGRITY_HASH_OVERLAP; 89438c8a9a5SSteve French 89538c8a9a5SSteve French conn->preauth_info->Preauth_HashId = SMB2_PREAUTH_INTEGRITY_SHA512; 89638c8a9a5SSteve French return STATUS_SUCCESS; 89738c8a9a5SSteve French } 89838c8a9a5SSteve French 89938c8a9a5SSteve French static void decode_encrypt_ctxt(struct ksmbd_conn *conn, 90038c8a9a5SSteve French struct smb2_encryption_neg_context *pneg_ctxt, 9010512a5f8SKuan-Ting Chen int ctxt_len) 90238c8a9a5SSteve French { 9030512a5f8SKuan-Ting Chen int cph_cnt; 9040512a5f8SKuan-Ting Chen int i, cphs_size; 9050512a5f8SKuan-Ting Chen 9060512a5f8SKuan-Ting Chen if (sizeof(struct smb2_encryption_neg_context) > ctxt_len) { 9070512a5f8SKuan-Ting Chen pr_err("Invalid SMB2_ENCRYPTION_CAPABILITIES context size\n"); 9080512a5f8SKuan-Ting Chen return; 9090512a5f8SKuan-Ting Chen } 91038c8a9a5SSteve French 91138c8a9a5SSteve French conn->cipher_type = 0; 91238c8a9a5SSteve French 9130512a5f8SKuan-Ting Chen cph_cnt = le16_to_cpu(pneg_ctxt->CipherCount); 9140512a5f8SKuan-Ting Chen cphs_size = cph_cnt * sizeof(__le16); 9150512a5f8SKuan-Ting Chen 91638c8a9a5SSteve French if (sizeof(struct smb2_encryption_neg_context) + cphs_size > 9170512a5f8SKuan-Ting Chen ctxt_len) { 91838c8a9a5SSteve French pr_err("Invalid cipher count(%d)\n", cph_cnt); 91938c8a9a5SSteve French return; 92038c8a9a5SSteve French } 92138c8a9a5SSteve French 92238c8a9a5SSteve French if (server_conf.flags & KSMBD_GLOBAL_FLAG_SMB2_ENCRYPTION_OFF) 92338c8a9a5SSteve French return; 92438c8a9a5SSteve French 92538c8a9a5SSteve French for (i = 0; i < cph_cnt; i++) { 92638c8a9a5SSteve French if (pneg_ctxt->Ciphers[i] == SMB2_ENCRYPTION_AES128_GCM || 92738c8a9a5SSteve French pneg_ctxt->Ciphers[i] == SMB2_ENCRYPTION_AES128_CCM || 92838c8a9a5SSteve French pneg_ctxt->Ciphers[i] == SMB2_ENCRYPTION_AES256_CCM || 92938c8a9a5SSteve French pneg_ctxt->Ciphers[i] == SMB2_ENCRYPTION_AES256_GCM) { 93038c8a9a5SSteve French ksmbd_debug(SMB, "Cipher ID = 0x%x\n", 93138c8a9a5SSteve French pneg_ctxt->Ciphers[i]); 93238c8a9a5SSteve French conn->cipher_type = pneg_ctxt->Ciphers[i]; 93338c8a9a5SSteve French break; 93438c8a9a5SSteve French } 93538c8a9a5SSteve French } 93638c8a9a5SSteve French } 93738c8a9a5SSteve French 93838c8a9a5SSteve French /** 93938c8a9a5SSteve French * smb3_encryption_negotiated() - checks if server and client agreed on enabling encryption 94038c8a9a5SSteve French * @conn: smb connection 94138c8a9a5SSteve French * 94238c8a9a5SSteve French * Return: true if connection should be encrypted, else false 94338c8a9a5SSteve French */ 94438c8a9a5SSteve French bool smb3_encryption_negotiated(struct ksmbd_conn *conn) 94538c8a9a5SSteve French { 94638c8a9a5SSteve French if (!conn->ops->generate_encryptionkey) 94738c8a9a5SSteve French return false; 94838c8a9a5SSteve French 94938c8a9a5SSteve French /* 95038c8a9a5SSteve French * SMB 3.0 and 3.0.2 dialects use the SMB2_GLOBAL_CAP_ENCRYPTION flag. 95138c8a9a5SSteve French * SMB 3.1.1 uses the cipher_type field. 95238c8a9a5SSteve French */ 95338c8a9a5SSteve French return (conn->vals->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION) || 95438c8a9a5SSteve French conn->cipher_type; 95538c8a9a5SSteve French } 95638c8a9a5SSteve French 95738c8a9a5SSteve French static void decode_compress_ctxt(struct ksmbd_conn *conn, 95838c8a9a5SSteve French struct smb2_compression_capabilities_context *pneg_ctxt) 95938c8a9a5SSteve French { 96038c8a9a5SSteve French conn->compress_algorithm = SMB3_COMPRESS_NONE; 96138c8a9a5SSteve French } 96238c8a9a5SSteve French 96338c8a9a5SSteve French static void decode_sign_cap_ctxt(struct ksmbd_conn *conn, 96438c8a9a5SSteve French struct smb2_signing_capabilities *pneg_ctxt, 9650512a5f8SKuan-Ting Chen int ctxt_len) 96638c8a9a5SSteve French { 9670512a5f8SKuan-Ting Chen int sign_algo_cnt; 9680512a5f8SKuan-Ting Chen int i, sign_alos_size; 9690512a5f8SKuan-Ting Chen 9700512a5f8SKuan-Ting Chen if (sizeof(struct smb2_signing_capabilities) > ctxt_len) { 9710512a5f8SKuan-Ting Chen pr_err("Invalid SMB2_SIGNING_CAPABILITIES context length\n"); 9720512a5f8SKuan-Ting Chen return; 9730512a5f8SKuan-Ting Chen } 97438c8a9a5SSteve French 97538c8a9a5SSteve French conn->signing_negotiated = false; 9760512a5f8SKuan-Ting Chen sign_algo_cnt = le16_to_cpu(pneg_ctxt->SigningAlgorithmCount); 9770512a5f8SKuan-Ting Chen sign_alos_size = sign_algo_cnt * sizeof(__le16); 97838c8a9a5SSteve French 97938c8a9a5SSteve French if (sizeof(struct smb2_signing_capabilities) + sign_alos_size > 9800512a5f8SKuan-Ting Chen ctxt_len) { 98138c8a9a5SSteve French pr_err("Invalid signing algorithm count(%d)\n", sign_algo_cnt); 98238c8a9a5SSteve French return; 98338c8a9a5SSteve French } 98438c8a9a5SSteve French 98538c8a9a5SSteve French for (i = 0; i < sign_algo_cnt; i++) { 98638c8a9a5SSteve French if (pneg_ctxt->SigningAlgorithms[i] == SIGNING_ALG_HMAC_SHA256_LE || 98738c8a9a5SSteve French pneg_ctxt->SigningAlgorithms[i] == SIGNING_ALG_AES_CMAC_LE) { 98838c8a9a5SSteve French ksmbd_debug(SMB, "Signing Algorithm ID = 0x%x\n", 98938c8a9a5SSteve French pneg_ctxt->SigningAlgorithms[i]); 99038c8a9a5SSteve French conn->signing_negotiated = true; 99138c8a9a5SSteve French conn->signing_algorithm = 99238c8a9a5SSteve French pneg_ctxt->SigningAlgorithms[i]; 99338c8a9a5SSteve French break; 99438c8a9a5SSteve French } 99538c8a9a5SSteve French } 99638c8a9a5SSteve French } 99738c8a9a5SSteve French 99838c8a9a5SSteve French static __le32 deassemble_neg_contexts(struct ksmbd_conn *conn, 99938c8a9a5SSteve French struct smb2_negotiate_req *req, 1000f1a41187SNamjae Jeon unsigned int len_of_smb) 100138c8a9a5SSteve French { 100238c8a9a5SSteve French /* +4 is to account for the RFC1001 len field */ 100338c8a9a5SSteve French struct smb2_neg_context *pctx = (struct smb2_neg_context *)req; 100438c8a9a5SSteve French int i = 0, len_of_ctxts; 1005f1a41187SNamjae Jeon unsigned int offset = le32_to_cpu(req->NegotiateContextOffset); 1006f1a41187SNamjae Jeon unsigned int neg_ctxt_cnt = le16_to_cpu(req->NegotiateContextCount); 100738c8a9a5SSteve French __le32 status = STATUS_INVALID_PARAMETER; 100838c8a9a5SSteve French 100938c8a9a5SSteve French ksmbd_debug(SMB, "decoding %d negotiate contexts\n", neg_ctxt_cnt); 101038c8a9a5SSteve French if (len_of_smb <= offset) { 101138c8a9a5SSteve French ksmbd_debug(SMB, "Invalid response: negotiate context offset\n"); 101238c8a9a5SSteve French return status; 101338c8a9a5SSteve French } 101438c8a9a5SSteve French 101538c8a9a5SSteve French len_of_ctxts = len_of_smb - offset; 101638c8a9a5SSteve French 101738c8a9a5SSteve French while (i++ < neg_ctxt_cnt) { 10180512a5f8SKuan-Ting Chen int clen, ctxt_len; 101938c8a9a5SSteve French 1020f1a41187SNamjae Jeon if (len_of_ctxts < (int)sizeof(struct smb2_neg_context)) 102138c8a9a5SSteve French break; 102238c8a9a5SSteve French 102338c8a9a5SSteve French pctx = (struct smb2_neg_context *)((char *)pctx + offset); 102438c8a9a5SSteve French clen = le16_to_cpu(pctx->DataLength); 10250512a5f8SKuan-Ting Chen ctxt_len = clen + sizeof(struct smb2_neg_context); 10260512a5f8SKuan-Ting Chen 10270512a5f8SKuan-Ting Chen if (ctxt_len > len_of_ctxts) 102838c8a9a5SSteve French break; 102938c8a9a5SSteve French 103038c8a9a5SSteve French if (pctx->ContextType == SMB2_PREAUTH_INTEGRITY_CAPABILITIES) { 103138c8a9a5SSteve French ksmbd_debug(SMB, 103238c8a9a5SSteve French "deassemble SMB2_PREAUTH_INTEGRITY_CAPABILITIES context\n"); 103338c8a9a5SSteve French if (conn->preauth_info->Preauth_HashId) 103438c8a9a5SSteve French break; 103538c8a9a5SSteve French 103638c8a9a5SSteve French status = decode_preauth_ctxt(conn, 103738c8a9a5SSteve French (struct smb2_preauth_neg_context *)pctx, 10380512a5f8SKuan-Ting Chen ctxt_len); 103938c8a9a5SSteve French if (status != STATUS_SUCCESS) 104038c8a9a5SSteve French break; 104138c8a9a5SSteve French } else if (pctx->ContextType == SMB2_ENCRYPTION_CAPABILITIES) { 104238c8a9a5SSteve French ksmbd_debug(SMB, 104338c8a9a5SSteve French "deassemble SMB2_ENCRYPTION_CAPABILITIES context\n"); 104438c8a9a5SSteve French if (conn->cipher_type) 104538c8a9a5SSteve French break; 104638c8a9a5SSteve French 104738c8a9a5SSteve French decode_encrypt_ctxt(conn, 104838c8a9a5SSteve French (struct smb2_encryption_neg_context *)pctx, 10490512a5f8SKuan-Ting Chen ctxt_len); 105038c8a9a5SSteve French } else if (pctx->ContextType == SMB2_COMPRESSION_CAPABILITIES) { 105138c8a9a5SSteve French ksmbd_debug(SMB, 105238c8a9a5SSteve French "deassemble SMB2_COMPRESSION_CAPABILITIES context\n"); 105338c8a9a5SSteve French if (conn->compress_algorithm) 105438c8a9a5SSteve French break; 105538c8a9a5SSteve French 105638c8a9a5SSteve French decode_compress_ctxt(conn, 105738c8a9a5SSteve French (struct smb2_compression_capabilities_context *)pctx); 105838c8a9a5SSteve French } else if (pctx->ContextType == SMB2_NETNAME_NEGOTIATE_CONTEXT_ID) { 105938c8a9a5SSteve French ksmbd_debug(SMB, 106038c8a9a5SSteve French "deassemble SMB2_NETNAME_NEGOTIATE_CONTEXT_ID context\n"); 106138c8a9a5SSteve French } else if (pctx->ContextType == SMB2_POSIX_EXTENSIONS_AVAILABLE) { 106238c8a9a5SSteve French ksmbd_debug(SMB, 106338c8a9a5SSteve French "deassemble SMB2_POSIX_EXTENSIONS_AVAILABLE context\n"); 106438c8a9a5SSteve French conn->posix_ext_supported = true; 106538c8a9a5SSteve French } else if (pctx->ContextType == SMB2_SIGNING_CAPABILITIES) { 106638c8a9a5SSteve French ksmbd_debug(SMB, 106738c8a9a5SSteve French "deassemble SMB2_SIGNING_CAPABILITIES context\n"); 10680512a5f8SKuan-Ting Chen 106938c8a9a5SSteve French decode_sign_cap_ctxt(conn, 107038c8a9a5SSteve French (struct smb2_signing_capabilities *)pctx, 10710512a5f8SKuan-Ting Chen ctxt_len); 107238c8a9a5SSteve French } 107338c8a9a5SSteve French 107438c8a9a5SSteve French /* offsets must be 8 byte aligned */ 1075f1a41187SNamjae Jeon offset = (ctxt_len + 7) & ~0x7; 1076f1a41187SNamjae Jeon len_of_ctxts -= offset; 107738c8a9a5SSteve French } 107838c8a9a5SSteve French return status; 107938c8a9a5SSteve French } 108038c8a9a5SSteve French 108138c8a9a5SSteve French /** 108238c8a9a5SSteve French * smb2_handle_negotiate() - handler for smb2 negotiate command 108338c8a9a5SSteve French * @work: smb work containing smb request buffer 108438c8a9a5SSteve French * 108538c8a9a5SSteve French * Return: 0 108638c8a9a5SSteve French */ 108738c8a9a5SSteve French int smb2_handle_negotiate(struct ksmbd_work *work) 108838c8a9a5SSteve French { 108938c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 109038c8a9a5SSteve French struct smb2_negotiate_req *req = smb2_get_msg(work->request_buf); 109138c8a9a5SSteve French struct smb2_negotiate_rsp *rsp = smb2_get_msg(work->response_buf); 109238c8a9a5SSteve French int rc = 0; 109338c8a9a5SSteve French unsigned int smb2_buf_len, smb2_neg_size; 109438c8a9a5SSteve French __le32 status; 109538c8a9a5SSteve French 109638c8a9a5SSteve French ksmbd_debug(SMB, "Received negotiate request\n"); 109738c8a9a5SSteve French conn->need_neg = false; 109838c8a9a5SSteve French if (ksmbd_conn_good(conn)) { 109938c8a9a5SSteve French pr_err("conn->tcp_status is already in CifsGood State\n"); 110038c8a9a5SSteve French work->send_no_response = 1; 110138c8a9a5SSteve French return rc; 110238c8a9a5SSteve French } 110338c8a9a5SSteve French 1104d738950fSKuan-Ting Chen smb2_buf_len = get_rfc1002_len(work->request_buf); 1105d738950fSKuan-Ting Chen smb2_neg_size = offsetof(struct smb2_negotiate_req, Dialects); 1106d738950fSKuan-Ting Chen if (smb2_neg_size > smb2_buf_len) { 110738c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 110838c8a9a5SSteve French rc = -EINVAL; 110938c8a9a5SSteve French goto err_out; 111038c8a9a5SSteve French } 111138c8a9a5SSteve French 1112d738950fSKuan-Ting Chen if (req->DialectCount == 0) { 1113d738950fSKuan-Ting Chen pr_err("malformed packet\n"); 111438c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 111538c8a9a5SSteve French rc = -EINVAL; 111638c8a9a5SSteve French goto err_out; 111738c8a9a5SSteve French } 111838c8a9a5SSteve French 111938c8a9a5SSteve French if (conn->dialect == SMB311_PROT_ID) { 112038c8a9a5SSteve French unsigned int nego_ctxt_off = le32_to_cpu(req->NegotiateContextOffset); 112138c8a9a5SSteve French 112238c8a9a5SSteve French if (smb2_buf_len < nego_ctxt_off) { 112338c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 112438c8a9a5SSteve French rc = -EINVAL; 112538c8a9a5SSteve French goto err_out; 112638c8a9a5SSteve French } 112738c8a9a5SSteve French 112838c8a9a5SSteve French if (smb2_neg_size > nego_ctxt_off) { 112938c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 113038c8a9a5SSteve French rc = -EINVAL; 113138c8a9a5SSteve French goto err_out; 113238c8a9a5SSteve French } 113338c8a9a5SSteve French 113438c8a9a5SSteve French if (smb2_neg_size + le16_to_cpu(req->DialectCount) * sizeof(__le16) > 113538c8a9a5SSteve French nego_ctxt_off) { 113638c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 113738c8a9a5SSteve French rc = -EINVAL; 113838c8a9a5SSteve French goto err_out; 113938c8a9a5SSteve French } 114038c8a9a5SSteve French } else { 114138c8a9a5SSteve French if (smb2_neg_size + le16_to_cpu(req->DialectCount) * sizeof(__le16) > 114238c8a9a5SSteve French smb2_buf_len) { 114338c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 114438c8a9a5SSteve French rc = -EINVAL; 114538c8a9a5SSteve French goto err_out; 114638c8a9a5SSteve French } 114738c8a9a5SSteve French } 114838c8a9a5SSteve French 114938c8a9a5SSteve French conn->cli_cap = le32_to_cpu(req->Capabilities); 115038c8a9a5SSteve French switch (conn->dialect) { 115138c8a9a5SSteve French case SMB311_PROT_ID: 115238c8a9a5SSteve French conn->preauth_info = 115338c8a9a5SSteve French kzalloc(sizeof(struct preauth_integrity_info), 115438c8a9a5SSteve French GFP_KERNEL); 115538c8a9a5SSteve French if (!conn->preauth_info) { 115638c8a9a5SSteve French rc = -ENOMEM; 115738c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 115838c8a9a5SSteve French goto err_out; 115938c8a9a5SSteve French } 116038c8a9a5SSteve French 116138c8a9a5SSteve French status = deassemble_neg_contexts(conn, req, 116238c8a9a5SSteve French get_rfc1002_len(work->request_buf)); 116338c8a9a5SSteve French if (status != STATUS_SUCCESS) { 116438c8a9a5SSteve French pr_err("deassemble_neg_contexts error(0x%x)\n", 116538c8a9a5SSteve French status); 116638c8a9a5SSteve French rsp->hdr.Status = status; 116738c8a9a5SSteve French rc = -EINVAL; 116838c8a9a5SSteve French kfree(conn->preauth_info); 116938c8a9a5SSteve French conn->preauth_info = NULL; 117038c8a9a5SSteve French goto err_out; 117138c8a9a5SSteve French } 117238c8a9a5SSteve French 117338c8a9a5SSteve French rc = init_smb3_11_server(conn); 117438c8a9a5SSteve French if (rc < 0) { 117538c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 117638c8a9a5SSteve French kfree(conn->preauth_info); 117738c8a9a5SSteve French conn->preauth_info = NULL; 117838c8a9a5SSteve French goto err_out; 117938c8a9a5SSteve French } 118038c8a9a5SSteve French 118138c8a9a5SSteve French ksmbd_gen_preauth_integrity_hash(conn, 118238c8a9a5SSteve French work->request_buf, 118338c8a9a5SSteve French conn->preauth_info->Preauth_HashValue); 118438c8a9a5SSteve French rsp->NegotiateContextOffset = 118538c8a9a5SSteve French cpu_to_le32(OFFSET_OF_NEG_CONTEXT); 118638c8a9a5SSteve French assemble_neg_contexts(conn, rsp, work->response_buf); 118738c8a9a5SSteve French break; 118838c8a9a5SSteve French case SMB302_PROT_ID: 118938c8a9a5SSteve French init_smb3_02_server(conn); 119038c8a9a5SSteve French break; 119138c8a9a5SSteve French case SMB30_PROT_ID: 119238c8a9a5SSteve French init_smb3_0_server(conn); 119338c8a9a5SSteve French break; 119438c8a9a5SSteve French case SMB21_PROT_ID: 119538c8a9a5SSteve French init_smb2_1_server(conn); 119638c8a9a5SSteve French break; 119738c8a9a5SSteve French case SMB2X_PROT_ID: 119838c8a9a5SSteve French case BAD_PROT_ID: 119938c8a9a5SSteve French default: 120038c8a9a5SSteve French ksmbd_debug(SMB, "Server dialect :0x%x not supported\n", 120138c8a9a5SSteve French conn->dialect); 120238c8a9a5SSteve French rsp->hdr.Status = STATUS_NOT_SUPPORTED; 120338c8a9a5SSteve French rc = -EINVAL; 120438c8a9a5SSteve French goto err_out; 120538c8a9a5SSteve French } 120638c8a9a5SSteve French rsp->Capabilities = cpu_to_le32(conn->vals->capabilities); 120738c8a9a5SSteve French 120838c8a9a5SSteve French /* For stats */ 120938c8a9a5SSteve French conn->connection_type = conn->dialect; 121038c8a9a5SSteve French 121138c8a9a5SSteve French rsp->MaxTransactSize = cpu_to_le32(conn->vals->max_trans_size); 121238c8a9a5SSteve French rsp->MaxReadSize = cpu_to_le32(conn->vals->max_read_size); 121338c8a9a5SSteve French rsp->MaxWriteSize = cpu_to_le32(conn->vals->max_write_size); 121438c8a9a5SSteve French 121538c8a9a5SSteve French memcpy(conn->ClientGUID, req->ClientGUID, 121638c8a9a5SSteve French SMB2_CLIENT_GUID_SIZE); 121738c8a9a5SSteve French conn->cli_sec_mode = le16_to_cpu(req->SecurityMode); 121838c8a9a5SSteve French 121938c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(65); 122038c8a9a5SSteve French rsp->DialectRevision = cpu_to_le16(conn->dialect); 122138c8a9a5SSteve French /* Not setting conn guid rsp->ServerGUID, as it 122238c8a9a5SSteve French * not used by client for identifying server 122338c8a9a5SSteve French */ 122438c8a9a5SSteve French memset(rsp->ServerGUID, 0, SMB2_CLIENT_GUID_SIZE); 122538c8a9a5SSteve French 122638c8a9a5SSteve French rsp->SystemTime = cpu_to_le64(ksmbd_systime()); 122738c8a9a5SSteve French rsp->ServerStartTime = 0; 122838c8a9a5SSteve French ksmbd_debug(SMB, "negotiate context offset %d, count %d\n", 122938c8a9a5SSteve French le32_to_cpu(rsp->NegotiateContextOffset), 123038c8a9a5SSteve French le16_to_cpu(rsp->NegotiateContextCount)); 123138c8a9a5SSteve French 123238c8a9a5SSteve French rsp->SecurityBufferOffset = cpu_to_le16(128); 123338c8a9a5SSteve French rsp->SecurityBufferLength = cpu_to_le16(AUTH_GSS_LENGTH); 123438c8a9a5SSteve French ksmbd_copy_gss_neg_header((char *)(&rsp->hdr) + 123538c8a9a5SSteve French le16_to_cpu(rsp->SecurityBufferOffset)); 123638c8a9a5SSteve French inc_rfc1001_len(work->response_buf, sizeof(struct smb2_negotiate_rsp) - 123738c8a9a5SSteve French sizeof(struct smb2_hdr) + AUTH_GSS_LENGTH); 123838c8a9a5SSteve French rsp->SecurityMode = SMB2_NEGOTIATE_SIGNING_ENABLED_LE; 123938c8a9a5SSteve French conn->use_spnego = true; 124038c8a9a5SSteve French 124138c8a9a5SSteve French if ((server_conf.signing == KSMBD_CONFIG_OPT_AUTO || 124238c8a9a5SSteve French server_conf.signing == KSMBD_CONFIG_OPT_DISABLED) && 124338c8a9a5SSteve French req->SecurityMode & SMB2_NEGOTIATE_SIGNING_REQUIRED_LE) 124438c8a9a5SSteve French conn->sign = true; 124538c8a9a5SSteve French else if (server_conf.signing == KSMBD_CONFIG_OPT_MANDATORY) { 124638c8a9a5SSteve French server_conf.enforced_signing = true; 124738c8a9a5SSteve French rsp->SecurityMode |= SMB2_NEGOTIATE_SIGNING_REQUIRED_LE; 124838c8a9a5SSteve French conn->sign = true; 124938c8a9a5SSteve French } 125038c8a9a5SSteve French 125138c8a9a5SSteve French conn->srv_sec_mode = le16_to_cpu(rsp->SecurityMode); 125238c8a9a5SSteve French ksmbd_conn_set_need_negotiate(conn); 125338c8a9a5SSteve French 125438c8a9a5SSteve French err_out: 125538c8a9a5SSteve French if (rc < 0) 125638c8a9a5SSteve French smb2_set_err_rsp(work); 125738c8a9a5SSteve French 125838c8a9a5SSteve French return rc; 125938c8a9a5SSteve French } 126038c8a9a5SSteve French 126138c8a9a5SSteve French static int alloc_preauth_hash(struct ksmbd_session *sess, 126238c8a9a5SSteve French struct ksmbd_conn *conn) 126338c8a9a5SSteve French { 126438c8a9a5SSteve French if (sess->Preauth_HashValue) 126538c8a9a5SSteve French return 0; 126638c8a9a5SSteve French 126738c8a9a5SSteve French sess->Preauth_HashValue = kmemdup(conn->preauth_info->Preauth_HashValue, 126838c8a9a5SSteve French PREAUTH_HASHVALUE_SIZE, GFP_KERNEL); 126938c8a9a5SSteve French if (!sess->Preauth_HashValue) 127038c8a9a5SSteve French return -ENOMEM; 127138c8a9a5SSteve French 127238c8a9a5SSteve French return 0; 127338c8a9a5SSteve French } 127438c8a9a5SSteve French 127538c8a9a5SSteve French static int generate_preauth_hash(struct ksmbd_work *work) 127638c8a9a5SSteve French { 127738c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 127838c8a9a5SSteve French struct ksmbd_session *sess = work->sess; 127938c8a9a5SSteve French u8 *preauth_hash; 128038c8a9a5SSteve French 128138c8a9a5SSteve French if (conn->dialect != SMB311_PROT_ID) 128238c8a9a5SSteve French return 0; 128338c8a9a5SSteve French 128438c8a9a5SSteve French if (conn->binding) { 128538c8a9a5SSteve French struct preauth_session *preauth_sess; 128638c8a9a5SSteve French 128738c8a9a5SSteve French preauth_sess = ksmbd_preauth_session_lookup(conn, sess->id); 128838c8a9a5SSteve French if (!preauth_sess) { 128938c8a9a5SSteve French preauth_sess = ksmbd_preauth_session_alloc(conn, sess->id); 129038c8a9a5SSteve French if (!preauth_sess) 129138c8a9a5SSteve French return -ENOMEM; 129238c8a9a5SSteve French } 129338c8a9a5SSteve French 129438c8a9a5SSteve French preauth_hash = preauth_sess->Preauth_HashValue; 129538c8a9a5SSteve French } else { 129638c8a9a5SSteve French if (!sess->Preauth_HashValue) 129738c8a9a5SSteve French if (alloc_preauth_hash(sess, conn)) 129838c8a9a5SSteve French return -ENOMEM; 129938c8a9a5SSteve French preauth_hash = sess->Preauth_HashValue; 130038c8a9a5SSteve French } 130138c8a9a5SSteve French 130238c8a9a5SSteve French ksmbd_gen_preauth_integrity_hash(conn, work->request_buf, preauth_hash); 130338c8a9a5SSteve French return 0; 130438c8a9a5SSteve French } 130538c8a9a5SSteve French 130638c8a9a5SSteve French static int decode_negotiation_token(struct ksmbd_conn *conn, 130738c8a9a5SSteve French struct negotiate_message *negblob, 130838c8a9a5SSteve French size_t sz) 130938c8a9a5SSteve French { 131038c8a9a5SSteve French if (!conn->use_spnego) 131138c8a9a5SSteve French return -EINVAL; 131238c8a9a5SSteve French 131338c8a9a5SSteve French if (ksmbd_decode_negTokenInit((char *)negblob, sz, conn)) { 131438c8a9a5SSteve French if (ksmbd_decode_negTokenTarg((char *)negblob, sz, conn)) { 131538c8a9a5SSteve French conn->auth_mechs |= KSMBD_AUTH_NTLMSSP; 131638c8a9a5SSteve French conn->preferred_auth_mech = KSMBD_AUTH_NTLMSSP; 131738c8a9a5SSteve French conn->use_spnego = false; 131838c8a9a5SSteve French } 131938c8a9a5SSteve French } 132038c8a9a5SSteve French return 0; 132138c8a9a5SSteve French } 132238c8a9a5SSteve French 132338c8a9a5SSteve French static int ntlm_negotiate(struct ksmbd_work *work, 132438c8a9a5SSteve French struct negotiate_message *negblob, 132598422bddSNamjae Jeon size_t negblob_len, struct smb2_sess_setup_rsp *rsp) 132638c8a9a5SSteve French { 132738c8a9a5SSteve French struct challenge_message *chgblob; 132838c8a9a5SSteve French unsigned char *spnego_blob = NULL; 132938c8a9a5SSteve French u16 spnego_blob_len; 133038c8a9a5SSteve French char *neg_blob; 133138c8a9a5SSteve French int sz, rc; 133238c8a9a5SSteve French 133338c8a9a5SSteve French ksmbd_debug(SMB, "negotiate phase\n"); 133438c8a9a5SSteve French rc = ksmbd_decode_ntlmssp_neg_blob(negblob, negblob_len, work->conn); 133538c8a9a5SSteve French if (rc) 133638c8a9a5SSteve French return rc; 133738c8a9a5SSteve French 133838c8a9a5SSteve French sz = le16_to_cpu(rsp->SecurityBufferOffset); 133938c8a9a5SSteve French chgblob = 134038c8a9a5SSteve French (struct challenge_message *)((char *)&rsp->hdr.ProtocolId + sz); 134138c8a9a5SSteve French memset(chgblob, 0, sizeof(struct challenge_message)); 134238c8a9a5SSteve French 134338c8a9a5SSteve French if (!work->conn->use_spnego) { 134438c8a9a5SSteve French sz = ksmbd_build_ntlmssp_challenge_blob(chgblob, work->conn); 134538c8a9a5SSteve French if (sz < 0) 134638c8a9a5SSteve French return -ENOMEM; 134738c8a9a5SSteve French 134838c8a9a5SSteve French rsp->SecurityBufferLength = cpu_to_le16(sz); 134938c8a9a5SSteve French return 0; 135038c8a9a5SSteve French } 135138c8a9a5SSteve French 135238c8a9a5SSteve French sz = sizeof(struct challenge_message); 135338c8a9a5SSteve French sz += (strlen(ksmbd_netbios_name()) * 2 + 1 + 4) * 6; 135438c8a9a5SSteve French 135538c8a9a5SSteve French neg_blob = kzalloc(sz, GFP_KERNEL); 135638c8a9a5SSteve French if (!neg_blob) 135738c8a9a5SSteve French return -ENOMEM; 135838c8a9a5SSteve French 135938c8a9a5SSteve French chgblob = (struct challenge_message *)neg_blob; 136038c8a9a5SSteve French sz = ksmbd_build_ntlmssp_challenge_blob(chgblob, work->conn); 136138c8a9a5SSteve French if (sz < 0) { 136238c8a9a5SSteve French rc = -ENOMEM; 136338c8a9a5SSteve French goto out; 136438c8a9a5SSteve French } 136538c8a9a5SSteve French 136638c8a9a5SSteve French rc = build_spnego_ntlmssp_neg_blob(&spnego_blob, &spnego_blob_len, 136738c8a9a5SSteve French neg_blob, sz); 136838c8a9a5SSteve French if (rc) { 136938c8a9a5SSteve French rc = -ENOMEM; 137038c8a9a5SSteve French goto out; 137138c8a9a5SSteve French } 137238c8a9a5SSteve French 137338c8a9a5SSteve French sz = le16_to_cpu(rsp->SecurityBufferOffset); 137438c8a9a5SSteve French memcpy((char *)&rsp->hdr.ProtocolId + sz, spnego_blob, spnego_blob_len); 137538c8a9a5SSteve French rsp->SecurityBufferLength = cpu_to_le16(spnego_blob_len); 137638c8a9a5SSteve French 137738c8a9a5SSteve French out: 137838c8a9a5SSteve French kfree(spnego_blob); 137938c8a9a5SSteve French kfree(neg_blob); 138038c8a9a5SSteve French return rc; 138138c8a9a5SSteve French } 138238c8a9a5SSteve French 138338c8a9a5SSteve French static struct authenticate_message *user_authblob(struct ksmbd_conn *conn, 138438c8a9a5SSteve French struct smb2_sess_setup_req *req) 138538c8a9a5SSteve French { 138638c8a9a5SSteve French int sz; 138738c8a9a5SSteve French 138838c8a9a5SSteve French if (conn->use_spnego && conn->mechToken) 138938c8a9a5SSteve French return (struct authenticate_message *)conn->mechToken; 139038c8a9a5SSteve French 139138c8a9a5SSteve French sz = le16_to_cpu(req->SecurityBufferOffset); 139238c8a9a5SSteve French return (struct authenticate_message *)((char *)&req->hdr.ProtocolId 139338c8a9a5SSteve French + sz); 139438c8a9a5SSteve French } 139538c8a9a5SSteve French 139638c8a9a5SSteve French static struct ksmbd_user *session_user(struct ksmbd_conn *conn, 139738c8a9a5SSteve French struct smb2_sess_setup_req *req) 139838c8a9a5SSteve French { 139938c8a9a5SSteve French struct authenticate_message *authblob; 140038c8a9a5SSteve French struct ksmbd_user *user; 140138c8a9a5SSteve French char *name; 140238c8a9a5SSteve French unsigned int name_off, name_len, secbuf_len; 140338c8a9a5SSteve French 140438c8a9a5SSteve French secbuf_len = le16_to_cpu(req->SecurityBufferLength); 140538c8a9a5SSteve French if (secbuf_len < sizeof(struct authenticate_message)) { 140638c8a9a5SSteve French ksmbd_debug(SMB, "blob len %d too small\n", secbuf_len); 140738c8a9a5SSteve French return NULL; 140838c8a9a5SSteve French } 140938c8a9a5SSteve French authblob = user_authblob(conn, req); 141038c8a9a5SSteve French name_off = le32_to_cpu(authblob->UserName.BufferOffset); 141138c8a9a5SSteve French name_len = le16_to_cpu(authblob->UserName.Length); 141238c8a9a5SSteve French 141338c8a9a5SSteve French if (secbuf_len < (u64)name_off + name_len) 141438c8a9a5SSteve French return NULL; 141538c8a9a5SSteve French 141638c8a9a5SSteve French name = smb_strndup_from_utf16((const char *)authblob + name_off, 141738c8a9a5SSteve French name_len, 141838c8a9a5SSteve French true, 141938c8a9a5SSteve French conn->local_nls); 142038c8a9a5SSteve French if (IS_ERR(name)) { 142138c8a9a5SSteve French pr_err("cannot allocate memory\n"); 142238c8a9a5SSteve French return NULL; 142338c8a9a5SSteve French } 142438c8a9a5SSteve French 142538c8a9a5SSteve French ksmbd_debug(SMB, "session setup request for user %s\n", name); 142638c8a9a5SSteve French user = ksmbd_login_user(name); 142738c8a9a5SSteve French kfree(name); 142838c8a9a5SSteve French return user; 142938c8a9a5SSteve French } 143038c8a9a5SSteve French 143198422bddSNamjae Jeon static int ntlm_authenticate(struct ksmbd_work *work, 143298422bddSNamjae Jeon struct smb2_sess_setup_req *req, 143398422bddSNamjae Jeon struct smb2_sess_setup_rsp *rsp) 143438c8a9a5SSteve French { 143538c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 143638c8a9a5SSteve French struct ksmbd_session *sess = work->sess; 143738c8a9a5SSteve French struct channel *chann = NULL; 143838c8a9a5SSteve French struct ksmbd_user *user; 143938c8a9a5SSteve French u64 prev_id; 144038c8a9a5SSteve French int sz, rc; 144138c8a9a5SSteve French 144238c8a9a5SSteve French ksmbd_debug(SMB, "authenticate phase\n"); 144338c8a9a5SSteve French if (conn->use_spnego) { 144438c8a9a5SSteve French unsigned char *spnego_blob; 144538c8a9a5SSteve French u16 spnego_blob_len; 144638c8a9a5SSteve French 144738c8a9a5SSteve French rc = build_spnego_ntlmssp_auth_blob(&spnego_blob, 144838c8a9a5SSteve French &spnego_blob_len, 144938c8a9a5SSteve French 0); 145038c8a9a5SSteve French if (rc) 145138c8a9a5SSteve French return -ENOMEM; 145238c8a9a5SSteve French 145338c8a9a5SSteve French sz = le16_to_cpu(rsp->SecurityBufferOffset); 145438c8a9a5SSteve French memcpy((char *)&rsp->hdr.ProtocolId + sz, spnego_blob, spnego_blob_len); 145538c8a9a5SSteve French rsp->SecurityBufferLength = cpu_to_le16(spnego_blob_len); 145638c8a9a5SSteve French kfree(spnego_blob); 145738c8a9a5SSteve French inc_rfc1001_len(work->response_buf, spnego_blob_len - 1); 145838c8a9a5SSteve French } 145938c8a9a5SSteve French 146038c8a9a5SSteve French user = session_user(conn, req); 146138c8a9a5SSteve French if (!user) { 146238c8a9a5SSteve French ksmbd_debug(SMB, "Unknown user name or an error\n"); 146338c8a9a5SSteve French return -EPERM; 146438c8a9a5SSteve French } 146538c8a9a5SSteve French 146638c8a9a5SSteve French /* Check for previous session */ 146738c8a9a5SSteve French prev_id = le64_to_cpu(req->PreviousSessionId); 146838c8a9a5SSteve French if (prev_id && prev_id != sess->id) 146938c8a9a5SSteve French destroy_previous_session(conn, user, prev_id); 147038c8a9a5SSteve French 147138c8a9a5SSteve French if (sess->state == SMB2_SESSION_VALID) { 147238c8a9a5SSteve French /* 147338c8a9a5SSteve French * Reuse session if anonymous try to connect 147438c8a9a5SSteve French * on reauthetication. 147538c8a9a5SSteve French */ 147638c8a9a5SSteve French if (conn->binding == false && ksmbd_anonymous_user(user)) { 147738c8a9a5SSteve French ksmbd_free_user(user); 147838c8a9a5SSteve French return 0; 147938c8a9a5SSteve French } 148038c8a9a5SSteve French 148138c8a9a5SSteve French if (!ksmbd_compare_user(sess->user, user)) { 148238c8a9a5SSteve French ksmbd_free_user(user); 148338c8a9a5SSteve French return -EPERM; 148438c8a9a5SSteve French } 148538c8a9a5SSteve French ksmbd_free_user(user); 148638c8a9a5SSteve French } else { 148738c8a9a5SSteve French sess->user = user; 148838c8a9a5SSteve French } 148938c8a9a5SSteve French 149038c8a9a5SSteve French if (conn->binding == false && user_guest(sess->user)) { 149138c8a9a5SSteve French rsp->SessionFlags = SMB2_SESSION_FLAG_IS_GUEST_LE; 149238c8a9a5SSteve French } else { 149338c8a9a5SSteve French struct authenticate_message *authblob; 149438c8a9a5SSteve French 149538c8a9a5SSteve French authblob = user_authblob(conn, req); 149638c8a9a5SSteve French sz = le16_to_cpu(req->SecurityBufferLength); 149738c8a9a5SSteve French rc = ksmbd_decode_ntlmssp_auth_blob(authblob, sz, conn, sess); 149838c8a9a5SSteve French if (rc) { 149938c8a9a5SSteve French set_user_flag(sess->user, KSMBD_USER_FLAG_BAD_PASSWORD); 150038c8a9a5SSteve French ksmbd_debug(SMB, "authentication failed\n"); 150138c8a9a5SSteve French return -EPERM; 150238c8a9a5SSteve French } 150338c8a9a5SSteve French } 150438c8a9a5SSteve French 150538c8a9a5SSteve French /* 150638c8a9a5SSteve French * If session state is SMB2_SESSION_VALID, We can assume 150738c8a9a5SSteve French * that it is reauthentication. And the user/password 150838c8a9a5SSteve French * has been verified, so return it here. 150938c8a9a5SSteve French */ 151038c8a9a5SSteve French if (sess->state == SMB2_SESSION_VALID) { 151138c8a9a5SSteve French if (conn->binding) 151238c8a9a5SSteve French goto binding_session; 151338c8a9a5SSteve French return 0; 151438c8a9a5SSteve French } 151538c8a9a5SSteve French 151638c8a9a5SSteve French if ((rsp->SessionFlags != SMB2_SESSION_FLAG_IS_GUEST_LE && 151738c8a9a5SSteve French (conn->sign || server_conf.enforced_signing)) || 151838c8a9a5SSteve French (req->SecurityMode & SMB2_NEGOTIATE_SIGNING_REQUIRED)) 151938c8a9a5SSteve French sess->sign = true; 152038c8a9a5SSteve French 152138c8a9a5SSteve French if (smb3_encryption_negotiated(conn) && 152238c8a9a5SSteve French !(req->Flags & SMB2_SESSION_REQ_FLAG_BINDING)) { 152338c8a9a5SSteve French rc = conn->ops->generate_encryptionkey(conn, sess); 152438c8a9a5SSteve French if (rc) { 152538c8a9a5SSteve French ksmbd_debug(SMB, 152638c8a9a5SSteve French "SMB3 encryption key generation failed\n"); 152738c8a9a5SSteve French return -EINVAL; 152838c8a9a5SSteve French } 152938c8a9a5SSteve French sess->enc = true; 153038c8a9a5SSteve French if (server_conf.flags & KSMBD_GLOBAL_FLAG_SMB2_ENCRYPTION) 153138c8a9a5SSteve French rsp->SessionFlags = SMB2_SESSION_FLAG_ENCRYPT_DATA_LE; 153238c8a9a5SSteve French /* 153338c8a9a5SSteve French * signing is disable if encryption is enable 153438c8a9a5SSteve French * on this session 153538c8a9a5SSteve French */ 153638c8a9a5SSteve French sess->sign = false; 153738c8a9a5SSteve French } 153838c8a9a5SSteve French 153938c8a9a5SSteve French binding_session: 154038c8a9a5SSteve French if (conn->dialect >= SMB30_PROT_ID) { 154138c8a9a5SSteve French chann = lookup_chann_list(sess, conn); 154238c8a9a5SSteve French if (!chann) { 154338c8a9a5SSteve French chann = kmalloc(sizeof(struct channel), GFP_KERNEL); 154438c8a9a5SSteve French if (!chann) 154538c8a9a5SSteve French return -ENOMEM; 154638c8a9a5SSteve French 154738c8a9a5SSteve French chann->conn = conn; 154838c8a9a5SSteve French xa_store(&sess->ksmbd_chann_list, (long)conn, chann, GFP_KERNEL); 154938c8a9a5SSteve French } 155038c8a9a5SSteve French } 155138c8a9a5SSteve French 155238c8a9a5SSteve French if (conn->ops->generate_signingkey) { 155338c8a9a5SSteve French rc = conn->ops->generate_signingkey(sess, conn); 155438c8a9a5SSteve French if (rc) { 155538c8a9a5SSteve French ksmbd_debug(SMB, "SMB3 signing key generation failed\n"); 155638c8a9a5SSteve French return -EINVAL; 155738c8a9a5SSteve French } 155838c8a9a5SSteve French } 155938c8a9a5SSteve French 156038c8a9a5SSteve French if (!ksmbd_conn_lookup_dialect(conn)) { 156138c8a9a5SSteve French pr_err("fail to verify the dialect\n"); 156238c8a9a5SSteve French return -ENOENT; 156338c8a9a5SSteve French } 156438c8a9a5SSteve French return 0; 156538c8a9a5SSteve French } 156638c8a9a5SSteve French 156738c8a9a5SSteve French #ifdef CONFIG_SMB_SERVER_KERBEROS5 156898422bddSNamjae Jeon static int krb5_authenticate(struct ksmbd_work *work, 156998422bddSNamjae Jeon struct smb2_sess_setup_req *req, 157098422bddSNamjae Jeon struct smb2_sess_setup_rsp *rsp) 157138c8a9a5SSteve French { 157238c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 157338c8a9a5SSteve French struct ksmbd_session *sess = work->sess; 157438c8a9a5SSteve French char *in_blob, *out_blob; 157538c8a9a5SSteve French struct channel *chann = NULL; 157638c8a9a5SSteve French u64 prev_sess_id; 157738c8a9a5SSteve French int in_len, out_len; 157838c8a9a5SSteve French int retval; 157938c8a9a5SSteve French 158038c8a9a5SSteve French in_blob = (char *)&req->hdr.ProtocolId + 158138c8a9a5SSteve French le16_to_cpu(req->SecurityBufferOffset); 158238c8a9a5SSteve French in_len = le16_to_cpu(req->SecurityBufferLength); 158338c8a9a5SSteve French out_blob = (char *)&rsp->hdr.ProtocolId + 158438c8a9a5SSteve French le16_to_cpu(rsp->SecurityBufferOffset); 158538c8a9a5SSteve French out_len = work->response_sz - 158638c8a9a5SSteve French (le16_to_cpu(rsp->SecurityBufferOffset) + 4); 158738c8a9a5SSteve French 158838c8a9a5SSteve French /* Check previous session */ 158938c8a9a5SSteve French prev_sess_id = le64_to_cpu(req->PreviousSessionId); 159038c8a9a5SSteve French if (prev_sess_id && prev_sess_id != sess->id) 159138c8a9a5SSteve French destroy_previous_session(conn, sess->user, prev_sess_id); 159238c8a9a5SSteve French 159338c8a9a5SSteve French if (sess->state == SMB2_SESSION_VALID) 159438c8a9a5SSteve French ksmbd_free_user(sess->user); 159538c8a9a5SSteve French 159638c8a9a5SSteve French retval = ksmbd_krb5_authenticate(sess, in_blob, in_len, 159738c8a9a5SSteve French out_blob, &out_len); 159838c8a9a5SSteve French if (retval) { 159938c8a9a5SSteve French ksmbd_debug(SMB, "krb5 authentication failed\n"); 160038c8a9a5SSteve French return -EINVAL; 160138c8a9a5SSteve French } 160238c8a9a5SSteve French rsp->SecurityBufferLength = cpu_to_le16(out_len); 160338c8a9a5SSteve French inc_rfc1001_len(work->response_buf, out_len - 1); 160438c8a9a5SSteve French 160538c8a9a5SSteve French if ((conn->sign || server_conf.enforced_signing) || 160638c8a9a5SSteve French (req->SecurityMode & SMB2_NEGOTIATE_SIGNING_REQUIRED)) 160738c8a9a5SSteve French sess->sign = true; 160838c8a9a5SSteve French 160938c8a9a5SSteve French if (smb3_encryption_negotiated(conn)) { 161038c8a9a5SSteve French retval = conn->ops->generate_encryptionkey(conn, sess); 161138c8a9a5SSteve French if (retval) { 161238c8a9a5SSteve French ksmbd_debug(SMB, 161338c8a9a5SSteve French "SMB3 encryption key generation failed\n"); 161438c8a9a5SSteve French return -EINVAL; 161538c8a9a5SSteve French } 161638c8a9a5SSteve French sess->enc = true; 161738c8a9a5SSteve French if (server_conf.flags & KSMBD_GLOBAL_FLAG_SMB2_ENCRYPTION) 161838c8a9a5SSteve French rsp->SessionFlags = SMB2_SESSION_FLAG_ENCRYPT_DATA_LE; 161938c8a9a5SSteve French sess->sign = false; 162038c8a9a5SSteve French } 162138c8a9a5SSteve French 162238c8a9a5SSteve French if (conn->dialect >= SMB30_PROT_ID) { 162338c8a9a5SSteve French chann = lookup_chann_list(sess, conn); 162438c8a9a5SSteve French if (!chann) { 162538c8a9a5SSteve French chann = kmalloc(sizeof(struct channel), GFP_KERNEL); 162638c8a9a5SSteve French if (!chann) 162738c8a9a5SSteve French return -ENOMEM; 162838c8a9a5SSteve French 162938c8a9a5SSteve French chann->conn = conn; 163038c8a9a5SSteve French xa_store(&sess->ksmbd_chann_list, (long)conn, chann, GFP_KERNEL); 163138c8a9a5SSteve French } 163238c8a9a5SSteve French } 163338c8a9a5SSteve French 163438c8a9a5SSteve French if (conn->ops->generate_signingkey) { 163538c8a9a5SSteve French retval = conn->ops->generate_signingkey(sess, conn); 163638c8a9a5SSteve French if (retval) { 163738c8a9a5SSteve French ksmbd_debug(SMB, "SMB3 signing key generation failed\n"); 163838c8a9a5SSteve French return -EINVAL; 163938c8a9a5SSteve French } 164038c8a9a5SSteve French } 164138c8a9a5SSteve French 164238c8a9a5SSteve French if (!ksmbd_conn_lookup_dialect(conn)) { 164338c8a9a5SSteve French pr_err("fail to verify the dialect\n"); 164438c8a9a5SSteve French return -ENOENT; 164538c8a9a5SSteve French } 164638c8a9a5SSteve French return 0; 164738c8a9a5SSteve French } 164838c8a9a5SSteve French #else 164998422bddSNamjae Jeon static int krb5_authenticate(struct ksmbd_work *work, 165098422bddSNamjae Jeon struct smb2_sess_setup_req *req, 165198422bddSNamjae Jeon struct smb2_sess_setup_rsp *rsp) 165238c8a9a5SSteve French { 165338c8a9a5SSteve French return -EOPNOTSUPP; 165438c8a9a5SSteve French } 165538c8a9a5SSteve French #endif 165638c8a9a5SSteve French 165738c8a9a5SSteve French int smb2_sess_setup(struct ksmbd_work *work) 165838c8a9a5SSteve French { 165938c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 166098422bddSNamjae Jeon struct smb2_sess_setup_req *req; 166198422bddSNamjae Jeon struct smb2_sess_setup_rsp *rsp; 166238c8a9a5SSteve French struct ksmbd_session *sess; 166338c8a9a5SSteve French struct negotiate_message *negblob; 166438c8a9a5SSteve French unsigned int negblob_len, negblob_off; 166538c8a9a5SSteve French int rc = 0; 166638c8a9a5SSteve French 166738c8a9a5SSteve French ksmbd_debug(SMB, "Received request for session setup\n"); 166838c8a9a5SSteve French 166998422bddSNamjae Jeon WORK_BUFFERS(work, req, rsp); 167098422bddSNamjae Jeon 167138c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(9); 167238c8a9a5SSteve French rsp->SessionFlags = 0; 167338c8a9a5SSteve French rsp->SecurityBufferOffset = cpu_to_le16(72); 167438c8a9a5SSteve French rsp->SecurityBufferLength = 0; 167538c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 9); 167638c8a9a5SSteve French 167738c8a9a5SSteve French ksmbd_conn_lock(conn); 167838c8a9a5SSteve French if (!req->hdr.SessionId) { 167938c8a9a5SSteve French sess = ksmbd_smb2_session_create(); 168038c8a9a5SSteve French if (!sess) { 168138c8a9a5SSteve French rc = -ENOMEM; 168238c8a9a5SSteve French goto out_err; 168338c8a9a5SSteve French } 168438c8a9a5SSteve French rsp->hdr.SessionId = cpu_to_le64(sess->id); 168538c8a9a5SSteve French rc = ksmbd_session_register(conn, sess); 168638c8a9a5SSteve French if (rc) 168738c8a9a5SSteve French goto out_err; 168838c8a9a5SSteve French } else if (conn->dialect >= SMB30_PROT_ID && 168938c8a9a5SSteve French (server_conf.flags & KSMBD_GLOBAL_FLAG_SMB3_MULTICHANNEL) && 169038c8a9a5SSteve French req->Flags & SMB2_SESSION_REQ_FLAG_BINDING) { 169138c8a9a5SSteve French u64 sess_id = le64_to_cpu(req->hdr.SessionId); 169238c8a9a5SSteve French 169338c8a9a5SSteve French sess = ksmbd_session_lookup_slowpath(sess_id); 169438c8a9a5SSteve French if (!sess) { 169538c8a9a5SSteve French rc = -ENOENT; 169638c8a9a5SSteve French goto out_err; 169738c8a9a5SSteve French } 169838c8a9a5SSteve French 169938c8a9a5SSteve French if (conn->dialect != sess->dialect) { 170038c8a9a5SSteve French rc = -EINVAL; 170138c8a9a5SSteve French goto out_err; 170238c8a9a5SSteve French } 170338c8a9a5SSteve French 170438c8a9a5SSteve French if (!(req->hdr.Flags & SMB2_FLAGS_SIGNED)) { 170538c8a9a5SSteve French rc = -EINVAL; 170638c8a9a5SSteve French goto out_err; 170738c8a9a5SSteve French } 170838c8a9a5SSteve French 170938c8a9a5SSteve French if (strncmp(conn->ClientGUID, sess->ClientGUID, 171038c8a9a5SSteve French SMB2_CLIENT_GUID_SIZE)) { 171138c8a9a5SSteve French rc = -ENOENT; 171238c8a9a5SSteve French goto out_err; 171338c8a9a5SSteve French } 171438c8a9a5SSteve French 171538c8a9a5SSteve French if (sess->state == SMB2_SESSION_IN_PROGRESS) { 171638c8a9a5SSteve French rc = -EACCES; 171738c8a9a5SSteve French goto out_err; 171838c8a9a5SSteve French } 171938c8a9a5SSteve French 172038c8a9a5SSteve French if (sess->state == SMB2_SESSION_EXPIRED) { 172138c8a9a5SSteve French rc = -EFAULT; 172238c8a9a5SSteve French goto out_err; 172338c8a9a5SSteve French } 172438c8a9a5SSteve French 172538c8a9a5SSteve French if (ksmbd_conn_need_reconnect(conn)) { 172638c8a9a5SSteve French rc = -EFAULT; 172738c8a9a5SSteve French sess = NULL; 172838c8a9a5SSteve French goto out_err; 172938c8a9a5SSteve French } 173038c8a9a5SSteve French 173138c8a9a5SSteve French if (ksmbd_session_lookup(conn, sess_id)) { 173238c8a9a5SSteve French rc = -EACCES; 173338c8a9a5SSteve French goto out_err; 173438c8a9a5SSteve French } 173538c8a9a5SSteve French 173638c8a9a5SSteve French if (user_guest(sess->user)) { 173738c8a9a5SSteve French rc = -EOPNOTSUPP; 173838c8a9a5SSteve French goto out_err; 173938c8a9a5SSteve French } 174038c8a9a5SSteve French 174138c8a9a5SSteve French conn->binding = true; 174238c8a9a5SSteve French } else if ((conn->dialect < SMB30_PROT_ID || 174338c8a9a5SSteve French server_conf.flags & KSMBD_GLOBAL_FLAG_SMB3_MULTICHANNEL) && 174438c8a9a5SSteve French (req->Flags & SMB2_SESSION_REQ_FLAG_BINDING)) { 174538c8a9a5SSteve French sess = NULL; 174638c8a9a5SSteve French rc = -EACCES; 174738c8a9a5SSteve French goto out_err; 174838c8a9a5SSteve French } else { 174938c8a9a5SSteve French sess = ksmbd_session_lookup(conn, 175038c8a9a5SSteve French le64_to_cpu(req->hdr.SessionId)); 175138c8a9a5SSteve French if (!sess) { 175238c8a9a5SSteve French rc = -ENOENT; 175338c8a9a5SSteve French goto out_err; 175438c8a9a5SSteve French } 175538c8a9a5SSteve French 175638c8a9a5SSteve French if (sess->state == SMB2_SESSION_EXPIRED) { 175738c8a9a5SSteve French rc = -EFAULT; 175838c8a9a5SSteve French goto out_err; 175938c8a9a5SSteve French } 176038c8a9a5SSteve French 176138c8a9a5SSteve French if (ksmbd_conn_need_reconnect(conn)) { 176238c8a9a5SSteve French rc = -EFAULT; 176338c8a9a5SSteve French sess = NULL; 176438c8a9a5SSteve French goto out_err; 176538c8a9a5SSteve French } 176638c8a9a5SSteve French } 176738c8a9a5SSteve French work->sess = sess; 176838c8a9a5SSteve French 176938c8a9a5SSteve French negblob_off = le16_to_cpu(req->SecurityBufferOffset); 177038c8a9a5SSteve French negblob_len = le16_to_cpu(req->SecurityBufferLength); 177138c8a9a5SSteve French if (negblob_off < offsetof(struct smb2_sess_setup_req, Buffer) || 177238c8a9a5SSteve French negblob_len < offsetof(struct negotiate_message, NegotiateFlags)) { 177338c8a9a5SSteve French rc = -EINVAL; 177438c8a9a5SSteve French goto out_err; 177538c8a9a5SSteve French } 177638c8a9a5SSteve French 177738c8a9a5SSteve French negblob = (struct negotiate_message *)((char *)&req->hdr.ProtocolId + 177838c8a9a5SSteve French negblob_off); 177938c8a9a5SSteve French 178038c8a9a5SSteve French if (decode_negotiation_token(conn, negblob, negblob_len) == 0) { 178138c8a9a5SSteve French if (conn->mechToken) 178238c8a9a5SSteve French negblob = (struct negotiate_message *)conn->mechToken; 178338c8a9a5SSteve French } 178438c8a9a5SSteve French 178538c8a9a5SSteve French if (server_conf.auth_mechs & conn->auth_mechs) { 178638c8a9a5SSteve French rc = generate_preauth_hash(work); 178738c8a9a5SSteve French if (rc) 178838c8a9a5SSteve French goto out_err; 178938c8a9a5SSteve French 179038c8a9a5SSteve French if (conn->preferred_auth_mech & 179138c8a9a5SSteve French (KSMBD_AUTH_KRB5 | KSMBD_AUTH_MSKRB5)) { 179298422bddSNamjae Jeon rc = krb5_authenticate(work, req, rsp); 179338c8a9a5SSteve French if (rc) { 179438c8a9a5SSteve French rc = -EINVAL; 179538c8a9a5SSteve French goto out_err; 179638c8a9a5SSteve French } 179738c8a9a5SSteve French 179838c8a9a5SSteve French if (!ksmbd_conn_need_reconnect(conn)) { 179938c8a9a5SSteve French ksmbd_conn_set_good(conn); 180038c8a9a5SSteve French sess->state = SMB2_SESSION_VALID; 180138c8a9a5SSteve French } 180238c8a9a5SSteve French kfree(sess->Preauth_HashValue); 180338c8a9a5SSteve French sess->Preauth_HashValue = NULL; 180438c8a9a5SSteve French } else if (conn->preferred_auth_mech == KSMBD_AUTH_NTLMSSP) { 180538c8a9a5SSteve French if (negblob->MessageType == NtLmNegotiate) { 180698422bddSNamjae Jeon rc = ntlm_negotiate(work, negblob, negblob_len, rsp); 180738c8a9a5SSteve French if (rc) 180838c8a9a5SSteve French goto out_err; 180938c8a9a5SSteve French rsp->hdr.Status = 181038c8a9a5SSteve French STATUS_MORE_PROCESSING_REQUIRED; 181138c8a9a5SSteve French /* 181238c8a9a5SSteve French * Note: here total size -1 is done as an 181338c8a9a5SSteve French * adjustment for 0 size blob 181438c8a9a5SSteve French */ 181538c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 181638c8a9a5SSteve French le16_to_cpu(rsp->SecurityBufferLength) - 1); 181738c8a9a5SSteve French 181838c8a9a5SSteve French } else if (negblob->MessageType == NtLmAuthenticate) { 181998422bddSNamjae Jeon rc = ntlm_authenticate(work, req, rsp); 182038c8a9a5SSteve French if (rc) 182138c8a9a5SSteve French goto out_err; 182238c8a9a5SSteve French 182338c8a9a5SSteve French if (!ksmbd_conn_need_reconnect(conn)) { 182438c8a9a5SSteve French ksmbd_conn_set_good(conn); 182538c8a9a5SSteve French sess->state = SMB2_SESSION_VALID; 182638c8a9a5SSteve French } 182738c8a9a5SSteve French if (conn->binding) { 182838c8a9a5SSteve French struct preauth_session *preauth_sess; 182938c8a9a5SSteve French 183038c8a9a5SSteve French preauth_sess = 183138c8a9a5SSteve French ksmbd_preauth_session_lookup(conn, sess->id); 183238c8a9a5SSteve French if (preauth_sess) { 183338c8a9a5SSteve French list_del(&preauth_sess->preauth_entry); 183438c8a9a5SSteve French kfree(preauth_sess); 183538c8a9a5SSteve French } 183638c8a9a5SSteve French } 183738c8a9a5SSteve French kfree(sess->Preauth_HashValue); 183838c8a9a5SSteve French sess->Preauth_HashValue = NULL; 183938c8a9a5SSteve French } else { 184038c8a9a5SSteve French pr_info_ratelimited("Unknown NTLMSSP message type : 0x%x\n", 184138c8a9a5SSteve French le32_to_cpu(negblob->MessageType)); 184238c8a9a5SSteve French rc = -EINVAL; 184338c8a9a5SSteve French } 184438c8a9a5SSteve French } else { 184538c8a9a5SSteve French /* TODO: need one more negotiation */ 184638c8a9a5SSteve French pr_err("Not support the preferred authentication\n"); 184738c8a9a5SSteve French rc = -EINVAL; 184838c8a9a5SSteve French } 184938c8a9a5SSteve French } else { 185038c8a9a5SSteve French pr_err("Not support authentication\n"); 185138c8a9a5SSteve French rc = -EINVAL; 185238c8a9a5SSteve French } 185338c8a9a5SSteve French 185438c8a9a5SSteve French out_err: 185538c8a9a5SSteve French if (rc == -EINVAL) 185638c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 185738c8a9a5SSteve French else if (rc == -ENOENT) 185838c8a9a5SSteve French rsp->hdr.Status = STATUS_USER_SESSION_DELETED; 185938c8a9a5SSteve French else if (rc == -EACCES) 186038c8a9a5SSteve French rsp->hdr.Status = STATUS_REQUEST_NOT_ACCEPTED; 186138c8a9a5SSteve French else if (rc == -EFAULT) 186238c8a9a5SSteve French rsp->hdr.Status = STATUS_NETWORK_SESSION_EXPIRED; 186338c8a9a5SSteve French else if (rc == -ENOMEM) 186438c8a9a5SSteve French rsp->hdr.Status = STATUS_INSUFFICIENT_RESOURCES; 186538c8a9a5SSteve French else if (rc == -EOPNOTSUPP) 186638c8a9a5SSteve French rsp->hdr.Status = STATUS_NOT_SUPPORTED; 186738c8a9a5SSteve French else if (rc) 186838c8a9a5SSteve French rsp->hdr.Status = STATUS_LOGON_FAILURE; 186938c8a9a5SSteve French 187038c8a9a5SSteve French if (conn->use_spnego && conn->mechToken) { 187138c8a9a5SSteve French kfree(conn->mechToken); 187238c8a9a5SSteve French conn->mechToken = NULL; 187338c8a9a5SSteve French } 187438c8a9a5SSteve French 187538c8a9a5SSteve French if (rc < 0) { 187638c8a9a5SSteve French /* 187738c8a9a5SSteve French * SecurityBufferOffset should be set to zero 187838c8a9a5SSteve French * in session setup error response. 187938c8a9a5SSteve French */ 188038c8a9a5SSteve French rsp->SecurityBufferOffset = 0; 188138c8a9a5SSteve French 188238c8a9a5SSteve French if (sess) { 188338c8a9a5SSteve French bool try_delay = false; 188438c8a9a5SSteve French 188538c8a9a5SSteve French /* 188638c8a9a5SSteve French * To avoid dictionary attacks (repeated session setups rapidly sent) to 188738c8a9a5SSteve French * connect to server, ksmbd make a delay of a 5 seconds on session setup 188838c8a9a5SSteve French * failure to make it harder to send enough random connection requests 188938c8a9a5SSteve French * to break into a server. 189038c8a9a5SSteve French */ 189138c8a9a5SSteve French if (sess->user && sess->user->flags & KSMBD_USER_FLAG_DELAY_SESSION) 189238c8a9a5SSteve French try_delay = true; 189338c8a9a5SSteve French 189438c8a9a5SSteve French sess->last_active = jiffies; 189538c8a9a5SSteve French sess->state = SMB2_SESSION_EXPIRED; 189638c8a9a5SSteve French if (try_delay) { 189738c8a9a5SSteve French ksmbd_conn_set_need_reconnect(conn); 189838c8a9a5SSteve French ssleep(5); 189938c8a9a5SSteve French ksmbd_conn_set_need_negotiate(conn); 190038c8a9a5SSteve French } 190138c8a9a5SSteve French } 190238c8a9a5SSteve French } 190338c8a9a5SSteve French 190438c8a9a5SSteve French ksmbd_conn_unlock(conn); 190538c8a9a5SSteve French return rc; 190638c8a9a5SSteve French } 190738c8a9a5SSteve French 190838c8a9a5SSteve French /** 190938c8a9a5SSteve French * smb2_tree_connect() - handler for smb2 tree connect command 191038c8a9a5SSteve French * @work: smb work containing smb request buffer 191138c8a9a5SSteve French * 191238c8a9a5SSteve French * Return: 0 on success, otherwise error 191338c8a9a5SSteve French */ 191438c8a9a5SSteve French int smb2_tree_connect(struct ksmbd_work *work) 191538c8a9a5SSteve French { 191638c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 19177b7d709eSNamjae Jeon struct smb2_tree_connect_req *req; 19187b7d709eSNamjae Jeon struct smb2_tree_connect_rsp *rsp; 191938c8a9a5SSteve French struct ksmbd_session *sess = work->sess; 192038c8a9a5SSteve French char *treename = NULL, *name = NULL; 192138c8a9a5SSteve French struct ksmbd_tree_conn_status status; 192238c8a9a5SSteve French struct ksmbd_share_config *share; 192338c8a9a5SSteve French int rc = -EINVAL; 192438c8a9a5SSteve French 19257b7d709eSNamjae Jeon WORK_BUFFERS(work, req, rsp); 19267b7d709eSNamjae Jeon 192738c8a9a5SSteve French treename = smb_strndup_from_utf16(req->Buffer, 192838c8a9a5SSteve French le16_to_cpu(req->PathLength), true, 192938c8a9a5SSteve French conn->local_nls); 193038c8a9a5SSteve French if (IS_ERR(treename)) { 193138c8a9a5SSteve French pr_err("treename is NULL\n"); 193238c8a9a5SSteve French status.ret = KSMBD_TREE_CONN_STATUS_ERROR; 193338c8a9a5SSteve French goto out_err1; 193438c8a9a5SSteve French } 193538c8a9a5SSteve French 193638c8a9a5SSteve French name = ksmbd_extract_sharename(conn->um, treename); 193738c8a9a5SSteve French if (IS_ERR(name)) { 193838c8a9a5SSteve French status.ret = KSMBD_TREE_CONN_STATUS_ERROR; 193938c8a9a5SSteve French goto out_err1; 194038c8a9a5SSteve French } 194138c8a9a5SSteve French 194238c8a9a5SSteve French ksmbd_debug(SMB, "tree connect request for tree %s treename %s\n", 194338c8a9a5SSteve French name, treename); 194438c8a9a5SSteve French 194538c8a9a5SSteve French status = ksmbd_tree_conn_connect(conn, sess, name); 194638c8a9a5SSteve French if (status.ret == KSMBD_TREE_CONN_STATUS_OK) 194738c8a9a5SSteve French rsp->hdr.Id.SyncId.TreeId = cpu_to_le32(status.tree_conn->id); 194838c8a9a5SSteve French else 194938c8a9a5SSteve French goto out_err1; 195038c8a9a5SSteve French 195138c8a9a5SSteve French share = status.tree_conn->share_conf; 195238c8a9a5SSteve French if (test_share_config_flag(share, KSMBD_SHARE_FLAG_PIPE)) { 195338c8a9a5SSteve French ksmbd_debug(SMB, "IPC share path request\n"); 195438c8a9a5SSteve French rsp->ShareType = SMB2_SHARE_TYPE_PIPE; 195538c8a9a5SSteve French rsp->MaximalAccess = FILE_READ_DATA_LE | FILE_READ_EA_LE | 195638c8a9a5SSteve French FILE_EXECUTE_LE | FILE_READ_ATTRIBUTES_LE | 195738c8a9a5SSteve French FILE_DELETE_LE | FILE_READ_CONTROL_LE | 195838c8a9a5SSteve French FILE_WRITE_DAC_LE | FILE_WRITE_OWNER_LE | 195938c8a9a5SSteve French FILE_SYNCHRONIZE_LE; 196038c8a9a5SSteve French } else { 196138c8a9a5SSteve French rsp->ShareType = SMB2_SHARE_TYPE_DISK; 196238c8a9a5SSteve French rsp->MaximalAccess = FILE_READ_DATA_LE | FILE_READ_EA_LE | 196338c8a9a5SSteve French FILE_EXECUTE_LE | FILE_READ_ATTRIBUTES_LE; 196438c8a9a5SSteve French if (test_tree_conn_flag(status.tree_conn, 196538c8a9a5SSteve French KSMBD_TREE_CONN_FLAG_WRITABLE)) { 196638c8a9a5SSteve French rsp->MaximalAccess |= FILE_WRITE_DATA_LE | 196738c8a9a5SSteve French FILE_APPEND_DATA_LE | FILE_WRITE_EA_LE | 196838c8a9a5SSteve French FILE_DELETE_LE | FILE_WRITE_ATTRIBUTES_LE | 196938c8a9a5SSteve French FILE_DELETE_CHILD_LE | FILE_READ_CONTROL_LE | 197038c8a9a5SSteve French FILE_WRITE_DAC_LE | FILE_WRITE_OWNER_LE | 197138c8a9a5SSteve French FILE_SYNCHRONIZE_LE; 197238c8a9a5SSteve French } 197338c8a9a5SSteve French } 197438c8a9a5SSteve French 197538c8a9a5SSteve French status.tree_conn->maximal_access = le32_to_cpu(rsp->MaximalAccess); 197638c8a9a5SSteve French if (conn->posix_ext_supported) 197738c8a9a5SSteve French status.tree_conn->posix_extensions = true; 197838c8a9a5SSteve French 197938c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(16); 198038c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 16); 198138c8a9a5SSteve French out_err1: 198238c8a9a5SSteve French rsp->Capabilities = 0; 198338c8a9a5SSteve French rsp->Reserved = 0; 198438c8a9a5SSteve French /* default manual caching */ 198538c8a9a5SSteve French rsp->ShareFlags = SMB2_SHAREFLAG_MANUAL_CACHING; 198638c8a9a5SSteve French 198738c8a9a5SSteve French if (!IS_ERR(treename)) 198838c8a9a5SSteve French kfree(treename); 198938c8a9a5SSteve French if (!IS_ERR(name)) 199038c8a9a5SSteve French kfree(name); 199138c8a9a5SSteve French 199238c8a9a5SSteve French switch (status.ret) { 199338c8a9a5SSteve French case KSMBD_TREE_CONN_STATUS_OK: 199438c8a9a5SSteve French rsp->hdr.Status = STATUS_SUCCESS; 199538c8a9a5SSteve French rc = 0; 199638c8a9a5SSteve French break; 199738c8a9a5SSteve French case -ESTALE: 199838c8a9a5SSteve French case -ENOENT: 199938c8a9a5SSteve French case KSMBD_TREE_CONN_STATUS_NO_SHARE: 200038c8a9a5SSteve French rsp->hdr.Status = STATUS_BAD_NETWORK_NAME; 200138c8a9a5SSteve French break; 200238c8a9a5SSteve French case -ENOMEM: 200338c8a9a5SSteve French case KSMBD_TREE_CONN_STATUS_NOMEM: 200438c8a9a5SSteve French rsp->hdr.Status = STATUS_NO_MEMORY; 200538c8a9a5SSteve French break; 200638c8a9a5SSteve French case KSMBD_TREE_CONN_STATUS_ERROR: 200738c8a9a5SSteve French case KSMBD_TREE_CONN_STATUS_TOO_MANY_CONNS: 200838c8a9a5SSteve French case KSMBD_TREE_CONN_STATUS_TOO_MANY_SESSIONS: 200938c8a9a5SSteve French rsp->hdr.Status = STATUS_ACCESS_DENIED; 201038c8a9a5SSteve French break; 201138c8a9a5SSteve French case -EINVAL: 201238c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 201338c8a9a5SSteve French break; 201438c8a9a5SSteve French default: 201538c8a9a5SSteve French rsp->hdr.Status = STATUS_ACCESS_DENIED; 201638c8a9a5SSteve French } 201738c8a9a5SSteve French 201838c8a9a5SSteve French if (status.ret != KSMBD_TREE_CONN_STATUS_OK) 201938c8a9a5SSteve French smb2_set_err_rsp(work); 202038c8a9a5SSteve French 202138c8a9a5SSteve French return rc; 202238c8a9a5SSteve French } 202338c8a9a5SSteve French 202438c8a9a5SSteve French /** 202538c8a9a5SSteve French * smb2_create_open_flags() - convert smb open flags to unix open flags 202638c8a9a5SSteve French * @file_present: is file already present 202738c8a9a5SSteve French * @access: file access flags 202838c8a9a5SSteve French * @disposition: file disposition flags 202938c8a9a5SSteve French * @may_flags: set with MAY_ flags 203038c8a9a5SSteve French * 203138c8a9a5SSteve French * Return: file open flags 203238c8a9a5SSteve French */ 203338c8a9a5SSteve French static int smb2_create_open_flags(bool file_present, __le32 access, 203438c8a9a5SSteve French __le32 disposition, 203538c8a9a5SSteve French int *may_flags) 203638c8a9a5SSteve French { 203738c8a9a5SSteve French int oflags = O_NONBLOCK | O_LARGEFILE; 203838c8a9a5SSteve French 203938c8a9a5SSteve French if (access & FILE_READ_DESIRED_ACCESS_LE && 204038c8a9a5SSteve French access & FILE_WRITE_DESIRE_ACCESS_LE) { 204138c8a9a5SSteve French oflags |= O_RDWR; 204238c8a9a5SSteve French *may_flags = MAY_OPEN | MAY_READ | MAY_WRITE; 204338c8a9a5SSteve French } else if (access & FILE_WRITE_DESIRE_ACCESS_LE) { 204438c8a9a5SSteve French oflags |= O_WRONLY; 204538c8a9a5SSteve French *may_flags = MAY_OPEN | MAY_WRITE; 204638c8a9a5SSteve French } else { 204738c8a9a5SSteve French oflags |= O_RDONLY; 204838c8a9a5SSteve French *may_flags = MAY_OPEN | MAY_READ; 204938c8a9a5SSteve French } 205038c8a9a5SSteve French 205138c8a9a5SSteve French if (access == FILE_READ_ATTRIBUTES_LE) 205238c8a9a5SSteve French oflags |= O_PATH; 205338c8a9a5SSteve French 205438c8a9a5SSteve French if (file_present) { 205538c8a9a5SSteve French switch (disposition & FILE_CREATE_MASK_LE) { 205638c8a9a5SSteve French case FILE_OPEN_LE: 205738c8a9a5SSteve French case FILE_CREATE_LE: 205838c8a9a5SSteve French break; 205938c8a9a5SSteve French case FILE_SUPERSEDE_LE: 206038c8a9a5SSteve French case FILE_OVERWRITE_LE: 206138c8a9a5SSteve French case FILE_OVERWRITE_IF_LE: 206238c8a9a5SSteve French oflags |= O_TRUNC; 206338c8a9a5SSteve French break; 206438c8a9a5SSteve French default: 206538c8a9a5SSteve French break; 206638c8a9a5SSteve French } 206738c8a9a5SSteve French } else { 206838c8a9a5SSteve French switch (disposition & FILE_CREATE_MASK_LE) { 206938c8a9a5SSteve French case FILE_SUPERSEDE_LE: 207038c8a9a5SSteve French case FILE_CREATE_LE: 207138c8a9a5SSteve French case FILE_OPEN_IF_LE: 207238c8a9a5SSteve French case FILE_OVERWRITE_IF_LE: 207338c8a9a5SSteve French oflags |= O_CREAT; 207438c8a9a5SSteve French break; 207538c8a9a5SSteve French case FILE_OPEN_LE: 207638c8a9a5SSteve French case FILE_OVERWRITE_LE: 207738c8a9a5SSteve French oflags &= ~O_CREAT; 207838c8a9a5SSteve French break; 207938c8a9a5SSteve French default: 208038c8a9a5SSteve French break; 208138c8a9a5SSteve French } 208238c8a9a5SSteve French } 208338c8a9a5SSteve French 208438c8a9a5SSteve French return oflags; 208538c8a9a5SSteve French } 208638c8a9a5SSteve French 208738c8a9a5SSteve French /** 208838c8a9a5SSteve French * smb2_tree_disconnect() - handler for smb tree connect request 208938c8a9a5SSteve French * @work: smb work containing request buffer 209038c8a9a5SSteve French * 209138c8a9a5SSteve French * Return: 0 209238c8a9a5SSteve French */ 209338c8a9a5SSteve French int smb2_tree_disconnect(struct ksmbd_work *work) 209438c8a9a5SSteve French { 20957b7d709eSNamjae Jeon struct smb2_tree_disconnect_rsp *rsp; 20967b7d709eSNamjae Jeon struct smb2_tree_disconnect_req *req; 209738c8a9a5SSteve French struct ksmbd_session *sess = work->sess; 209838c8a9a5SSteve French struct ksmbd_tree_connect *tcon = work->tcon; 209938c8a9a5SSteve French 21007b7d709eSNamjae Jeon WORK_BUFFERS(work, req, rsp); 21017b7d709eSNamjae Jeon 210238c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(4); 210338c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 4); 210438c8a9a5SSteve French 210538c8a9a5SSteve French ksmbd_debug(SMB, "request\n"); 210638c8a9a5SSteve French 210738c8a9a5SSteve French if (!tcon || test_and_set_bit(TREE_CONN_EXPIRE, &tcon->status)) { 210838c8a9a5SSteve French ksmbd_debug(SMB, "Invalid tid %d\n", req->hdr.Id.SyncId.TreeId); 210938c8a9a5SSteve French 211038c8a9a5SSteve French rsp->hdr.Status = STATUS_NETWORK_NAME_DELETED; 211138c8a9a5SSteve French smb2_set_err_rsp(work); 211238c8a9a5SSteve French return 0; 211338c8a9a5SSteve French } 211438c8a9a5SSteve French 211538c8a9a5SSteve French ksmbd_close_tree_conn_fds(work); 211638c8a9a5SSteve French ksmbd_tree_conn_disconnect(sess, tcon); 211738c8a9a5SSteve French work->tcon = NULL; 211838c8a9a5SSteve French return 0; 211938c8a9a5SSteve French } 212038c8a9a5SSteve French 212138c8a9a5SSteve French /** 212238c8a9a5SSteve French * smb2_session_logoff() - handler for session log off request 212338c8a9a5SSteve French * @work: smb work containing request buffer 212438c8a9a5SSteve French * 212538c8a9a5SSteve French * Return: 0 212638c8a9a5SSteve French */ 212738c8a9a5SSteve French int smb2_session_logoff(struct ksmbd_work *work) 212838c8a9a5SSteve French { 212938c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 21307b7d709eSNamjae Jeon struct smb2_logoff_req *req; 21317b7d709eSNamjae Jeon struct smb2_logoff_rsp *rsp; 213238c8a9a5SSteve French struct ksmbd_session *sess; 21337b7d709eSNamjae Jeon u64 sess_id; 21347b7d709eSNamjae Jeon 21357b7d709eSNamjae Jeon WORK_BUFFERS(work, req, rsp); 21367b7d709eSNamjae Jeon 21377b7d709eSNamjae Jeon sess_id = le64_to_cpu(req->hdr.SessionId); 213838c8a9a5SSteve French 213938c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(4); 214038c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 4); 214138c8a9a5SSteve French 214238c8a9a5SSteve French ksmbd_debug(SMB, "request\n"); 214338c8a9a5SSteve French 214438c8a9a5SSteve French ksmbd_all_conn_set_status(sess_id, KSMBD_SESS_NEED_RECONNECT); 214538c8a9a5SSteve French ksmbd_close_session_fds(work); 214638c8a9a5SSteve French ksmbd_conn_wait_idle(conn, sess_id); 214738c8a9a5SSteve French 214838c8a9a5SSteve French /* 214938c8a9a5SSteve French * Re-lookup session to validate if session is deleted 215038c8a9a5SSteve French * while waiting request complete 215138c8a9a5SSteve French */ 215238c8a9a5SSteve French sess = ksmbd_session_lookup_all(conn, sess_id); 215338c8a9a5SSteve French if (ksmbd_tree_conn_session_logoff(sess)) { 215438c8a9a5SSteve French ksmbd_debug(SMB, "Invalid tid %d\n", req->hdr.Id.SyncId.TreeId); 215538c8a9a5SSteve French rsp->hdr.Status = STATUS_NETWORK_NAME_DELETED; 215638c8a9a5SSteve French smb2_set_err_rsp(work); 215738c8a9a5SSteve French return 0; 215838c8a9a5SSteve French } 215938c8a9a5SSteve French 216038c8a9a5SSteve French ksmbd_destroy_file_table(&sess->file_table); 216138c8a9a5SSteve French sess->state = SMB2_SESSION_EXPIRED; 216238c8a9a5SSteve French 216338c8a9a5SSteve French ksmbd_free_user(sess->user); 216438c8a9a5SSteve French sess->user = NULL; 216538c8a9a5SSteve French ksmbd_all_conn_set_status(sess_id, KSMBD_SESS_NEED_NEGOTIATE); 216638c8a9a5SSteve French return 0; 216738c8a9a5SSteve French } 216838c8a9a5SSteve French 216938c8a9a5SSteve French /** 217038c8a9a5SSteve French * create_smb2_pipe() - create IPC pipe 217138c8a9a5SSteve French * @work: smb work containing request buffer 217238c8a9a5SSteve French * 217338c8a9a5SSteve French * Return: 0 on success, otherwise error 217438c8a9a5SSteve French */ 217538c8a9a5SSteve French static noinline int create_smb2_pipe(struct ksmbd_work *work) 217638c8a9a5SSteve French { 21777b7d709eSNamjae Jeon struct smb2_create_rsp *rsp; 21787b7d709eSNamjae Jeon struct smb2_create_req *req; 217938c8a9a5SSteve French int id; 218038c8a9a5SSteve French int err; 218138c8a9a5SSteve French char *name; 218238c8a9a5SSteve French 21837b7d709eSNamjae Jeon WORK_BUFFERS(work, req, rsp); 21847b7d709eSNamjae Jeon 218538c8a9a5SSteve French name = smb_strndup_from_utf16(req->Buffer, le16_to_cpu(req->NameLength), 218638c8a9a5SSteve French 1, work->conn->local_nls); 218738c8a9a5SSteve French if (IS_ERR(name)) { 218838c8a9a5SSteve French rsp->hdr.Status = STATUS_NO_MEMORY; 218938c8a9a5SSteve French err = PTR_ERR(name); 219038c8a9a5SSteve French goto out; 219138c8a9a5SSteve French } 219238c8a9a5SSteve French 219338c8a9a5SSteve French id = ksmbd_session_rpc_open(work->sess, name); 219438c8a9a5SSteve French if (id < 0) { 219538c8a9a5SSteve French pr_err("Unable to open RPC pipe: %d\n", id); 219638c8a9a5SSteve French err = id; 219738c8a9a5SSteve French goto out; 219838c8a9a5SSteve French } 219938c8a9a5SSteve French 220038c8a9a5SSteve French rsp->hdr.Status = STATUS_SUCCESS; 220138c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(89); 220238c8a9a5SSteve French rsp->OplockLevel = SMB2_OPLOCK_LEVEL_NONE; 220338c8a9a5SSteve French rsp->Flags = 0; 220438c8a9a5SSteve French rsp->CreateAction = cpu_to_le32(FILE_OPENED); 220538c8a9a5SSteve French 220638c8a9a5SSteve French rsp->CreationTime = cpu_to_le64(0); 220738c8a9a5SSteve French rsp->LastAccessTime = cpu_to_le64(0); 220838c8a9a5SSteve French rsp->ChangeTime = cpu_to_le64(0); 220938c8a9a5SSteve French rsp->AllocationSize = cpu_to_le64(0); 221038c8a9a5SSteve French rsp->EndofFile = cpu_to_le64(0); 221138c8a9a5SSteve French rsp->FileAttributes = FILE_ATTRIBUTE_NORMAL_LE; 221238c8a9a5SSteve French rsp->Reserved2 = 0; 221338c8a9a5SSteve French rsp->VolatileFileId = id; 221438c8a9a5SSteve French rsp->PersistentFileId = 0; 221538c8a9a5SSteve French rsp->CreateContextsOffset = 0; 221638c8a9a5SSteve French rsp->CreateContextsLength = 0; 221738c8a9a5SSteve French 221838c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 88); /* StructureSize - 1*/ 221938c8a9a5SSteve French kfree(name); 222038c8a9a5SSteve French return 0; 222138c8a9a5SSteve French 222238c8a9a5SSteve French out: 222338c8a9a5SSteve French switch (err) { 222438c8a9a5SSteve French case -EINVAL: 222538c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 222638c8a9a5SSteve French break; 222738c8a9a5SSteve French case -ENOSPC: 222838c8a9a5SSteve French case -ENOMEM: 222938c8a9a5SSteve French rsp->hdr.Status = STATUS_NO_MEMORY; 223038c8a9a5SSteve French break; 223138c8a9a5SSteve French } 223238c8a9a5SSteve French 223338c8a9a5SSteve French if (!IS_ERR(name)) 223438c8a9a5SSteve French kfree(name); 223538c8a9a5SSteve French 223638c8a9a5SSteve French smb2_set_err_rsp(work); 223738c8a9a5SSteve French return err; 223838c8a9a5SSteve French } 223938c8a9a5SSteve French 224038c8a9a5SSteve French /** 224138c8a9a5SSteve French * smb2_set_ea() - handler for setting extended attributes using set 224238c8a9a5SSteve French * info command 224338c8a9a5SSteve French * @eabuf: set info command buffer 224438c8a9a5SSteve French * @buf_len: set info command buffer length 224538c8a9a5SSteve French * @path: dentry path for get ea 224638c8a9a5SSteve French * 224738c8a9a5SSteve French * Return: 0 on success, otherwise error 224838c8a9a5SSteve French */ 224938c8a9a5SSteve French static int smb2_set_ea(struct smb2_ea_info *eabuf, unsigned int buf_len, 225038c8a9a5SSteve French const struct path *path) 225138c8a9a5SSteve French { 225238c8a9a5SSteve French struct mnt_idmap *idmap = mnt_idmap(path->mnt); 225338c8a9a5SSteve French char *attr_name = NULL, *value; 225438c8a9a5SSteve French int rc = 0; 225538c8a9a5SSteve French unsigned int next = 0; 225638c8a9a5SSteve French 225738c8a9a5SSteve French if (buf_len < sizeof(struct smb2_ea_info) + eabuf->EaNameLength + 225838c8a9a5SSteve French le16_to_cpu(eabuf->EaValueLength)) 225938c8a9a5SSteve French return -EINVAL; 226038c8a9a5SSteve French 226138c8a9a5SSteve French attr_name = kmalloc(XATTR_NAME_MAX + 1, GFP_KERNEL); 226238c8a9a5SSteve French if (!attr_name) 226338c8a9a5SSteve French return -ENOMEM; 226438c8a9a5SSteve French 226538c8a9a5SSteve French do { 226638c8a9a5SSteve French if (!eabuf->EaNameLength) 226738c8a9a5SSteve French goto next; 226838c8a9a5SSteve French 226938c8a9a5SSteve French ksmbd_debug(SMB, 227038c8a9a5SSteve French "name : <%s>, name_len : %u, value_len : %u, next : %u\n", 227138c8a9a5SSteve French eabuf->name, eabuf->EaNameLength, 227238c8a9a5SSteve French le16_to_cpu(eabuf->EaValueLength), 227338c8a9a5SSteve French le32_to_cpu(eabuf->NextEntryOffset)); 227438c8a9a5SSteve French 227538c8a9a5SSteve French if (eabuf->EaNameLength > 227638c8a9a5SSteve French (XATTR_NAME_MAX - XATTR_USER_PREFIX_LEN)) { 227738c8a9a5SSteve French rc = -EINVAL; 227838c8a9a5SSteve French break; 227938c8a9a5SSteve French } 228038c8a9a5SSteve French 228138c8a9a5SSteve French memcpy(attr_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN); 228238c8a9a5SSteve French memcpy(&attr_name[XATTR_USER_PREFIX_LEN], eabuf->name, 228338c8a9a5SSteve French eabuf->EaNameLength); 228438c8a9a5SSteve French attr_name[XATTR_USER_PREFIX_LEN + eabuf->EaNameLength] = '\0'; 228538c8a9a5SSteve French value = (char *)&eabuf->name + eabuf->EaNameLength + 1; 228638c8a9a5SSteve French 228738c8a9a5SSteve French if (!eabuf->EaValueLength) { 228838c8a9a5SSteve French rc = ksmbd_vfs_casexattr_len(idmap, 228938c8a9a5SSteve French path->dentry, 229038c8a9a5SSteve French attr_name, 229138c8a9a5SSteve French XATTR_USER_PREFIX_LEN + 229238c8a9a5SSteve French eabuf->EaNameLength); 229338c8a9a5SSteve French 229438c8a9a5SSteve French /* delete the EA only when it exits */ 229538c8a9a5SSteve French if (rc > 0) { 229638c8a9a5SSteve French rc = ksmbd_vfs_remove_xattr(idmap, 229740b268d3SNamjae Jeon path, 229838c8a9a5SSteve French attr_name); 229938c8a9a5SSteve French 230038c8a9a5SSteve French if (rc < 0) { 230138c8a9a5SSteve French ksmbd_debug(SMB, 230238c8a9a5SSteve French "remove xattr failed(%d)\n", 230338c8a9a5SSteve French rc); 230438c8a9a5SSteve French break; 230538c8a9a5SSteve French } 230638c8a9a5SSteve French } 230738c8a9a5SSteve French 230838c8a9a5SSteve French /* if the EA doesn't exist, just do nothing. */ 230938c8a9a5SSteve French rc = 0; 231038c8a9a5SSteve French } else { 231140b268d3SNamjae Jeon rc = ksmbd_vfs_setxattr(idmap, path, attr_name, value, 231238c8a9a5SSteve French le16_to_cpu(eabuf->EaValueLength), 0); 231338c8a9a5SSteve French if (rc < 0) { 231438c8a9a5SSteve French ksmbd_debug(SMB, 231538c8a9a5SSteve French "ksmbd_vfs_setxattr is failed(%d)\n", 231638c8a9a5SSteve French rc); 231738c8a9a5SSteve French break; 231838c8a9a5SSteve French } 231938c8a9a5SSteve French } 232038c8a9a5SSteve French 232138c8a9a5SSteve French next: 232238c8a9a5SSteve French next = le32_to_cpu(eabuf->NextEntryOffset); 232338c8a9a5SSteve French if (next == 0 || buf_len < next) 232438c8a9a5SSteve French break; 232538c8a9a5SSteve French buf_len -= next; 232638c8a9a5SSteve French eabuf = (struct smb2_ea_info *)((char *)eabuf + next); 232738c8a9a5SSteve French if (next < (u32)eabuf->EaNameLength + le16_to_cpu(eabuf->EaValueLength)) 232838c8a9a5SSteve French break; 232938c8a9a5SSteve French 233038c8a9a5SSteve French } while (next != 0); 233138c8a9a5SSteve French 233238c8a9a5SSteve French kfree(attr_name); 233338c8a9a5SSteve French return rc; 233438c8a9a5SSteve French } 233538c8a9a5SSteve French 233638c8a9a5SSteve French static noinline int smb2_set_stream_name_xattr(const struct path *path, 233738c8a9a5SSteve French struct ksmbd_file *fp, 233838c8a9a5SSteve French char *stream_name, int s_type) 233938c8a9a5SSteve French { 234038c8a9a5SSteve French struct mnt_idmap *idmap = mnt_idmap(path->mnt); 234138c8a9a5SSteve French size_t xattr_stream_size; 234238c8a9a5SSteve French char *xattr_stream_name; 234338c8a9a5SSteve French int rc; 234438c8a9a5SSteve French 234538c8a9a5SSteve French rc = ksmbd_vfs_xattr_stream_name(stream_name, 234638c8a9a5SSteve French &xattr_stream_name, 234738c8a9a5SSteve French &xattr_stream_size, 234838c8a9a5SSteve French s_type); 234938c8a9a5SSteve French if (rc) 235038c8a9a5SSteve French return rc; 235138c8a9a5SSteve French 235238c8a9a5SSteve French fp->stream.name = xattr_stream_name; 235338c8a9a5SSteve French fp->stream.size = xattr_stream_size; 235438c8a9a5SSteve French 235538c8a9a5SSteve French /* Check if there is stream prefix in xattr space */ 235638c8a9a5SSteve French rc = ksmbd_vfs_casexattr_len(idmap, 235738c8a9a5SSteve French path->dentry, 235838c8a9a5SSteve French xattr_stream_name, 235938c8a9a5SSteve French xattr_stream_size); 236038c8a9a5SSteve French if (rc >= 0) 236138c8a9a5SSteve French return 0; 236238c8a9a5SSteve French 236338c8a9a5SSteve French if (fp->cdoption == FILE_OPEN_LE) { 236438c8a9a5SSteve French ksmbd_debug(SMB, "XATTR stream name lookup failed: %d\n", rc); 236538c8a9a5SSteve French return -EBADF; 236638c8a9a5SSteve French } 236738c8a9a5SSteve French 236840b268d3SNamjae Jeon rc = ksmbd_vfs_setxattr(idmap, path, xattr_stream_name, NULL, 0, 0); 236938c8a9a5SSteve French if (rc < 0) 237038c8a9a5SSteve French pr_err("Failed to store XATTR stream name :%d\n", rc); 237138c8a9a5SSteve French return 0; 237238c8a9a5SSteve French } 237338c8a9a5SSteve French 237438c8a9a5SSteve French static int smb2_remove_smb_xattrs(const struct path *path) 237538c8a9a5SSteve French { 237638c8a9a5SSteve French struct mnt_idmap *idmap = mnt_idmap(path->mnt); 237738c8a9a5SSteve French char *name, *xattr_list = NULL; 237838c8a9a5SSteve French ssize_t xattr_list_len; 237938c8a9a5SSteve French int err = 0; 238038c8a9a5SSteve French 238138c8a9a5SSteve French xattr_list_len = ksmbd_vfs_listxattr(path->dentry, &xattr_list); 238238c8a9a5SSteve French if (xattr_list_len < 0) { 238338c8a9a5SSteve French goto out; 238438c8a9a5SSteve French } else if (!xattr_list_len) { 238538c8a9a5SSteve French ksmbd_debug(SMB, "empty xattr in the file\n"); 238638c8a9a5SSteve French goto out; 238738c8a9a5SSteve French } 238838c8a9a5SSteve French 238938c8a9a5SSteve French for (name = xattr_list; name - xattr_list < xattr_list_len; 239038c8a9a5SSteve French name += strlen(name) + 1) { 239138c8a9a5SSteve French ksmbd_debug(SMB, "%s, len %zd\n", name, strlen(name)); 239238c8a9a5SSteve French 239338c8a9a5SSteve French if (!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) && 239438c8a9a5SSteve French !strncmp(&name[XATTR_USER_PREFIX_LEN], STREAM_PREFIX, 239538c8a9a5SSteve French STREAM_PREFIX_LEN)) { 239640b268d3SNamjae Jeon err = ksmbd_vfs_remove_xattr(idmap, path, 239738c8a9a5SSteve French name); 239838c8a9a5SSteve French if (err) 239938c8a9a5SSteve French ksmbd_debug(SMB, "remove xattr failed : %s\n", 240038c8a9a5SSteve French name); 240138c8a9a5SSteve French } 240238c8a9a5SSteve French } 240338c8a9a5SSteve French out: 240438c8a9a5SSteve French kvfree(xattr_list); 240538c8a9a5SSteve French return err; 240638c8a9a5SSteve French } 240738c8a9a5SSteve French 240838c8a9a5SSteve French static int smb2_create_truncate(const struct path *path) 240938c8a9a5SSteve French { 241038c8a9a5SSteve French int rc = vfs_truncate(path, 0); 241138c8a9a5SSteve French 241238c8a9a5SSteve French if (rc) { 241338c8a9a5SSteve French pr_err("vfs_truncate failed, rc %d\n", rc); 241438c8a9a5SSteve French return rc; 241538c8a9a5SSteve French } 241638c8a9a5SSteve French 241738c8a9a5SSteve French rc = smb2_remove_smb_xattrs(path); 241838c8a9a5SSteve French if (rc == -EOPNOTSUPP) 241938c8a9a5SSteve French rc = 0; 242038c8a9a5SSteve French if (rc) 242138c8a9a5SSteve French ksmbd_debug(SMB, 242238c8a9a5SSteve French "ksmbd_truncate_stream_name_xattr failed, rc %d\n", 242338c8a9a5SSteve French rc); 242438c8a9a5SSteve French return rc; 242538c8a9a5SSteve French } 242638c8a9a5SSteve French 242738c8a9a5SSteve French static void smb2_new_xattrs(struct ksmbd_tree_connect *tcon, const struct path *path, 242838c8a9a5SSteve French struct ksmbd_file *fp) 242938c8a9a5SSteve French { 243038c8a9a5SSteve French struct xattr_dos_attrib da = {0}; 243138c8a9a5SSteve French int rc; 243238c8a9a5SSteve French 243338c8a9a5SSteve French if (!test_share_config_flag(tcon->share_conf, 243438c8a9a5SSteve French KSMBD_SHARE_FLAG_STORE_DOS_ATTRS)) 243538c8a9a5SSteve French return; 243638c8a9a5SSteve French 243738c8a9a5SSteve French da.version = 4; 243838c8a9a5SSteve French da.attr = le32_to_cpu(fp->f_ci->m_fattr); 243938c8a9a5SSteve French da.itime = da.create_time = fp->create_time; 244038c8a9a5SSteve French da.flags = XATTR_DOSINFO_ATTRIB | XATTR_DOSINFO_CREATE_TIME | 244138c8a9a5SSteve French XATTR_DOSINFO_ITIME; 244238c8a9a5SSteve French 244340b268d3SNamjae Jeon rc = ksmbd_vfs_set_dos_attrib_xattr(mnt_idmap(path->mnt), path, &da); 244438c8a9a5SSteve French if (rc) 244538c8a9a5SSteve French ksmbd_debug(SMB, "failed to store file attribute into xattr\n"); 244638c8a9a5SSteve French } 244738c8a9a5SSteve French 244838c8a9a5SSteve French static void smb2_update_xattrs(struct ksmbd_tree_connect *tcon, 244938c8a9a5SSteve French const struct path *path, struct ksmbd_file *fp) 245038c8a9a5SSteve French { 245138c8a9a5SSteve French struct xattr_dos_attrib da; 245238c8a9a5SSteve French int rc; 245338c8a9a5SSteve French 245438c8a9a5SSteve French fp->f_ci->m_fattr &= ~(FILE_ATTRIBUTE_HIDDEN_LE | FILE_ATTRIBUTE_SYSTEM_LE); 245538c8a9a5SSteve French 245638c8a9a5SSteve French /* get FileAttributes from XATTR_NAME_DOS_ATTRIBUTE */ 245738c8a9a5SSteve French if (!test_share_config_flag(tcon->share_conf, 245838c8a9a5SSteve French KSMBD_SHARE_FLAG_STORE_DOS_ATTRS)) 245938c8a9a5SSteve French return; 246038c8a9a5SSteve French 246138c8a9a5SSteve French rc = ksmbd_vfs_get_dos_attrib_xattr(mnt_idmap(path->mnt), 246238c8a9a5SSteve French path->dentry, &da); 246338c8a9a5SSteve French if (rc > 0) { 246438c8a9a5SSteve French fp->f_ci->m_fattr = cpu_to_le32(da.attr); 246538c8a9a5SSteve French fp->create_time = da.create_time; 246638c8a9a5SSteve French fp->itime = da.itime; 246738c8a9a5SSteve French } 246838c8a9a5SSteve French } 246938c8a9a5SSteve French 2470*2b57a432SNamjae Jeon static int smb2_creat(struct ksmbd_work *work, struct path *parent_path, 2471*2b57a432SNamjae Jeon struct path *path, char *name, int open_flags, 2472*2b57a432SNamjae Jeon umode_t posix_mode, bool is_dir) 247338c8a9a5SSteve French { 247438c8a9a5SSteve French struct ksmbd_tree_connect *tcon = work->tcon; 247538c8a9a5SSteve French struct ksmbd_share_config *share = tcon->share_conf; 247638c8a9a5SSteve French umode_t mode; 247738c8a9a5SSteve French int rc; 247838c8a9a5SSteve French 247938c8a9a5SSteve French if (!(open_flags & O_CREAT)) 248038c8a9a5SSteve French return -EBADF; 248138c8a9a5SSteve French 248238c8a9a5SSteve French ksmbd_debug(SMB, "file does not exist, so creating\n"); 248338c8a9a5SSteve French if (is_dir == true) { 248438c8a9a5SSteve French ksmbd_debug(SMB, "creating directory\n"); 248538c8a9a5SSteve French 248638c8a9a5SSteve French mode = share_config_directory_mode(share, posix_mode); 248738c8a9a5SSteve French rc = ksmbd_vfs_mkdir(work, name, mode); 248838c8a9a5SSteve French if (rc) 248938c8a9a5SSteve French return rc; 249038c8a9a5SSteve French } else { 249138c8a9a5SSteve French ksmbd_debug(SMB, "creating regular file\n"); 249238c8a9a5SSteve French 249338c8a9a5SSteve French mode = share_config_create_mode(share, posix_mode); 249438c8a9a5SSteve French rc = ksmbd_vfs_create(work, name, mode); 249538c8a9a5SSteve French if (rc) 249638c8a9a5SSteve French return rc; 249738c8a9a5SSteve French } 249838c8a9a5SSteve French 2499*2b57a432SNamjae Jeon rc = ksmbd_vfs_kern_path_locked(work, name, 0, parent_path, path, 0); 250038c8a9a5SSteve French if (rc) { 250138c8a9a5SSteve French pr_err("cannot get linux path (%s), err = %d\n", 250238c8a9a5SSteve French name, rc); 250338c8a9a5SSteve French return rc; 250438c8a9a5SSteve French } 250538c8a9a5SSteve French return 0; 250638c8a9a5SSteve French } 250738c8a9a5SSteve French 250838c8a9a5SSteve French static int smb2_create_sd_buffer(struct ksmbd_work *work, 250938c8a9a5SSteve French struct smb2_create_req *req, 251038c8a9a5SSteve French const struct path *path) 251138c8a9a5SSteve French { 251238c8a9a5SSteve French struct create_context *context; 251338c8a9a5SSteve French struct create_sd_buf_req *sd_buf; 251438c8a9a5SSteve French 251538c8a9a5SSteve French if (!req->CreateContextsOffset) 251638c8a9a5SSteve French return -ENOENT; 251738c8a9a5SSteve French 251838c8a9a5SSteve French /* Parse SD BUFFER create contexts */ 251938c8a9a5SSteve French context = smb2_find_context_vals(req, SMB2_CREATE_SD_BUFFER, 4); 252038c8a9a5SSteve French if (!context) 252138c8a9a5SSteve French return -ENOENT; 252238c8a9a5SSteve French else if (IS_ERR(context)) 252338c8a9a5SSteve French return PTR_ERR(context); 252438c8a9a5SSteve French 252538c8a9a5SSteve French ksmbd_debug(SMB, 252638c8a9a5SSteve French "Set ACLs using SMB2_CREATE_SD_BUFFER context\n"); 252738c8a9a5SSteve French sd_buf = (struct create_sd_buf_req *)context; 252838c8a9a5SSteve French if (le16_to_cpu(context->DataOffset) + 252938c8a9a5SSteve French le32_to_cpu(context->DataLength) < 253038c8a9a5SSteve French sizeof(struct create_sd_buf_req)) 253138c8a9a5SSteve French return -EINVAL; 253238c8a9a5SSteve French return set_info_sec(work->conn, work->tcon, path, &sd_buf->ntsd, 253338c8a9a5SSteve French le32_to_cpu(sd_buf->ccontext.DataLength), true); 253438c8a9a5SSteve French } 253538c8a9a5SSteve French 253638c8a9a5SSteve French static void ksmbd_acls_fattr(struct smb_fattr *fattr, 253738c8a9a5SSteve French struct mnt_idmap *idmap, 253838c8a9a5SSteve French struct inode *inode) 253938c8a9a5SSteve French { 254038c8a9a5SSteve French vfsuid_t vfsuid = i_uid_into_vfsuid(idmap, inode); 254138c8a9a5SSteve French vfsgid_t vfsgid = i_gid_into_vfsgid(idmap, inode); 254238c8a9a5SSteve French 254338c8a9a5SSteve French fattr->cf_uid = vfsuid_into_kuid(vfsuid); 254438c8a9a5SSteve French fattr->cf_gid = vfsgid_into_kgid(vfsgid); 254538c8a9a5SSteve French fattr->cf_mode = inode->i_mode; 254638c8a9a5SSteve French fattr->cf_acls = NULL; 254738c8a9a5SSteve French fattr->cf_dacls = NULL; 254838c8a9a5SSteve French 254938c8a9a5SSteve French if (IS_ENABLED(CONFIG_FS_POSIX_ACL)) { 255038c8a9a5SSteve French fattr->cf_acls = get_inode_acl(inode, ACL_TYPE_ACCESS); 255138c8a9a5SSteve French if (S_ISDIR(inode->i_mode)) 255238c8a9a5SSteve French fattr->cf_dacls = get_inode_acl(inode, ACL_TYPE_DEFAULT); 255338c8a9a5SSteve French } 255438c8a9a5SSteve French } 255538c8a9a5SSteve French 255638c8a9a5SSteve French /** 255738c8a9a5SSteve French * smb2_open() - handler for smb file open request 255838c8a9a5SSteve French * @work: smb work containing request buffer 255938c8a9a5SSteve French * 256038c8a9a5SSteve French * Return: 0 on success, otherwise error 256138c8a9a5SSteve French */ 256238c8a9a5SSteve French int smb2_open(struct ksmbd_work *work) 256338c8a9a5SSteve French { 256438c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 256538c8a9a5SSteve French struct ksmbd_session *sess = work->sess; 256638c8a9a5SSteve French struct ksmbd_tree_connect *tcon = work->tcon; 256738c8a9a5SSteve French struct smb2_create_req *req; 256838c8a9a5SSteve French struct smb2_create_rsp *rsp; 2569*2b57a432SNamjae Jeon struct path path, parent_path; 257038c8a9a5SSteve French struct ksmbd_share_config *share = tcon->share_conf; 257138c8a9a5SSteve French struct ksmbd_file *fp = NULL; 257238c8a9a5SSteve French struct file *filp = NULL; 257338c8a9a5SSteve French struct mnt_idmap *idmap = NULL; 257438c8a9a5SSteve French struct kstat stat; 257538c8a9a5SSteve French struct create_context *context; 257638c8a9a5SSteve French struct lease_ctx_info *lc = NULL; 257738c8a9a5SSteve French struct create_ea_buf_req *ea_buf = NULL; 257838c8a9a5SSteve French struct oplock_info *opinfo; 257938c8a9a5SSteve French __le32 *next_ptr = NULL; 258038c8a9a5SSteve French int req_op_level = 0, open_flags = 0, may_flags = 0, file_info = 0; 258138c8a9a5SSteve French int rc = 0; 258238c8a9a5SSteve French int contxt_cnt = 0, query_disk_id = 0; 258338c8a9a5SSteve French int maximal_access_ctxt = 0, posix_ctxt = 0; 258438c8a9a5SSteve French int s_type = 0; 258538c8a9a5SSteve French int next_off = 0; 258638c8a9a5SSteve French char *name = NULL; 258738c8a9a5SSteve French char *stream_name = NULL; 258838c8a9a5SSteve French bool file_present = false, created = false, already_permitted = false; 258938c8a9a5SSteve French int share_ret, need_truncate = 0; 259038c8a9a5SSteve French u64 time; 259138c8a9a5SSteve French umode_t posix_mode = 0; 259238c8a9a5SSteve French __le32 daccess, maximal_access = 0; 259338c8a9a5SSteve French 259438c8a9a5SSteve French WORK_BUFFERS(work, req, rsp); 259538c8a9a5SSteve French 259638c8a9a5SSteve French if (req->hdr.NextCommand && !work->next_smb2_rcv_hdr_off && 259738c8a9a5SSteve French (req->hdr.Flags & SMB2_FLAGS_RELATED_OPERATIONS)) { 259838c8a9a5SSteve French ksmbd_debug(SMB, "invalid flag in chained command\n"); 259938c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 260038c8a9a5SSteve French smb2_set_err_rsp(work); 260138c8a9a5SSteve French return -EINVAL; 260238c8a9a5SSteve French } 260338c8a9a5SSteve French 260438c8a9a5SSteve French if (test_share_config_flag(share, KSMBD_SHARE_FLAG_PIPE)) { 260538c8a9a5SSteve French ksmbd_debug(SMB, "IPC pipe create request\n"); 260638c8a9a5SSteve French return create_smb2_pipe(work); 260738c8a9a5SSteve French } 260838c8a9a5SSteve French 260938c8a9a5SSteve French if (req->NameLength) { 261038c8a9a5SSteve French if ((req->CreateOptions & FILE_DIRECTORY_FILE_LE) && 261138c8a9a5SSteve French *(char *)req->Buffer == '\\') { 261238c8a9a5SSteve French pr_err("not allow directory name included leading slash\n"); 261338c8a9a5SSteve French rc = -EINVAL; 261438c8a9a5SSteve French goto err_out1; 261538c8a9a5SSteve French } 261638c8a9a5SSteve French 261738c8a9a5SSteve French name = smb2_get_name(req->Buffer, 261838c8a9a5SSteve French le16_to_cpu(req->NameLength), 261938c8a9a5SSteve French work->conn->local_nls); 262038c8a9a5SSteve French if (IS_ERR(name)) { 262138c8a9a5SSteve French rc = PTR_ERR(name); 262238c8a9a5SSteve French if (rc != -ENOMEM) 262338c8a9a5SSteve French rc = -ENOENT; 262438c8a9a5SSteve French name = NULL; 262538c8a9a5SSteve French goto err_out1; 262638c8a9a5SSteve French } 262738c8a9a5SSteve French 262838c8a9a5SSteve French ksmbd_debug(SMB, "converted name = %s\n", name); 262938c8a9a5SSteve French if (strchr(name, ':')) { 263038c8a9a5SSteve French if (!test_share_config_flag(work->tcon->share_conf, 263138c8a9a5SSteve French KSMBD_SHARE_FLAG_STREAMS)) { 263238c8a9a5SSteve French rc = -EBADF; 263338c8a9a5SSteve French goto err_out1; 263438c8a9a5SSteve French } 263538c8a9a5SSteve French rc = parse_stream_name(name, &stream_name, &s_type); 263638c8a9a5SSteve French if (rc < 0) 263738c8a9a5SSteve French goto err_out1; 263838c8a9a5SSteve French } 263938c8a9a5SSteve French 264038c8a9a5SSteve French rc = ksmbd_validate_filename(name); 264138c8a9a5SSteve French if (rc < 0) 264238c8a9a5SSteve French goto err_out1; 264338c8a9a5SSteve French 264438c8a9a5SSteve French if (ksmbd_share_veto_filename(share, name)) { 264538c8a9a5SSteve French rc = -ENOENT; 264638c8a9a5SSteve French ksmbd_debug(SMB, "Reject open(), vetoed file: %s\n", 264738c8a9a5SSteve French name); 264838c8a9a5SSteve French goto err_out1; 264938c8a9a5SSteve French } 265038c8a9a5SSteve French } else { 265138c8a9a5SSteve French name = kstrdup("", GFP_KERNEL); 265238c8a9a5SSteve French if (!name) { 265338c8a9a5SSteve French rc = -ENOMEM; 265438c8a9a5SSteve French goto err_out1; 265538c8a9a5SSteve French } 265638c8a9a5SSteve French } 265738c8a9a5SSteve French 265838c8a9a5SSteve French req_op_level = req->RequestedOplockLevel; 265938c8a9a5SSteve French if (req_op_level == SMB2_OPLOCK_LEVEL_LEASE) 266038c8a9a5SSteve French lc = parse_lease_state(req); 266138c8a9a5SSteve French 266238c8a9a5SSteve French if (le32_to_cpu(req->ImpersonationLevel) > le32_to_cpu(IL_DELEGATE)) { 266338c8a9a5SSteve French pr_err("Invalid impersonationlevel : 0x%x\n", 266438c8a9a5SSteve French le32_to_cpu(req->ImpersonationLevel)); 266538c8a9a5SSteve French rc = -EIO; 266638c8a9a5SSteve French rsp->hdr.Status = STATUS_BAD_IMPERSONATION_LEVEL; 266738c8a9a5SSteve French goto err_out1; 266838c8a9a5SSteve French } 266938c8a9a5SSteve French 267038c8a9a5SSteve French if (req->CreateOptions && !(req->CreateOptions & CREATE_OPTIONS_MASK_LE)) { 267138c8a9a5SSteve French pr_err("Invalid create options : 0x%x\n", 267238c8a9a5SSteve French le32_to_cpu(req->CreateOptions)); 267338c8a9a5SSteve French rc = -EINVAL; 267438c8a9a5SSteve French goto err_out1; 267538c8a9a5SSteve French } else { 267638c8a9a5SSteve French if (req->CreateOptions & FILE_SEQUENTIAL_ONLY_LE && 267738c8a9a5SSteve French req->CreateOptions & FILE_RANDOM_ACCESS_LE) 267838c8a9a5SSteve French req->CreateOptions = ~(FILE_SEQUENTIAL_ONLY_LE); 267938c8a9a5SSteve French 268038c8a9a5SSteve French if (req->CreateOptions & 268138c8a9a5SSteve French (FILE_OPEN_BY_FILE_ID_LE | CREATE_TREE_CONNECTION | 268238c8a9a5SSteve French FILE_RESERVE_OPFILTER_LE)) { 268338c8a9a5SSteve French rc = -EOPNOTSUPP; 268438c8a9a5SSteve French goto err_out1; 268538c8a9a5SSteve French } 268638c8a9a5SSteve French 268738c8a9a5SSteve French if (req->CreateOptions & FILE_DIRECTORY_FILE_LE) { 268838c8a9a5SSteve French if (req->CreateOptions & FILE_NON_DIRECTORY_FILE_LE) { 268938c8a9a5SSteve French rc = -EINVAL; 269038c8a9a5SSteve French goto err_out1; 269138c8a9a5SSteve French } else if (req->CreateOptions & FILE_NO_COMPRESSION_LE) { 269238c8a9a5SSteve French req->CreateOptions = ~(FILE_NO_COMPRESSION_LE); 269338c8a9a5SSteve French } 269438c8a9a5SSteve French } 269538c8a9a5SSteve French } 269638c8a9a5SSteve French 269738c8a9a5SSteve French if (le32_to_cpu(req->CreateDisposition) > 269838c8a9a5SSteve French le32_to_cpu(FILE_OVERWRITE_IF_LE)) { 269938c8a9a5SSteve French pr_err("Invalid create disposition : 0x%x\n", 270038c8a9a5SSteve French le32_to_cpu(req->CreateDisposition)); 270138c8a9a5SSteve French rc = -EINVAL; 270238c8a9a5SSteve French goto err_out1; 270338c8a9a5SSteve French } 270438c8a9a5SSteve French 270538c8a9a5SSteve French if (!(req->DesiredAccess & DESIRED_ACCESS_MASK)) { 270638c8a9a5SSteve French pr_err("Invalid desired access : 0x%x\n", 270738c8a9a5SSteve French le32_to_cpu(req->DesiredAccess)); 270838c8a9a5SSteve French rc = -EACCES; 270938c8a9a5SSteve French goto err_out1; 271038c8a9a5SSteve French } 271138c8a9a5SSteve French 271238c8a9a5SSteve French if (req->FileAttributes && !(req->FileAttributes & FILE_ATTRIBUTE_MASK_LE)) { 271338c8a9a5SSteve French pr_err("Invalid file attribute : 0x%x\n", 271438c8a9a5SSteve French le32_to_cpu(req->FileAttributes)); 271538c8a9a5SSteve French rc = -EINVAL; 271638c8a9a5SSteve French goto err_out1; 271738c8a9a5SSteve French } 271838c8a9a5SSteve French 271938c8a9a5SSteve French if (req->CreateContextsOffset) { 272038c8a9a5SSteve French /* Parse non-durable handle create contexts */ 272138c8a9a5SSteve French context = smb2_find_context_vals(req, SMB2_CREATE_EA_BUFFER, 4); 272238c8a9a5SSteve French if (IS_ERR(context)) { 272338c8a9a5SSteve French rc = PTR_ERR(context); 272438c8a9a5SSteve French goto err_out1; 272538c8a9a5SSteve French } else if (context) { 272638c8a9a5SSteve French ea_buf = (struct create_ea_buf_req *)context; 272738c8a9a5SSteve French if (le16_to_cpu(context->DataOffset) + 272838c8a9a5SSteve French le32_to_cpu(context->DataLength) < 272938c8a9a5SSteve French sizeof(struct create_ea_buf_req)) { 273038c8a9a5SSteve French rc = -EINVAL; 273138c8a9a5SSteve French goto err_out1; 273238c8a9a5SSteve French } 273338c8a9a5SSteve French if (req->CreateOptions & FILE_NO_EA_KNOWLEDGE_LE) { 273438c8a9a5SSteve French rsp->hdr.Status = STATUS_ACCESS_DENIED; 273538c8a9a5SSteve French rc = -EACCES; 273638c8a9a5SSteve French goto err_out1; 273738c8a9a5SSteve French } 273838c8a9a5SSteve French } 273938c8a9a5SSteve French 274038c8a9a5SSteve French context = smb2_find_context_vals(req, 274138c8a9a5SSteve French SMB2_CREATE_QUERY_MAXIMAL_ACCESS_REQUEST, 4); 274238c8a9a5SSteve French if (IS_ERR(context)) { 274338c8a9a5SSteve French rc = PTR_ERR(context); 274438c8a9a5SSteve French goto err_out1; 274538c8a9a5SSteve French } else if (context) { 274638c8a9a5SSteve French ksmbd_debug(SMB, 274738c8a9a5SSteve French "get query maximal access context\n"); 274838c8a9a5SSteve French maximal_access_ctxt = 1; 274938c8a9a5SSteve French } 275038c8a9a5SSteve French 275138c8a9a5SSteve French context = smb2_find_context_vals(req, 275238c8a9a5SSteve French SMB2_CREATE_TIMEWARP_REQUEST, 4); 275338c8a9a5SSteve French if (IS_ERR(context)) { 275438c8a9a5SSteve French rc = PTR_ERR(context); 275538c8a9a5SSteve French goto err_out1; 275638c8a9a5SSteve French } else if (context) { 275738c8a9a5SSteve French ksmbd_debug(SMB, "get timewarp context\n"); 275838c8a9a5SSteve French rc = -EBADF; 275938c8a9a5SSteve French goto err_out1; 276038c8a9a5SSteve French } 276138c8a9a5SSteve French 276238c8a9a5SSteve French if (tcon->posix_extensions) { 276338c8a9a5SSteve French context = smb2_find_context_vals(req, 276438c8a9a5SSteve French SMB2_CREATE_TAG_POSIX, 16); 276538c8a9a5SSteve French if (IS_ERR(context)) { 276638c8a9a5SSteve French rc = PTR_ERR(context); 276738c8a9a5SSteve French goto err_out1; 276838c8a9a5SSteve French } else if (context) { 276938c8a9a5SSteve French struct create_posix *posix = 277038c8a9a5SSteve French (struct create_posix *)context; 277138c8a9a5SSteve French if (le16_to_cpu(context->DataOffset) + 277238c8a9a5SSteve French le32_to_cpu(context->DataLength) < 277338c8a9a5SSteve French sizeof(struct create_posix) - 4) { 277438c8a9a5SSteve French rc = -EINVAL; 277538c8a9a5SSteve French goto err_out1; 277638c8a9a5SSteve French } 277738c8a9a5SSteve French ksmbd_debug(SMB, "get posix context\n"); 277838c8a9a5SSteve French 277938c8a9a5SSteve French posix_mode = le32_to_cpu(posix->Mode); 278038c8a9a5SSteve French posix_ctxt = 1; 278138c8a9a5SSteve French } 278238c8a9a5SSteve French } 278338c8a9a5SSteve French } 278438c8a9a5SSteve French 278538c8a9a5SSteve French if (ksmbd_override_fsids(work)) { 278638c8a9a5SSteve French rc = -ENOMEM; 278738c8a9a5SSteve French goto err_out1; 278838c8a9a5SSteve French } 278938c8a9a5SSteve French 2790*2b57a432SNamjae Jeon rc = ksmbd_vfs_kern_path_locked(work, name, LOOKUP_NO_SYMLINKS, 2791*2b57a432SNamjae Jeon &parent_path, &path, 1); 279238c8a9a5SSteve French if (!rc) { 279338c8a9a5SSteve French file_present = true; 279438c8a9a5SSteve French 279538c8a9a5SSteve French if (req->CreateOptions & FILE_DELETE_ON_CLOSE_LE) { 279638c8a9a5SSteve French /* 279738c8a9a5SSteve French * If file exists with under flags, return access 279838c8a9a5SSteve French * denied error. 279938c8a9a5SSteve French */ 280038c8a9a5SSteve French if (req->CreateDisposition == FILE_OVERWRITE_IF_LE || 280138c8a9a5SSteve French req->CreateDisposition == FILE_OPEN_IF_LE) { 280238c8a9a5SSteve French rc = -EACCES; 280338c8a9a5SSteve French goto err_out; 280438c8a9a5SSteve French } 280538c8a9a5SSteve French 280638c8a9a5SSteve French if (!test_tree_conn_flag(tcon, KSMBD_TREE_CONN_FLAG_WRITABLE)) { 280738c8a9a5SSteve French ksmbd_debug(SMB, 280838c8a9a5SSteve French "User does not have write permission\n"); 280938c8a9a5SSteve French rc = -EACCES; 281038c8a9a5SSteve French goto err_out; 281138c8a9a5SSteve French } 281238c8a9a5SSteve French } else if (d_is_symlink(path.dentry)) { 281338c8a9a5SSteve French rc = -EACCES; 281438c8a9a5SSteve French goto err_out; 281538c8a9a5SSteve French } 281638c8a9a5SSteve French 281738c8a9a5SSteve French file_present = true; 281838c8a9a5SSteve French idmap = mnt_idmap(path.mnt); 281938c8a9a5SSteve French } else { 282038c8a9a5SSteve French if (rc != -ENOENT) 282138c8a9a5SSteve French goto err_out; 282238c8a9a5SSteve French ksmbd_debug(SMB, "can not get linux path for %s, rc = %d\n", 282338c8a9a5SSteve French name, rc); 282438c8a9a5SSteve French rc = 0; 282538c8a9a5SSteve French } 282638c8a9a5SSteve French 282738c8a9a5SSteve French if (stream_name) { 282838c8a9a5SSteve French if (req->CreateOptions & FILE_DIRECTORY_FILE_LE) { 282938c8a9a5SSteve French if (s_type == DATA_STREAM) { 283038c8a9a5SSteve French rc = -EIO; 283138c8a9a5SSteve French rsp->hdr.Status = STATUS_NOT_A_DIRECTORY; 283238c8a9a5SSteve French } 283338c8a9a5SSteve French } else { 283438c8a9a5SSteve French if (file_present && S_ISDIR(d_inode(path.dentry)->i_mode) && 283538c8a9a5SSteve French s_type == DATA_STREAM) { 283638c8a9a5SSteve French rc = -EIO; 283738c8a9a5SSteve French rsp->hdr.Status = STATUS_FILE_IS_A_DIRECTORY; 283838c8a9a5SSteve French } 283938c8a9a5SSteve French } 284038c8a9a5SSteve French 284138c8a9a5SSteve French if (req->CreateOptions & FILE_DIRECTORY_FILE_LE && 284238c8a9a5SSteve French req->FileAttributes & FILE_ATTRIBUTE_NORMAL_LE) { 284338c8a9a5SSteve French rsp->hdr.Status = STATUS_NOT_A_DIRECTORY; 284438c8a9a5SSteve French rc = -EIO; 284538c8a9a5SSteve French } 284638c8a9a5SSteve French 284738c8a9a5SSteve French if (rc < 0) 284838c8a9a5SSteve French goto err_out; 284938c8a9a5SSteve French } 285038c8a9a5SSteve French 285138c8a9a5SSteve French if (file_present && req->CreateOptions & FILE_NON_DIRECTORY_FILE_LE && 285238c8a9a5SSteve French S_ISDIR(d_inode(path.dentry)->i_mode) && 285338c8a9a5SSteve French !(req->CreateOptions & FILE_DELETE_ON_CLOSE_LE)) { 285438c8a9a5SSteve French ksmbd_debug(SMB, "open() argument is a directory: %s, %x\n", 285538c8a9a5SSteve French name, req->CreateOptions); 285638c8a9a5SSteve French rsp->hdr.Status = STATUS_FILE_IS_A_DIRECTORY; 285738c8a9a5SSteve French rc = -EIO; 285838c8a9a5SSteve French goto err_out; 285938c8a9a5SSteve French } 286038c8a9a5SSteve French 286138c8a9a5SSteve French if (file_present && (req->CreateOptions & FILE_DIRECTORY_FILE_LE) && 286238c8a9a5SSteve French !(req->CreateDisposition == FILE_CREATE_LE) && 286338c8a9a5SSteve French !S_ISDIR(d_inode(path.dentry)->i_mode)) { 286438c8a9a5SSteve French rsp->hdr.Status = STATUS_NOT_A_DIRECTORY; 286538c8a9a5SSteve French rc = -EIO; 286638c8a9a5SSteve French goto err_out; 286738c8a9a5SSteve French } 286838c8a9a5SSteve French 286938c8a9a5SSteve French if (!stream_name && file_present && 287038c8a9a5SSteve French req->CreateDisposition == FILE_CREATE_LE) { 287138c8a9a5SSteve French rc = -EEXIST; 287238c8a9a5SSteve French goto err_out; 287338c8a9a5SSteve French } 287438c8a9a5SSteve French 287538c8a9a5SSteve French daccess = smb_map_generic_desired_access(req->DesiredAccess); 287638c8a9a5SSteve French 287738c8a9a5SSteve French if (file_present && !(req->CreateOptions & FILE_DELETE_ON_CLOSE_LE)) { 287838c8a9a5SSteve French rc = smb_check_perm_dacl(conn, &path, &daccess, 287938c8a9a5SSteve French sess->user->uid); 288038c8a9a5SSteve French if (rc) 288138c8a9a5SSteve French goto err_out; 288238c8a9a5SSteve French } 288338c8a9a5SSteve French 288438c8a9a5SSteve French if (daccess & FILE_MAXIMAL_ACCESS_LE) { 288538c8a9a5SSteve French if (!file_present) { 288638c8a9a5SSteve French daccess = cpu_to_le32(GENERIC_ALL_FLAGS); 288738c8a9a5SSteve French } else { 2888ccb5889aSLu Hongfei ksmbd_vfs_query_maximal_access(idmap, 288938c8a9a5SSteve French path.dentry, 289038c8a9a5SSteve French &daccess); 289138c8a9a5SSteve French already_permitted = true; 289238c8a9a5SSteve French } 289338c8a9a5SSteve French maximal_access = daccess; 289438c8a9a5SSteve French } 289538c8a9a5SSteve French 289638c8a9a5SSteve French open_flags = smb2_create_open_flags(file_present, daccess, 289738c8a9a5SSteve French req->CreateDisposition, 289838c8a9a5SSteve French &may_flags); 289938c8a9a5SSteve French 290038c8a9a5SSteve French if (!test_tree_conn_flag(tcon, KSMBD_TREE_CONN_FLAG_WRITABLE)) { 290138c8a9a5SSteve French if (open_flags & O_CREAT) { 290238c8a9a5SSteve French ksmbd_debug(SMB, 290338c8a9a5SSteve French "User does not have write permission\n"); 290438c8a9a5SSteve French rc = -EACCES; 290538c8a9a5SSteve French goto err_out; 290638c8a9a5SSteve French } 290738c8a9a5SSteve French } 290838c8a9a5SSteve French 290938c8a9a5SSteve French /*create file if not present */ 291038c8a9a5SSteve French if (!file_present) { 2911*2b57a432SNamjae Jeon rc = smb2_creat(work, &parent_path, &path, name, open_flags, 2912*2b57a432SNamjae Jeon posix_mode, 291338c8a9a5SSteve French req->CreateOptions & FILE_DIRECTORY_FILE_LE); 291438c8a9a5SSteve French if (rc) { 291538c8a9a5SSteve French if (rc == -ENOENT) { 291638c8a9a5SSteve French rc = -EIO; 291738c8a9a5SSteve French rsp->hdr.Status = STATUS_OBJECT_PATH_NOT_FOUND; 291838c8a9a5SSteve French } 291938c8a9a5SSteve French goto err_out; 292038c8a9a5SSteve French } 292138c8a9a5SSteve French 292238c8a9a5SSteve French created = true; 292338c8a9a5SSteve French idmap = mnt_idmap(path.mnt); 292438c8a9a5SSteve French if (ea_buf) { 292538c8a9a5SSteve French if (le32_to_cpu(ea_buf->ccontext.DataLength) < 292638c8a9a5SSteve French sizeof(struct smb2_ea_info)) { 292738c8a9a5SSteve French rc = -EINVAL; 292838c8a9a5SSteve French goto err_out; 292938c8a9a5SSteve French } 293038c8a9a5SSteve French 293138c8a9a5SSteve French rc = smb2_set_ea(&ea_buf->ea, 293238c8a9a5SSteve French le32_to_cpu(ea_buf->ccontext.DataLength), 293338c8a9a5SSteve French &path); 293438c8a9a5SSteve French if (rc == -EOPNOTSUPP) 293538c8a9a5SSteve French rc = 0; 293638c8a9a5SSteve French else if (rc) 293738c8a9a5SSteve French goto err_out; 293838c8a9a5SSteve French } 293938c8a9a5SSteve French } else if (!already_permitted) { 294038c8a9a5SSteve French /* FILE_READ_ATTRIBUTE is allowed without inode_permission, 294138c8a9a5SSteve French * because execute(search) permission on a parent directory, 294238c8a9a5SSteve French * is already granted. 294338c8a9a5SSteve French */ 294438c8a9a5SSteve French if (daccess & ~(FILE_READ_ATTRIBUTES_LE | FILE_READ_CONTROL_LE)) { 294538c8a9a5SSteve French rc = inode_permission(idmap, 294638c8a9a5SSteve French d_inode(path.dentry), 294738c8a9a5SSteve French may_flags); 294838c8a9a5SSteve French if (rc) 294938c8a9a5SSteve French goto err_out; 295038c8a9a5SSteve French 295138c8a9a5SSteve French if ((daccess & FILE_DELETE_LE) || 295238c8a9a5SSteve French (req->CreateOptions & FILE_DELETE_ON_CLOSE_LE)) { 295338c8a9a5SSteve French rc = inode_permission(idmap, 295438c8a9a5SSteve French d_inode(path.dentry->d_parent), 295538c8a9a5SSteve French MAY_EXEC | MAY_WRITE); 295638c8a9a5SSteve French if (rc) 295738c8a9a5SSteve French goto err_out; 295838c8a9a5SSteve French } 295938c8a9a5SSteve French } 296038c8a9a5SSteve French } 296138c8a9a5SSteve French 296238c8a9a5SSteve French rc = ksmbd_query_inode_status(d_inode(path.dentry->d_parent)); 296338c8a9a5SSteve French if (rc == KSMBD_INODE_STATUS_PENDING_DELETE) { 296438c8a9a5SSteve French rc = -EBUSY; 296538c8a9a5SSteve French goto err_out; 296638c8a9a5SSteve French } 296738c8a9a5SSteve French 296838c8a9a5SSteve French rc = 0; 296938c8a9a5SSteve French filp = dentry_open(&path, open_flags, current_cred()); 297038c8a9a5SSteve French if (IS_ERR(filp)) { 297138c8a9a5SSteve French rc = PTR_ERR(filp); 297238c8a9a5SSteve French pr_err("dentry open for dir failed, rc %d\n", rc); 297338c8a9a5SSteve French goto err_out; 297438c8a9a5SSteve French } 297538c8a9a5SSteve French 297638c8a9a5SSteve French if (file_present) { 297738c8a9a5SSteve French if (!(open_flags & O_TRUNC)) 297838c8a9a5SSteve French file_info = FILE_OPENED; 297938c8a9a5SSteve French else 298038c8a9a5SSteve French file_info = FILE_OVERWRITTEN; 298138c8a9a5SSteve French 298238c8a9a5SSteve French if ((req->CreateDisposition & FILE_CREATE_MASK_LE) == 298338c8a9a5SSteve French FILE_SUPERSEDE_LE) 298438c8a9a5SSteve French file_info = FILE_SUPERSEDED; 298538c8a9a5SSteve French } else if (open_flags & O_CREAT) { 298638c8a9a5SSteve French file_info = FILE_CREATED; 298738c8a9a5SSteve French } 298838c8a9a5SSteve French 298938c8a9a5SSteve French ksmbd_vfs_set_fadvise(filp, req->CreateOptions); 299038c8a9a5SSteve French 299138c8a9a5SSteve French /* Obtain Volatile-ID */ 299238c8a9a5SSteve French fp = ksmbd_open_fd(work, filp); 299338c8a9a5SSteve French if (IS_ERR(fp)) { 299438c8a9a5SSteve French fput(filp); 299538c8a9a5SSteve French rc = PTR_ERR(fp); 299638c8a9a5SSteve French fp = NULL; 299738c8a9a5SSteve French goto err_out; 299838c8a9a5SSteve French } 299938c8a9a5SSteve French 300038c8a9a5SSteve French /* Get Persistent-ID */ 300138c8a9a5SSteve French ksmbd_open_durable_fd(fp); 300238c8a9a5SSteve French if (!has_file_id(fp->persistent_id)) { 300338c8a9a5SSteve French rc = -ENOMEM; 300438c8a9a5SSteve French goto err_out; 300538c8a9a5SSteve French } 300638c8a9a5SSteve French 300738c8a9a5SSteve French fp->cdoption = req->CreateDisposition; 300838c8a9a5SSteve French fp->daccess = daccess; 300938c8a9a5SSteve French fp->saccess = req->ShareAccess; 301038c8a9a5SSteve French fp->coption = req->CreateOptions; 301138c8a9a5SSteve French 301238c8a9a5SSteve French /* Set default windows and posix acls if creating new file */ 301338c8a9a5SSteve French if (created) { 301438c8a9a5SSteve French int posix_acl_rc; 301538c8a9a5SSteve French struct inode *inode = d_inode(path.dentry); 301638c8a9a5SSteve French 301738c8a9a5SSteve French posix_acl_rc = ksmbd_vfs_inherit_posix_acl(idmap, 301840b268d3SNamjae Jeon &path, 301938c8a9a5SSteve French d_inode(path.dentry->d_parent)); 302038c8a9a5SSteve French if (posix_acl_rc) 302138c8a9a5SSteve French ksmbd_debug(SMB, "inherit posix acl failed : %d\n", posix_acl_rc); 302238c8a9a5SSteve French 302338c8a9a5SSteve French if (test_share_config_flag(work->tcon->share_conf, 302438c8a9a5SSteve French KSMBD_SHARE_FLAG_ACL_XATTR)) { 302538c8a9a5SSteve French rc = smb_inherit_dacl(conn, &path, sess->user->uid, 302638c8a9a5SSteve French sess->user->gid); 302738c8a9a5SSteve French } 302838c8a9a5SSteve French 302938c8a9a5SSteve French if (rc) { 303038c8a9a5SSteve French rc = smb2_create_sd_buffer(work, req, &path); 303138c8a9a5SSteve French if (rc) { 303238c8a9a5SSteve French if (posix_acl_rc) 303338c8a9a5SSteve French ksmbd_vfs_set_init_posix_acl(idmap, 303440b268d3SNamjae Jeon &path); 303538c8a9a5SSteve French 303638c8a9a5SSteve French if (test_share_config_flag(work->tcon->share_conf, 303738c8a9a5SSteve French KSMBD_SHARE_FLAG_ACL_XATTR)) { 303838c8a9a5SSteve French struct smb_fattr fattr; 303938c8a9a5SSteve French struct smb_ntsd *pntsd; 304038c8a9a5SSteve French int pntsd_size, ace_num = 0; 304138c8a9a5SSteve French 304238c8a9a5SSteve French ksmbd_acls_fattr(&fattr, idmap, inode); 304338c8a9a5SSteve French if (fattr.cf_acls) 304438c8a9a5SSteve French ace_num = fattr.cf_acls->a_count; 304538c8a9a5SSteve French if (fattr.cf_dacls) 304638c8a9a5SSteve French ace_num += fattr.cf_dacls->a_count; 304738c8a9a5SSteve French 304838c8a9a5SSteve French pntsd = kmalloc(sizeof(struct smb_ntsd) + 304938c8a9a5SSteve French sizeof(struct smb_sid) * 3 + 305038c8a9a5SSteve French sizeof(struct smb_acl) + 305138c8a9a5SSteve French sizeof(struct smb_ace) * ace_num * 2, 305238c8a9a5SSteve French GFP_KERNEL); 305338c8a9a5SSteve French if (!pntsd) { 305438c8a9a5SSteve French posix_acl_release(fattr.cf_acls); 305538c8a9a5SSteve French posix_acl_release(fattr.cf_dacls); 305638c8a9a5SSteve French goto err_out; 305738c8a9a5SSteve French } 305838c8a9a5SSteve French 305938c8a9a5SSteve French rc = build_sec_desc(idmap, 306038c8a9a5SSteve French pntsd, NULL, 0, 306138c8a9a5SSteve French OWNER_SECINFO | 306238c8a9a5SSteve French GROUP_SECINFO | 306338c8a9a5SSteve French DACL_SECINFO, 306438c8a9a5SSteve French &pntsd_size, &fattr); 306538c8a9a5SSteve French posix_acl_release(fattr.cf_acls); 306638c8a9a5SSteve French posix_acl_release(fattr.cf_dacls); 306738c8a9a5SSteve French if (rc) { 306838c8a9a5SSteve French kfree(pntsd); 306938c8a9a5SSteve French goto err_out; 307038c8a9a5SSteve French } 307138c8a9a5SSteve French 307238c8a9a5SSteve French rc = ksmbd_vfs_set_sd_xattr(conn, 307338c8a9a5SSteve French idmap, 307440b268d3SNamjae Jeon &path, 307538c8a9a5SSteve French pntsd, 307638c8a9a5SSteve French pntsd_size); 307738c8a9a5SSteve French kfree(pntsd); 307838c8a9a5SSteve French if (rc) 307938c8a9a5SSteve French pr_err("failed to store ntacl in xattr : %d\n", 308038c8a9a5SSteve French rc); 308138c8a9a5SSteve French } 308238c8a9a5SSteve French } 308338c8a9a5SSteve French } 308438c8a9a5SSteve French rc = 0; 308538c8a9a5SSteve French } 308638c8a9a5SSteve French 308738c8a9a5SSteve French if (stream_name) { 308838c8a9a5SSteve French rc = smb2_set_stream_name_xattr(&path, 308938c8a9a5SSteve French fp, 309038c8a9a5SSteve French stream_name, 309138c8a9a5SSteve French s_type); 309238c8a9a5SSteve French if (rc) 309338c8a9a5SSteve French goto err_out; 309438c8a9a5SSteve French file_info = FILE_CREATED; 309538c8a9a5SSteve French } 309638c8a9a5SSteve French 309738c8a9a5SSteve French fp->attrib_only = !(req->DesiredAccess & ~(FILE_READ_ATTRIBUTES_LE | 309838c8a9a5SSteve French FILE_WRITE_ATTRIBUTES_LE | FILE_SYNCHRONIZE_LE)); 309938c8a9a5SSteve French if (!S_ISDIR(file_inode(filp)->i_mode) && open_flags & O_TRUNC && 310038c8a9a5SSteve French !fp->attrib_only && !stream_name) { 310138c8a9a5SSteve French smb_break_all_oplock(work, fp); 310238c8a9a5SSteve French need_truncate = 1; 310338c8a9a5SSteve French } 310438c8a9a5SSteve French 310538c8a9a5SSteve French /* fp should be searchable through ksmbd_inode.m_fp_list 310638c8a9a5SSteve French * after daccess, saccess, attrib_only, and stream are 310738c8a9a5SSteve French * initialized. 310838c8a9a5SSteve French */ 310938c8a9a5SSteve French write_lock(&fp->f_ci->m_lock); 311038c8a9a5SSteve French list_add(&fp->node, &fp->f_ci->m_fp_list); 311138c8a9a5SSteve French write_unlock(&fp->f_ci->m_lock); 311238c8a9a5SSteve French 311338c8a9a5SSteve French /* Check delete pending among previous fp before oplock break */ 311438c8a9a5SSteve French if (ksmbd_inode_pending_delete(fp)) { 311538c8a9a5SSteve French rc = -EBUSY; 311638c8a9a5SSteve French goto err_out; 311738c8a9a5SSteve French } 311838c8a9a5SSteve French 311938c8a9a5SSteve French share_ret = ksmbd_smb_check_shared_mode(fp->filp, fp); 312038c8a9a5SSteve French if (!test_share_config_flag(work->tcon->share_conf, KSMBD_SHARE_FLAG_OPLOCKS) || 312138c8a9a5SSteve French (req_op_level == SMB2_OPLOCK_LEVEL_LEASE && 312238c8a9a5SSteve French !(conn->vals->capabilities & SMB2_GLOBAL_CAP_LEASING))) { 312338c8a9a5SSteve French if (share_ret < 0 && !S_ISDIR(file_inode(fp->filp)->i_mode)) { 312438c8a9a5SSteve French rc = share_ret; 312538c8a9a5SSteve French goto err_out; 312638c8a9a5SSteve French } 312738c8a9a5SSteve French } else { 312838c8a9a5SSteve French if (req_op_level == SMB2_OPLOCK_LEVEL_LEASE) { 312938c8a9a5SSteve French req_op_level = smb2_map_lease_to_oplock(lc->req_state); 313038c8a9a5SSteve French ksmbd_debug(SMB, 313138c8a9a5SSteve French "lease req for(%s) req oplock state 0x%x, lease state 0x%x\n", 313238c8a9a5SSteve French name, req_op_level, lc->req_state); 313338c8a9a5SSteve French rc = find_same_lease_key(sess, fp->f_ci, lc); 313438c8a9a5SSteve French if (rc) 313538c8a9a5SSteve French goto err_out; 313638c8a9a5SSteve French } else if (open_flags == O_RDONLY && 313738c8a9a5SSteve French (req_op_level == SMB2_OPLOCK_LEVEL_BATCH || 313838c8a9a5SSteve French req_op_level == SMB2_OPLOCK_LEVEL_EXCLUSIVE)) 313938c8a9a5SSteve French req_op_level = SMB2_OPLOCK_LEVEL_II; 314038c8a9a5SSteve French 314138c8a9a5SSteve French rc = smb_grant_oplock(work, req_op_level, 314238c8a9a5SSteve French fp->persistent_id, fp, 314338c8a9a5SSteve French le32_to_cpu(req->hdr.Id.SyncId.TreeId), 314438c8a9a5SSteve French lc, share_ret); 314538c8a9a5SSteve French if (rc < 0) 314638c8a9a5SSteve French goto err_out; 314738c8a9a5SSteve French } 314838c8a9a5SSteve French 314938c8a9a5SSteve French if (req->CreateOptions & FILE_DELETE_ON_CLOSE_LE) 315038c8a9a5SSteve French ksmbd_fd_set_delete_on_close(fp, file_info); 315138c8a9a5SSteve French 315238c8a9a5SSteve French if (need_truncate) { 315338c8a9a5SSteve French rc = smb2_create_truncate(&path); 315438c8a9a5SSteve French if (rc) 315538c8a9a5SSteve French goto err_out; 315638c8a9a5SSteve French } 315738c8a9a5SSteve French 315838c8a9a5SSteve French if (req->CreateContextsOffset) { 315938c8a9a5SSteve French struct create_alloc_size_req *az_req; 316038c8a9a5SSteve French 316138c8a9a5SSteve French az_req = (struct create_alloc_size_req *)smb2_find_context_vals(req, 316238c8a9a5SSteve French SMB2_CREATE_ALLOCATION_SIZE, 4); 316338c8a9a5SSteve French if (IS_ERR(az_req)) { 316438c8a9a5SSteve French rc = PTR_ERR(az_req); 316538c8a9a5SSteve French goto err_out; 316638c8a9a5SSteve French } else if (az_req) { 316738c8a9a5SSteve French loff_t alloc_size; 316838c8a9a5SSteve French int err; 316938c8a9a5SSteve French 317038c8a9a5SSteve French if (le16_to_cpu(az_req->ccontext.DataOffset) + 317138c8a9a5SSteve French le32_to_cpu(az_req->ccontext.DataLength) < 317238c8a9a5SSteve French sizeof(struct create_alloc_size_req)) { 317338c8a9a5SSteve French rc = -EINVAL; 317438c8a9a5SSteve French goto err_out; 317538c8a9a5SSteve French } 317638c8a9a5SSteve French alloc_size = le64_to_cpu(az_req->AllocationSize); 317738c8a9a5SSteve French ksmbd_debug(SMB, 317838c8a9a5SSteve French "request smb2 create allocate size : %llu\n", 317938c8a9a5SSteve French alloc_size); 318038c8a9a5SSteve French smb_break_all_levII_oplock(work, fp, 1); 318138c8a9a5SSteve French err = vfs_fallocate(fp->filp, FALLOC_FL_KEEP_SIZE, 0, 318238c8a9a5SSteve French alloc_size); 318338c8a9a5SSteve French if (err < 0) 318438c8a9a5SSteve French ksmbd_debug(SMB, 318538c8a9a5SSteve French "vfs_fallocate is failed : %d\n", 318638c8a9a5SSteve French err); 318738c8a9a5SSteve French } 318838c8a9a5SSteve French 318938c8a9a5SSteve French context = smb2_find_context_vals(req, SMB2_CREATE_QUERY_ON_DISK_ID, 4); 319038c8a9a5SSteve French if (IS_ERR(context)) { 319138c8a9a5SSteve French rc = PTR_ERR(context); 319238c8a9a5SSteve French goto err_out; 319338c8a9a5SSteve French } else if (context) { 319438c8a9a5SSteve French ksmbd_debug(SMB, "get query on disk id context\n"); 319538c8a9a5SSteve French query_disk_id = 1; 319638c8a9a5SSteve French } 319738c8a9a5SSteve French } 319838c8a9a5SSteve French 319938c8a9a5SSteve French rc = ksmbd_vfs_getattr(&path, &stat); 320038c8a9a5SSteve French if (rc) 320138c8a9a5SSteve French goto err_out; 320238c8a9a5SSteve French 320338c8a9a5SSteve French if (stat.result_mask & STATX_BTIME) 320438c8a9a5SSteve French fp->create_time = ksmbd_UnixTimeToNT(stat.btime); 320538c8a9a5SSteve French else 320638c8a9a5SSteve French fp->create_time = ksmbd_UnixTimeToNT(stat.ctime); 320738c8a9a5SSteve French if (req->FileAttributes || fp->f_ci->m_fattr == 0) 320838c8a9a5SSteve French fp->f_ci->m_fattr = 320938c8a9a5SSteve French cpu_to_le32(smb2_get_dos_mode(&stat, le32_to_cpu(req->FileAttributes))); 321038c8a9a5SSteve French 321138c8a9a5SSteve French if (!created) 321238c8a9a5SSteve French smb2_update_xattrs(tcon, &path, fp); 321338c8a9a5SSteve French else 321438c8a9a5SSteve French smb2_new_xattrs(tcon, &path, fp); 321538c8a9a5SSteve French 321638c8a9a5SSteve French memcpy(fp->client_guid, conn->ClientGUID, SMB2_CLIENT_GUID_SIZE); 321738c8a9a5SSteve French 321838c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(89); 321938c8a9a5SSteve French rcu_read_lock(); 322038c8a9a5SSteve French opinfo = rcu_dereference(fp->f_opinfo); 322138c8a9a5SSteve French rsp->OplockLevel = opinfo != NULL ? opinfo->level : 0; 322238c8a9a5SSteve French rcu_read_unlock(); 322338c8a9a5SSteve French rsp->Flags = 0; 322438c8a9a5SSteve French rsp->CreateAction = cpu_to_le32(file_info); 322538c8a9a5SSteve French rsp->CreationTime = cpu_to_le64(fp->create_time); 322638c8a9a5SSteve French time = ksmbd_UnixTimeToNT(stat.atime); 322738c8a9a5SSteve French rsp->LastAccessTime = cpu_to_le64(time); 322838c8a9a5SSteve French time = ksmbd_UnixTimeToNT(stat.mtime); 322938c8a9a5SSteve French rsp->LastWriteTime = cpu_to_le64(time); 323038c8a9a5SSteve French time = ksmbd_UnixTimeToNT(stat.ctime); 323138c8a9a5SSteve French rsp->ChangeTime = cpu_to_le64(time); 323238c8a9a5SSteve French rsp->AllocationSize = S_ISDIR(stat.mode) ? 0 : 323338c8a9a5SSteve French cpu_to_le64(stat.blocks << 9); 323438c8a9a5SSteve French rsp->EndofFile = S_ISDIR(stat.mode) ? 0 : cpu_to_le64(stat.size); 323538c8a9a5SSteve French rsp->FileAttributes = fp->f_ci->m_fattr; 323638c8a9a5SSteve French 323738c8a9a5SSteve French rsp->Reserved2 = 0; 323838c8a9a5SSteve French 323938c8a9a5SSteve French rsp->PersistentFileId = fp->persistent_id; 324038c8a9a5SSteve French rsp->VolatileFileId = fp->volatile_id; 324138c8a9a5SSteve French 324238c8a9a5SSteve French rsp->CreateContextsOffset = 0; 324338c8a9a5SSteve French rsp->CreateContextsLength = 0; 324438c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 88); /* StructureSize - 1*/ 324538c8a9a5SSteve French 324638c8a9a5SSteve French /* If lease is request send lease context response */ 324738c8a9a5SSteve French if (opinfo && opinfo->is_lease) { 324838c8a9a5SSteve French struct create_context *lease_ccontext; 324938c8a9a5SSteve French 325038c8a9a5SSteve French ksmbd_debug(SMB, "lease granted on(%s) lease state 0x%x\n", 325138c8a9a5SSteve French name, opinfo->o_lease->state); 325238c8a9a5SSteve French rsp->OplockLevel = SMB2_OPLOCK_LEVEL_LEASE; 325338c8a9a5SSteve French 325438c8a9a5SSteve French lease_ccontext = (struct create_context *)rsp->Buffer; 325538c8a9a5SSteve French contxt_cnt++; 325638c8a9a5SSteve French create_lease_buf(rsp->Buffer, opinfo->o_lease); 325738c8a9a5SSteve French le32_add_cpu(&rsp->CreateContextsLength, 325838c8a9a5SSteve French conn->vals->create_lease_size); 325938c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 326038c8a9a5SSteve French conn->vals->create_lease_size); 326138c8a9a5SSteve French next_ptr = &lease_ccontext->Next; 326238c8a9a5SSteve French next_off = conn->vals->create_lease_size; 326338c8a9a5SSteve French } 326438c8a9a5SSteve French 326538c8a9a5SSteve French if (maximal_access_ctxt) { 326638c8a9a5SSteve French struct create_context *mxac_ccontext; 326738c8a9a5SSteve French 326838c8a9a5SSteve French if (maximal_access == 0) 326938c8a9a5SSteve French ksmbd_vfs_query_maximal_access(idmap, 327038c8a9a5SSteve French path.dentry, 327138c8a9a5SSteve French &maximal_access); 327238c8a9a5SSteve French mxac_ccontext = (struct create_context *)(rsp->Buffer + 327338c8a9a5SSteve French le32_to_cpu(rsp->CreateContextsLength)); 327438c8a9a5SSteve French contxt_cnt++; 327538c8a9a5SSteve French create_mxac_rsp_buf(rsp->Buffer + 327638c8a9a5SSteve French le32_to_cpu(rsp->CreateContextsLength), 327738c8a9a5SSteve French le32_to_cpu(maximal_access)); 327838c8a9a5SSteve French le32_add_cpu(&rsp->CreateContextsLength, 327938c8a9a5SSteve French conn->vals->create_mxac_size); 328038c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 328138c8a9a5SSteve French conn->vals->create_mxac_size); 328238c8a9a5SSteve French if (next_ptr) 328338c8a9a5SSteve French *next_ptr = cpu_to_le32(next_off); 328438c8a9a5SSteve French next_ptr = &mxac_ccontext->Next; 328538c8a9a5SSteve French next_off = conn->vals->create_mxac_size; 328638c8a9a5SSteve French } 328738c8a9a5SSteve French 328838c8a9a5SSteve French if (query_disk_id) { 328938c8a9a5SSteve French struct create_context *disk_id_ccontext; 329038c8a9a5SSteve French 329138c8a9a5SSteve French disk_id_ccontext = (struct create_context *)(rsp->Buffer + 329238c8a9a5SSteve French le32_to_cpu(rsp->CreateContextsLength)); 329338c8a9a5SSteve French contxt_cnt++; 329438c8a9a5SSteve French create_disk_id_rsp_buf(rsp->Buffer + 329538c8a9a5SSteve French le32_to_cpu(rsp->CreateContextsLength), 329638c8a9a5SSteve French stat.ino, tcon->id); 329738c8a9a5SSteve French le32_add_cpu(&rsp->CreateContextsLength, 329838c8a9a5SSteve French conn->vals->create_disk_id_size); 329938c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 330038c8a9a5SSteve French conn->vals->create_disk_id_size); 330138c8a9a5SSteve French if (next_ptr) 330238c8a9a5SSteve French *next_ptr = cpu_to_le32(next_off); 330338c8a9a5SSteve French next_ptr = &disk_id_ccontext->Next; 330438c8a9a5SSteve French next_off = conn->vals->create_disk_id_size; 330538c8a9a5SSteve French } 330638c8a9a5SSteve French 330738c8a9a5SSteve French if (posix_ctxt) { 330838c8a9a5SSteve French contxt_cnt++; 330938c8a9a5SSteve French create_posix_rsp_buf(rsp->Buffer + 331038c8a9a5SSteve French le32_to_cpu(rsp->CreateContextsLength), 331138c8a9a5SSteve French fp); 331238c8a9a5SSteve French le32_add_cpu(&rsp->CreateContextsLength, 331338c8a9a5SSteve French conn->vals->create_posix_size); 331438c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 331538c8a9a5SSteve French conn->vals->create_posix_size); 331638c8a9a5SSteve French if (next_ptr) 331738c8a9a5SSteve French *next_ptr = cpu_to_le32(next_off); 331838c8a9a5SSteve French } 331938c8a9a5SSteve French 332038c8a9a5SSteve French if (contxt_cnt > 0) { 332138c8a9a5SSteve French rsp->CreateContextsOffset = 332238c8a9a5SSteve French cpu_to_le32(offsetof(struct smb2_create_rsp, Buffer)); 332338c8a9a5SSteve French } 332438c8a9a5SSteve French 332538c8a9a5SSteve French err_out: 332638c8a9a5SSteve French if (file_present || created) { 3327*2b57a432SNamjae Jeon inode_unlock(d_inode(parent_path.dentry)); 3328*2b57a432SNamjae Jeon path_put(&path); 3329*2b57a432SNamjae Jeon path_put(&parent_path); 333038c8a9a5SSteve French } 333138c8a9a5SSteve French ksmbd_revert_fsids(work); 333238c8a9a5SSteve French err_out1: 333338c8a9a5SSteve French 333438c8a9a5SSteve French if (rc) { 333538c8a9a5SSteve French if (rc == -EINVAL) 333638c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 333738c8a9a5SSteve French else if (rc == -EOPNOTSUPP) 333838c8a9a5SSteve French rsp->hdr.Status = STATUS_NOT_SUPPORTED; 333938c8a9a5SSteve French else if (rc == -EACCES || rc == -ESTALE || rc == -EXDEV) 334038c8a9a5SSteve French rsp->hdr.Status = STATUS_ACCESS_DENIED; 334138c8a9a5SSteve French else if (rc == -ENOENT) 334238c8a9a5SSteve French rsp->hdr.Status = STATUS_OBJECT_NAME_INVALID; 334338c8a9a5SSteve French else if (rc == -EPERM) 334438c8a9a5SSteve French rsp->hdr.Status = STATUS_SHARING_VIOLATION; 334538c8a9a5SSteve French else if (rc == -EBUSY) 334638c8a9a5SSteve French rsp->hdr.Status = STATUS_DELETE_PENDING; 334738c8a9a5SSteve French else if (rc == -EBADF) 334838c8a9a5SSteve French rsp->hdr.Status = STATUS_OBJECT_NAME_NOT_FOUND; 334938c8a9a5SSteve French else if (rc == -ENOEXEC) 335038c8a9a5SSteve French rsp->hdr.Status = STATUS_DUPLICATE_OBJECTID; 335138c8a9a5SSteve French else if (rc == -ENXIO) 335238c8a9a5SSteve French rsp->hdr.Status = STATUS_NO_SUCH_DEVICE; 335338c8a9a5SSteve French else if (rc == -EEXIST) 335438c8a9a5SSteve French rsp->hdr.Status = STATUS_OBJECT_NAME_COLLISION; 335538c8a9a5SSteve French else if (rc == -EMFILE) 335638c8a9a5SSteve French rsp->hdr.Status = STATUS_INSUFFICIENT_RESOURCES; 335738c8a9a5SSteve French if (!rsp->hdr.Status) 335838c8a9a5SSteve French rsp->hdr.Status = STATUS_UNEXPECTED_IO_ERROR; 335938c8a9a5SSteve French 336038c8a9a5SSteve French if (fp) 336138c8a9a5SSteve French ksmbd_fd_put(work, fp); 336238c8a9a5SSteve French smb2_set_err_rsp(work); 336338c8a9a5SSteve French ksmbd_debug(SMB, "Error response: %x\n", rsp->hdr.Status); 336438c8a9a5SSteve French } 336538c8a9a5SSteve French 336638c8a9a5SSteve French kfree(name); 336738c8a9a5SSteve French kfree(lc); 336838c8a9a5SSteve French 336938c8a9a5SSteve French return 0; 337038c8a9a5SSteve French } 337138c8a9a5SSteve French 337238c8a9a5SSteve French static int readdir_info_level_struct_sz(int info_level) 337338c8a9a5SSteve French { 337438c8a9a5SSteve French switch (info_level) { 337538c8a9a5SSteve French case FILE_FULL_DIRECTORY_INFORMATION: 337638c8a9a5SSteve French return sizeof(struct file_full_directory_info); 337738c8a9a5SSteve French case FILE_BOTH_DIRECTORY_INFORMATION: 337838c8a9a5SSteve French return sizeof(struct file_both_directory_info); 337938c8a9a5SSteve French case FILE_DIRECTORY_INFORMATION: 338038c8a9a5SSteve French return sizeof(struct file_directory_info); 338138c8a9a5SSteve French case FILE_NAMES_INFORMATION: 338238c8a9a5SSteve French return sizeof(struct file_names_info); 338338c8a9a5SSteve French case FILEID_FULL_DIRECTORY_INFORMATION: 338438c8a9a5SSteve French return sizeof(struct file_id_full_dir_info); 338538c8a9a5SSteve French case FILEID_BOTH_DIRECTORY_INFORMATION: 338638c8a9a5SSteve French return sizeof(struct file_id_both_directory_info); 338738c8a9a5SSteve French case SMB_FIND_FILE_POSIX_INFO: 338838c8a9a5SSteve French return sizeof(struct smb2_posix_info); 338938c8a9a5SSteve French default: 339038c8a9a5SSteve French return -EOPNOTSUPP; 339138c8a9a5SSteve French } 339238c8a9a5SSteve French } 339338c8a9a5SSteve French 339438c8a9a5SSteve French static int dentry_name(struct ksmbd_dir_info *d_info, int info_level) 339538c8a9a5SSteve French { 339638c8a9a5SSteve French switch (info_level) { 339738c8a9a5SSteve French case FILE_FULL_DIRECTORY_INFORMATION: 339838c8a9a5SSteve French { 339938c8a9a5SSteve French struct file_full_directory_info *ffdinfo; 340038c8a9a5SSteve French 340138c8a9a5SSteve French ffdinfo = (struct file_full_directory_info *)d_info->rptr; 340238c8a9a5SSteve French d_info->rptr += le32_to_cpu(ffdinfo->NextEntryOffset); 340338c8a9a5SSteve French d_info->name = ffdinfo->FileName; 340438c8a9a5SSteve French d_info->name_len = le32_to_cpu(ffdinfo->FileNameLength); 340538c8a9a5SSteve French return 0; 340638c8a9a5SSteve French } 340738c8a9a5SSteve French case FILE_BOTH_DIRECTORY_INFORMATION: 340838c8a9a5SSteve French { 340938c8a9a5SSteve French struct file_both_directory_info *fbdinfo; 341038c8a9a5SSteve French 341138c8a9a5SSteve French fbdinfo = (struct file_both_directory_info *)d_info->rptr; 341238c8a9a5SSteve French d_info->rptr += le32_to_cpu(fbdinfo->NextEntryOffset); 341338c8a9a5SSteve French d_info->name = fbdinfo->FileName; 341438c8a9a5SSteve French d_info->name_len = le32_to_cpu(fbdinfo->FileNameLength); 341538c8a9a5SSteve French return 0; 341638c8a9a5SSteve French } 341738c8a9a5SSteve French case FILE_DIRECTORY_INFORMATION: 341838c8a9a5SSteve French { 341938c8a9a5SSteve French struct file_directory_info *fdinfo; 342038c8a9a5SSteve French 342138c8a9a5SSteve French fdinfo = (struct file_directory_info *)d_info->rptr; 342238c8a9a5SSteve French d_info->rptr += le32_to_cpu(fdinfo->NextEntryOffset); 342338c8a9a5SSteve French d_info->name = fdinfo->FileName; 342438c8a9a5SSteve French d_info->name_len = le32_to_cpu(fdinfo->FileNameLength); 342538c8a9a5SSteve French return 0; 342638c8a9a5SSteve French } 342738c8a9a5SSteve French case FILE_NAMES_INFORMATION: 342838c8a9a5SSteve French { 342938c8a9a5SSteve French struct file_names_info *fninfo; 343038c8a9a5SSteve French 343138c8a9a5SSteve French fninfo = (struct file_names_info *)d_info->rptr; 343238c8a9a5SSteve French d_info->rptr += le32_to_cpu(fninfo->NextEntryOffset); 343338c8a9a5SSteve French d_info->name = fninfo->FileName; 343438c8a9a5SSteve French d_info->name_len = le32_to_cpu(fninfo->FileNameLength); 343538c8a9a5SSteve French return 0; 343638c8a9a5SSteve French } 343738c8a9a5SSteve French case FILEID_FULL_DIRECTORY_INFORMATION: 343838c8a9a5SSteve French { 343938c8a9a5SSteve French struct file_id_full_dir_info *dinfo; 344038c8a9a5SSteve French 344138c8a9a5SSteve French dinfo = (struct file_id_full_dir_info *)d_info->rptr; 344238c8a9a5SSteve French d_info->rptr += le32_to_cpu(dinfo->NextEntryOffset); 344338c8a9a5SSteve French d_info->name = dinfo->FileName; 344438c8a9a5SSteve French d_info->name_len = le32_to_cpu(dinfo->FileNameLength); 344538c8a9a5SSteve French return 0; 344638c8a9a5SSteve French } 344738c8a9a5SSteve French case FILEID_BOTH_DIRECTORY_INFORMATION: 344838c8a9a5SSteve French { 344938c8a9a5SSteve French struct file_id_both_directory_info *fibdinfo; 345038c8a9a5SSteve French 345138c8a9a5SSteve French fibdinfo = (struct file_id_both_directory_info *)d_info->rptr; 345238c8a9a5SSteve French d_info->rptr += le32_to_cpu(fibdinfo->NextEntryOffset); 345338c8a9a5SSteve French d_info->name = fibdinfo->FileName; 345438c8a9a5SSteve French d_info->name_len = le32_to_cpu(fibdinfo->FileNameLength); 345538c8a9a5SSteve French return 0; 345638c8a9a5SSteve French } 345738c8a9a5SSteve French case SMB_FIND_FILE_POSIX_INFO: 345838c8a9a5SSteve French { 345938c8a9a5SSteve French struct smb2_posix_info *posix_info; 346038c8a9a5SSteve French 346138c8a9a5SSteve French posix_info = (struct smb2_posix_info *)d_info->rptr; 346238c8a9a5SSteve French d_info->rptr += le32_to_cpu(posix_info->NextEntryOffset); 346338c8a9a5SSteve French d_info->name = posix_info->name; 346438c8a9a5SSteve French d_info->name_len = le32_to_cpu(posix_info->name_len); 346538c8a9a5SSteve French return 0; 346638c8a9a5SSteve French } 346738c8a9a5SSteve French default: 346838c8a9a5SSteve French return -EINVAL; 346938c8a9a5SSteve French } 347038c8a9a5SSteve French } 347138c8a9a5SSteve French 347238c8a9a5SSteve French /** 347338c8a9a5SSteve French * smb2_populate_readdir_entry() - encode directory entry in smb2 response 347438c8a9a5SSteve French * buffer 347538c8a9a5SSteve French * @conn: connection instance 347638c8a9a5SSteve French * @info_level: smb information level 347738c8a9a5SSteve French * @d_info: structure included variables for query dir 347838c8a9a5SSteve French * @ksmbd_kstat: ksmbd wrapper of dirent stat information 347938c8a9a5SSteve French * 348038c8a9a5SSteve French * if directory has many entries, find first can't read it fully. 348138c8a9a5SSteve French * find next might be called multiple times to read remaining dir entries 348238c8a9a5SSteve French * 348338c8a9a5SSteve French * Return: 0 on success, otherwise error 348438c8a9a5SSteve French */ 348538c8a9a5SSteve French static int smb2_populate_readdir_entry(struct ksmbd_conn *conn, int info_level, 348638c8a9a5SSteve French struct ksmbd_dir_info *d_info, 348738c8a9a5SSteve French struct ksmbd_kstat *ksmbd_kstat) 348838c8a9a5SSteve French { 348938c8a9a5SSteve French int next_entry_offset = 0; 349038c8a9a5SSteve French char *conv_name; 349138c8a9a5SSteve French int conv_len; 349238c8a9a5SSteve French void *kstat; 349338c8a9a5SSteve French int struct_sz, rc = 0; 349438c8a9a5SSteve French 349538c8a9a5SSteve French conv_name = ksmbd_convert_dir_info_name(d_info, 349638c8a9a5SSteve French conn->local_nls, 349738c8a9a5SSteve French &conv_len); 349838c8a9a5SSteve French if (!conv_name) 349938c8a9a5SSteve French return -ENOMEM; 350038c8a9a5SSteve French 350138c8a9a5SSteve French /* Somehow the name has only terminating NULL bytes */ 350238c8a9a5SSteve French if (conv_len < 0) { 350338c8a9a5SSteve French rc = -EINVAL; 350438c8a9a5SSteve French goto free_conv_name; 350538c8a9a5SSteve French } 350638c8a9a5SSteve French 350738c8a9a5SSteve French struct_sz = readdir_info_level_struct_sz(info_level) + conv_len; 350838c8a9a5SSteve French next_entry_offset = ALIGN(struct_sz, KSMBD_DIR_INFO_ALIGNMENT); 350938c8a9a5SSteve French d_info->last_entry_off_align = next_entry_offset - struct_sz; 351038c8a9a5SSteve French 351138c8a9a5SSteve French if (next_entry_offset > d_info->out_buf_len) { 351238c8a9a5SSteve French d_info->out_buf_len = 0; 351338c8a9a5SSteve French rc = -ENOSPC; 351438c8a9a5SSteve French goto free_conv_name; 351538c8a9a5SSteve French } 351638c8a9a5SSteve French 351738c8a9a5SSteve French kstat = d_info->wptr; 351838c8a9a5SSteve French if (info_level != FILE_NAMES_INFORMATION) 351938c8a9a5SSteve French kstat = ksmbd_vfs_init_kstat(&d_info->wptr, ksmbd_kstat); 352038c8a9a5SSteve French 352138c8a9a5SSteve French switch (info_level) { 352238c8a9a5SSteve French case FILE_FULL_DIRECTORY_INFORMATION: 352338c8a9a5SSteve French { 352438c8a9a5SSteve French struct file_full_directory_info *ffdinfo; 352538c8a9a5SSteve French 352638c8a9a5SSteve French ffdinfo = (struct file_full_directory_info *)kstat; 352738c8a9a5SSteve French ffdinfo->FileNameLength = cpu_to_le32(conv_len); 352838c8a9a5SSteve French ffdinfo->EaSize = 352938c8a9a5SSteve French smb2_get_reparse_tag_special_file(ksmbd_kstat->kstat->mode); 353038c8a9a5SSteve French if (ffdinfo->EaSize) 353138c8a9a5SSteve French ffdinfo->ExtFileAttributes = FILE_ATTRIBUTE_REPARSE_POINT_LE; 353238c8a9a5SSteve French if (d_info->hide_dot_file && d_info->name[0] == '.') 353338c8a9a5SSteve French ffdinfo->ExtFileAttributes |= FILE_ATTRIBUTE_HIDDEN_LE; 353438c8a9a5SSteve French memcpy(ffdinfo->FileName, conv_name, conv_len); 353538c8a9a5SSteve French ffdinfo->NextEntryOffset = cpu_to_le32(next_entry_offset); 353638c8a9a5SSteve French break; 353738c8a9a5SSteve French } 353838c8a9a5SSteve French case FILE_BOTH_DIRECTORY_INFORMATION: 353938c8a9a5SSteve French { 354038c8a9a5SSteve French struct file_both_directory_info *fbdinfo; 354138c8a9a5SSteve French 354238c8a9a5SSteve French fbdinfo = (struct file_both_directory_info *)kstat; 354338c8a9a5SSteve French fbdinfo->FileNameLength = cpu_to_le32(conv_len); 354438c8a9a5SSteve French fbdinfo->EaSize = 354538c8a9a5SSteve French smb2_get_reparse_tag_special_file(ksmbd_kstat->kstat->mode); 354638c8a9a5SSteve French if (fbdinfo->EaSize) 354738c8a9a5SSteve French fbdinfo->ExtFileAttributes = FILE_ATTRIBUTE_REPARSE_POINT_LE; 354838c8a9a5SSteve French fbdinfo->ShortNameLength = 0; 354938c8a9a5SSteve French fbdinfo->Reserved = 0; 355038c8a9a5SSteve French if (d_info->hide_dot_file && d_info->name[0] == '.') 355138c8a9a5SSteve French fbdinfo->ExtFileAttributes |= FILE_ATTRIBUTE_HIDDEN_LE; 355238c8a9a5SSteve French memcpy(fbdinfo->FileName, conv_name, conv_len); 355338c8a9a5SSteve French fbdinfo->NextEntryOffset = cpu_to_le32(next_entry_offset); 355438c8a9a5SSteve French break; 355538c8a9a5SSteve French } 355638c8a9a5SSteve French case FILE_DIRECTORY_INFORMATION: 355738c8a9a5SSteve French { 355838c8a9a5SSteve French struct file_directory_info *fdinfo; 355938c8a9a5SSteve French 356038c8a9a5SSteve French fdinfo = (struct file_directory_info *)kstat; 356138c8a9a5SSteve French fdinfo->FileNameLength = cpu_to_le32(conv_len); 356238c8a9a5SSteve French if (d_info->hide_dot_file && d_info->name[0] == '.') 356338c8a9a5SSteve French fdinfo->ExtFileAttributes |= FILE_ATTRIBUTE_HIDDEN_LE; 356438c8a9a5SSteve French memcpy(fdinfo->FileName, conv_name, conv_len); 356538c8a9a5SSteve French fdinfo->NextEntryOffset = cpu_to_le32(next_entry_offset); 356638c8a9a5SSteve French break; 356738c8a9a5SSteve French } 356838c8a9a5SSteve French case FILE_NAMES_INFORMATION: 356938c8a9a5SSteve French { 357038c8a9a5SSteve French struct file_names_info *fninfo; 357138c8a9a5SSteve French 357238c8a9a5SSteve French fninfo = (struct file_names_info *)kstat; 357338c8a9a5SSteve French fninfo->FileNameLength = cpu_to_le32(conv_len); 357438c8a9a5SSteve French memcpy(fninfo->FileName, conv_name, conv_len); 357538c8a9a5SSteve French fninfo->NextEntryOffset = cpu_to_le32(next_entry_offset); 357638c8a9a5SSteve French break; 357738c8a9a5SSteve French } 357838c8a9a5SSteve French case FILEID_FULL_DIRECTORY_INFORMATION: 357938c8a9a5SSteve French { 358038c8a9a5SSteve French struct file_id_full_dir_info *dinfo; 358138c8a9a5SSteve French 358238c8a9a5SSteve French dinfo = (struct file_id_full_dir_info *)kstat; 358338c8a9a5SSteve French dinfo->FileNameLength = cpu_to_le32(conv_len); 358438c8a9a5SSteve French dinfo->EaSize = 358538c8a9a5SSteve French smb2_get_reparse_tag_special_file(ksmbd_kstat->kstat->mode); 358638c8a9a5SSteve French if (dinfo->EaSize) 358738c8a9a5SSteve French dinfo->ExtFileAttributes = FILE_ATTRIBUTE_REPARSE_POINT_LE; 358838c8a9a5SSteve French dinfo->Reserved = 0; 358938c8a9a5SSteve French dinfo->UniqueId = cpu_to_le64(ksmbd_kstat->kstat->ino); 359038c8a9a5SSteve French if (d_info->hide_dot_file && d_info->name[0] == '.') 359138c8a9a5SSteve French dinfo->ExtFileAttributes |= FILE_ATTRIBUTE_HIDDEN_LE; 359238c8a9a5SSteve French memcpy(dinfo->FileName, conv_name, conv_len); 359338c8a9a5SSteve French dinfo->NextEntryOffset = cpu_to_le32(next_entry_offset); 359438c8a9a5SSteve French break; 359538c8a9a5SSteve French } 359638c8a9a5SSteve French case FILEID_BOTH_DIRECTORY_INFORMATION: 359738c8a9a5SSteve French { 359838c8a9a5SSteve French struct file_id_both_directory_info *fibdinfo; 359938c8a9a5SSteve French 360038c8a9a5SSteve French fibdinfo = (struct file_id_both_directory_info *)kstat; 360138c8a9a5SSteve French fibdinfo->FileNameLength = cpu_to_le32(conv_len); 360238c8a9a5SSteve French fibdinfo->EaSize = 360338c8a9a5SSteve French smb2_get_reparse_tag_special_file(ksmbd_kstat->kstat->mode); 360438c8a9a5SSteve French if (fibdinfo->EaSize) 360538c8a9a5SSteve French fibdinfo->ExtFileAttributes = FILE_ATTRIBUTE_REPARSE_POINT_LE; 360638c8a9a5SSteve French fibdinfo->UniqueId = cpu_to_le64(ksmbd_kstat->kstat->ino); 360738c8a9a5SSteve French fibdinfo->ShortNameLength = 0; 360838c8a9a5SSteve French fibdinfo->Reserved = 0; 360938c8a9a5SSteve French fibdinfo->Reserved2 = cpu_to_le16(0); 361038c8a9a5SSteve French if (d_info->hide_dot_file && d_info->name[0] == '.') 361138c8a9a5SSteve French fibdinfo->ExtFileAttributes |= FILE_ATTRIBUTE_HIDDEN_LE; 361238c8a9a5SSteve French memcpy(fibdinfo->FileName, conv_name, conv_len); 361338c8a9a5SSteve French fibdinfo->NextEntryOffset = cpu_to_le32(next_entry_offset); 361438c8a9a5SSteve French break; 361538c8a9a5SSteve French } 361638c8a9a5SSteve French case SMB_FIND_FILE_POSIX_INFO: 361738c8a9a5SSteve French { 361838c8a9a5SSteve French struct smb2_posix_info *posix_info; 361938c8a9a5SSteve French u64 time; 362038c8a9a5SSteve French 362138c8a9a5SSteve French posix_info = (struct smb2_posix_info *)kstat; 362238c8a9a5SSteve French posix_info->Ignored = 0; 362338c8a9a5SSteve French posix_info->CreationTime = cpu_to_le64(ksmbd_kstat->create_time); 362438c8a9a5SSteve French time = ksmbd_UnixTimeToNT(ksmbd_kstat->kstat->ctime); 362538c8a9a5SSteve French posix_info->ChangeTime = cpu_to_le64(time); 362638c8a9a5SSteve French time = ksmbd_UnixTimeToNT(ksmbd_kstat->kstat->atime); 362738c8a9a5SSteve French posix_info->LastAccessTime = cpu_to_le64(time); 362838c8a9a5SSteve French time = ksmbd_UnixTimeToNT(ksmbd_kstat->kstat->mtime); 362938c8a9a5SSteve French posix_info->LastWriteTime = cpu_to_le64(time); 363038c8a9a5SSteve French posix_info->EndOfFile = cpu_to_le64(ksmbd_kstat->kstat->size); 363138c8a9a5SSteve French posix_info->AllocationSize = cpu_to_le64(ksmbd_kstat->kstat->blocks << 9); 363238c8a9a5SSteve French posix_info->DeviceId = cpu_to_le32(ksmbd_kstat->kstat->rdev); 363338c8a9a5SSteve French posix_info->HardLinks = cpu_to_le32(ksmbd_kstat->kstat->nlink); 363438c8a9a5SSteve French posix_info->Mode = cpu_to_le32(ksmbd_kstat->kstat->mode & 0777); 363538c8a9a5SSteve French posix_info->Inode = cpu_to_le64(ksmbd_kstat->kstat->ino); 363638c8a9a5SSteve French posix_info->DosAttributes = 363738c8a9a5SSteve French S_ISDIR(ksmbd_kstat->kstat->mode) ? 363838c8a9a5SSteve French FILE_ATTRIBUTE_DIRECTORY_LE : FILE_ATTRIBUTE_ARCHIVE_LE; 363938c8a9a5SSteve French if (d_info->hide_dot_file && d_info->name[0] == '.') 364038c8a9a5SSteve French posix_info->DosAttributes |= FILE_ATTRIBUTE_HIDDEN_LE; 364138c8a9a5SSteve French /* 364238c8a9a5SSteve French * SidBuffer(32) contain two sids(Domain sid(16), UNIX group sid(16)). 364338c8a9a5SSteve French * UNIX sid(16) = revision(1) + num_subauth(1) + authority(6) + 364438c8a9a5SSteve French * sub_auth(4 * 1(num_subauth)) + RID(4). 364538c8a9a5SSteve French */ 364638c8a9a5SSteve French id_to_sid(from_kuid_munged(&init_user_ns, ksmbd_kstat->kstat->uid), 364738c8a9a5SSteve French SIDUNIX_USER, (struct smb_sid *)&posix_info->SidBuffer[0]); 364838c8a9a5SSteve French id_to_sid(from_kgid_munged(&init_user_ns, ksmbd_kstat->kstat->gid), 364938c8a9a5SSteve French SIDUNIX_GROUP, (struct smb_sid *)&posix_info->SidBuffer[16]); 365038c8a9a5SSteve French memcpy(posix_info->name, conv_name, conv_len); 365138c8a9a5SSteve French posix_info->name_len = cpu_to_le32(conv_len); 365238c8a9a5SSteve French posix_info->NextEntryOffset = cpu_to_le32(next_entry_offset); 365338c8a9a5SSteve French break; 365438c8a9a5SSteve French } 365538c8a9a5SSteve French 365638c8a9a5SSteve French } /* switch (info_level) */ 365738c8a9a5SSteve French 365838c8a9a5SSteve French d_info->last_entry_offset = d_info->data_count; 365938c8a9a5SSteve French d_info->data_count += next_entry_offset; 366038c8a9a5SSteve French d_info->out_buf_len -= next_entry_offset; 366138c8a9a5SSteve French d_info->wptr += next_entry_offset; 366238c8a9a5SSteve French 366338c8a9a5SSteve French ksmbd_debug(SMB, 366438c8a9a5SSteve French "info_level : %d, buf_len :%d, next_offset : %d, data_count : %d\n", 366538c8a9a5SSteve French info_level, d_info->out_buf_len, 366638c8a9a5SSteve French next_entry_offset, d_info->data_count); 366738c8a9a5SSteve French 366838c8a9a5SSteve French free_conv_name: 366938c8a9a5SSteve French kfree(conv_name); 367038c8a9a5SSteve French return rc; 367138c8a9a5SSteve French } 367238c8a9a5SSteve French 367338c8a9a5SSteve French struct smb2_query_dir_private { 367438c8a9a5SSteve French struct ksmbd_work *work; 367538c8a9a5SSteve French char *search_pattern; 367638c8a9a5SSteve French struct ksmbd_file *dir_fp; 367738c8a9a5SSteve French 367838c8a9a5SSteve French struct ksmbd_dir_info *d_info; 367938c8a9a5SSteve French int info_level; 368038c8a9a5SSteve French }; 368138c8a9a5SSteve French 368238c8a9a5SSteve French static void lock_dir(struct ksmbd_file *dir_fp) 368338c8a9a5SSteve French { 368438c8a9a5SSteve French struct dentry *dir = dir_fp->filp->f_path.dentry; 368538c8a9a5SSteve French 368638c8a9a5SSteve French inode_lock_nested(d_inode(dir), I_MUTEX_PARENT); 368738c8a9a5SSteve French } 368838c8a9a5SSteve French 368938c8a9a5SSteve French static void unlock_dir(struct ksmbd_file *dir_fp) 369038c8a9a5SSteve French { 369138c8a9a5SSteve French struct dentry *dir = dir_fp->filp->f_path.dentry; 369238c8a9a5SSteve French 369338c8a9a5SSteve French inode_unlock(d_inode(dir)); 369438c8a9a5SSteve French } 369538c8a9a5SSteve French 369638c8a9a5SSteve French static int process_query_dir_entries(struct smb2_query_dir_private *priv) 369738c8a9a5SSteve French { 369838c8a9a5SSteve French struct mnt_idmap *idmap = file_mnt_idmap(priv->dir_fp->filp); 369938c8a9a5SSteve French struct kstat kstat; 370038c8a9a5SSteve French struct ksmbd_kstat ksmbd_kstat; 370138c8a9a5SSteve French int rc; 370238c8a9a5SSteve French int i; 370338c8a9a5SSteve French 370438c8a9a5SSteve French for (i = 0; i < priv->d_info->num_entry; i++) { 370538c8a9a5SSteve French struct dentry *dent; 370638c8a9a5SSteve French 370738c8a9a5SSteve French if (dentry_name(priv->d_info, priv->info_level)) 370838c8a9a5SSteve French return -EINVAL; 370938c8a9a5SSteve French 371038c8a9a5SSteve French lock_dir(priv->dir_fp); 371138c8a9a5SSteve French dent = lookup_one(idmap, priv->d_info->name, 371238c8a9a5SSteve French priv->dir_fp->filp->f_path.dentry, 371338c8a9a5SSteve French priv->d_info->name_len); 371438c8a9a5SSteve French unlock_dir(priv->dir_fp); 371538c8a9a5SSteve French 371638c8a9a5SSteve French if (IS_ERR(dent)) { 371738c8a9a5SSteve French ksmbd_debug(SMB, "Cannot lookup `%s' [%ld]\n", 371838c8a9a5SSteve French priv->d_info->name, 371938c8a9a5SSteve French PTR_ERR(dent)); 372038c8a9a5SSteve French continue; 372138c8a9a5SSteve French } 372238c8a9a5SSteve French if (unlikely(d_is_negative(dent))) { 372338c8a9a5SSteve French dput(dent); 372438c8a9a5SSteve French ksmbd_debug(SMB, "Negative dentry `%s'\n", 372538c8a9a5SSteve French priv->d_info->name); 372638c8a9a5SSteve French continue; 372738c8a9a5SSteve French } 372838c8a9a5SSteve French 372938c8a9a5SSteve French ksmbd_kstat.kstat = &kstat; 373038c8a9a5SSteve French if (priv->info_level != FILE_NAMES_INFORMATION) 373138c8a9a5SSteve French ksmbd_vfs_fill_dentry_attrs(priv->work, 373238c8a9a5SSteve French idmap, 373338c8a9a5SSteve French dent, 373438c8a9a5SSteve French &ksmbd_kstat); 373538c8a9a5SSteve French 373638c8a9a5SSteve French rc = smb2_populate_readdir_entry(priv->work->conn, 373738c8a9a5SSteve French priv->info_level, 373838c8a9a5SSteve French priv->d_info, 373938c8a9a5SSteve French &ksmbd_kstat); 374038c8a9a5SSteve French dput(dent); 374138c8a9a5SSteve French if (rc) 374238c8a9a5SSteve French return rc; 374338c8a9a5SSteve French } 374438c8a9a5SSteve French return 0; 374538c8a9a5SSteve French } 374638c8a9a5SSteve French 374738c8a9a5SSteve French static int reserve_populate_dentry(struct ksmbd_dir_info *d_info, 374838c8a9a5SSteve French int info_level) 374938c8a9a5SSteve French { 375038c8a9a5SSteve French int struct_sz; 375138c8a9a5SSteve French int conv_len; 375238c8a9a5SSteve French int next_entry_offset; 375338c8a9a5SSteve French 375438c8a9a5SSteve French struct_sz = readdir_info_level_struct_sz(info_level); 375538c8a9a5SSteve French if (struct_sz == -EOPNOTSUPP) 375638c8a9a5SSteve French return -EOPNOTSUPP; 375738c8a9a5SSteve French 375838c8a9a5SSteve French conv_len = (d_info->name_len + 1) * 2; 375938c8a9a5SSteve French next_entry_offset = ALIGN(struct_sz + conv_len, 376038c8a9a5SSteve French KSMBD_DIR_INFO_ALIGNMENT); 376138c8a9a5SSteve French 376238c8a9a5SSteve French if (next_entry_offset > d_info->out_buf_len) { 376338c8a9a5SSteve French d_info->out_buf_len = 0; 376438c8a9a5SSteve French return -ENOSPC; 376538c8a9a5SSteve French } 376638c8a9a5SSteve French 376738c8a9a5SSteve French switch (info_level) { 376838c8a9a5SSteve French case FILE_FULL_DIRECTORY_INFORMATION: 376938c8a9a5SSteve French { 377038c8a9a5SSteve French struct file_full_directory_info *ffdinfo; 377138c8a9a5SSteve French 377238c8a9a5SSteve French ffdinfo = (struct file_full_directory_info *)d_info->wptr; 377338c8a9a5SSteve French memcpy(ffdinfo->FileName, d_info->name, d_info->name_len); 377438c8a9a5SSteve French ffdinfo->FileName[d_info->name_len] = 0x00; 377538c8a9a5SSteve French ffdinfo->FileNameLength = cpu_to_le32(d_info->name_len); 377638c8a9a5SSteve French ffdinfo->NextEntryOffset = cpu_to_le32(next_entry_offset); 377738c8a9a5SSteve French break; 377838c8a9a5SSteve French } 377938c8a9a5SSteve French case FILE_BOTH_DIRECTORY_INFORMATION: 378038c8a9a5SSteve French { 378138c8a9a5SSteve French struct file_both_directory_info *fbdinfo; 378238c8a9a5SSteve French 378338c8a9a5SSteve French fbdinfo = (struct file_both_directory_info *)d_info->wptr; 378438c8a9a5SSteve French memcpy(fbdinfo->FileName, d_info->name, d_info->name_len); 378538c8a9a5SSteve French fbdinfo->FileName[d_info->name_len] = 0x00; 378638c8a9a5SSteve French fbdinfo->FileNameLength = cpu_to_le32(d_info->name_len); 378738c8a9a5SSteve French fbdinfo->NextEntryOffset = cpu_to_le32(next_entry_offset); 378838c8a9a5SSteve French break; 378938c8a9a5SSteve French } 379038c8a9a5SSteve French case FILE_DIRECTORY_INFORMATION: 379138c8a9a5SSteve French { 379238c8a9a5SSteve French struct file_directory_info *fdinfo; 379338c8a9a5SSteve French 379438c8a9a5SSteve French fdinfo = (struct file_directory_info *)d_info->wptr; 379538c8a9a5SSteve French memcpy(fdinfo->FileName, d_info->name, d_info->name_len); 379638c8a9a5SSteve French fdinfo->FileName[d_info->name_len] = 0x00; 379738c8a9a5SSteve French fdinfo->FileNameLength = cpu_to_le32(d_info->name_len); 379838c8a9a5SSteve French fdinfo->NextEntryOffset = cpu_to_le32(next_entry_offset); 379938c8a9a5SSteve French break; 380038c8a9a5SSteve French } 380138c8a9a5SSteve French case FILE_NAMES_INFORMATION: 380238c8a9a5SSteve French { 380338c8a9a5SSteve French struct file_names_info *fninfo; 380438c8a9a5SSteve French 380538c8a9a5SSteve French fninfo = (struct file_names_info *)d_info->wptr; 380638c8a9a5SSteve French memcpy(fninfo->FileName, d_info->name, d_info->name_len); 380738c8a9a5SSteve French fninfo->FileName[d_info->name_len] = 0x00; 380838c8a9a5SSteve French fninfo->FileNameLength = cpu_to_le32(d_info->name_len); 380938c8a9a5SSteve French fninfo->NextEntryOffset = cpu_to_le32(next_entry_offset); 381038c8a9a5SSteve French break; 381138c8a9a5SSteve French } 381238c8a9a5SSteve French case FILEID_FULL_DIRECTORY_INFORMATION: 381338c8a9a5SSteve French { 381438c8a9a5SSteve French struct file_id_full_dir_info *dinfo; 381538c8a9a5SSteve French 381638c8a9a5SSteve French dinfo = (struct file_id_full_dir_info *)d_info->wptr; 381738c8a9a5SSteve French memcpy(dinfo->FileName, d_info->name, d_info->name_len); 381838c8a9a5SSteve French dinfo->FileName[d_info->name_len] = 0x00; 381938c8a9a5SSteve French dinfo->FileNameLength = cpu_to_le32(d_info->name_len); 382038c8a9a5SSteve French dinfo->NextEntryOffset = cpu_to_le32(next_entry_offset); 382138c8a9a5SSteve French break; 382238c8a9a5SSteve French } 382338c8a9a5SSteve French case FILEID_BOTH_DIRECTORY_INFORMATION: 382438c8a9a5SSteve French { 382538c8a9a5SSteve French struct file_id_both_directory_info *fibdinfo; 382638c8a9a5SSteve French 382738c8a9a5SSteve French fibdinfo = (struct file_id_both_directory_info *)d_info->wptr; 382838c8a9a5SSteve French memcpy(fibdinfo->FileName, d_info->name, d_info->name_len); 382938c8a9a5SSteve French fibdinfo->FileName[d_info->name_len] = 0x00; 383038c8a9a5SSteve French fibdinfo->FileNameLength = cpu_to_le32(d_info->name_len); 383138c8a9a5SSteve French fibdinfo->NextEntryOffset = cpu_to_le32(next_entry_offset); 383238c8a9a5SSteve French break; 383338c8a9a5SSteve French } 383438c8a9a5SSteve French case SMB_FIND_FILE_POSIX_INFO: 383538c8a9a5SSteve French { 383638c8a9a5SSteve French struct smb2_posix_info *posix_info; 383738c8a9a5SSteve French 383838c8a9a5SSteve French posix_info = (struct smb2_posix_info *)d_info->wptr; 383938c8a9a5SSteve French memcpy(posix_info->name, d_info->name, d_info->name_len); 384038c8a9a5SSteve French posix_info->name[d_info->name_len] = 0x00; 384138c8a9a5SSteve French posix_info->name_len = cpu_to_le32(d_info->name_len); 384238c8a9a5SSteve French posix_info->NextEntryOffset = 384338c8a9a5SSteve French cpu_to_le32(next_entry_offset); 384438c8a9a5SSteve French break; 384538c8a9a5SSteve French } 384638c8a9a5SSteve French } /* switch (info_level) */ 384738c8a9a5SSteve French 384838c8a9a5SSteve French d_info->num_entry++; 384938c8a9a5SSteve French d_info->out_buf_len -= next_entry_offset; 385038c8a9a5SSteve French d_info->wptr += next_entry_offset; 385138c8a9a5SSteve French return 0; 385238c8a9a5SSteve French } 385338c8a9a5SSteve French 385438c8a9a5SSteve French static bool __query_dir(struct dir_context *ctx, const char *name, int namlen, 385538c8a9a5SSteve French loff_t offset, u64 ino, unsigned int d_type) 385638c8a9a5SSteve French { 385738c8a9a5SSteve French struct ksmbd_readdir_data *buf; 385838c8a9a5SSteve French struct smb2_query_dir_private *priv; 385938c8a9a5SSteve French struct ksmbd_dir_info *d_info; 386038c8a9a5SSteve French int rc; 386138c8a9a5SSteve French 386238c8a9a5SSteve French buf = container_of(ctx, struct ksmbd_readdir_data, ctx); 386338c8a9a5SSteve French priv = buf->private; 386438c8a9a5SSteve French d_info = priv->d_info; 386538c8a9a5SSteve French 386638c8a9a5SSteve French /* dot and dotdot entries are already reserved */ 386738c8a9a5SSteve French if (!strcmp(".", name) || !strcmp("..", name)) 386838c8a9a5SSteve French return true; 386938c8a9a5SSteve French if (ksmbd_share_veto_filename(priv->work->tcon->share_conf, name)) 387038c8a9a5SSteve French return true; 387138c8a9a5SSteve French if (!match_pattern(name, namlen, priv->search_pattern)) 387238c8a9a5SSteve French return true; 387338c8a9a5SSteve French 387438c8a9a5SSteve French d_info->name = name; 387538c8a9a5SSteve French d_info->name_len = namlen; 387638c8a9a5SSteve French rc = reserve_populate_dentry(d_info, priv->info_level); 387738c8a9a5SSteve French if (rc) 387838c8a9a5SSteve French return false; 387938c8a9a5SSteve French if (d_info->flags & SMB2_RETURN_SINGLE_ENTRY) 388038c8a9a5SSteve French d_info->out_buf_len = 0; 388138c8a9a5SSteve French return true; 388238c8a9a5SSteve French } 388338c8a9a5SSteve French 388438c8a9a5SSteve French static int verify_info_level(int info_level) 388538c8a9a5SSteve French { 388638c8a9a5SSteve French switch (info_level) { 388738c8a9a5SSteve French case FILE_FULL_DIRECTORY_INFORMATION: 388838c8a9a5SSteve French case FILE_BOTH_DIRECTORY_INFORMATION: 388938c8a9a5SSteve French case FILE_DIRECTORY_INFORMATION: 389038c8a9a5SSteve French case FILE_NAMES_INFORMATION: 389138c8a9a5SSteve French case FILEID_FULL_DIRECTORY_INFORMATION: 389238c8a9a5SSteve French case FILEID_BOTH_DIRECTORY_INFORMATION: 389338c8a9a5SSteve French case SMB_FIND_FILE_POSIX_INFO: 389438c8a9a5SSteve French break; 389538c8a9a5SSteve French default: 389638c8a9a5SSteve French return -EOPNOTSUPP; 389738c8a9a5SSteve French } 389838c8a9a5SSteve French 389938c8a9a5SSteve French return 0; 390038c8a9a5SSteve French } 390138c8a9a5SSteve French 390238c8a9a5SSteve French static int smb2_resp_buf_len(struct ksmbd_work *work, unsigned short hdr2_len) 390338c8a9a5SSteve French { 390438c8a9a5SSteve French int free_len; 390538c8a9a5SSteve French 390638c8a9a5SSteve French free_len = (int)(work->response_sz - 390738c8a9a5SSteve French (get_rfc1002_len(work->response_buf) + 4)) - hdr2_len; 390838c8a9a5SSteve French return free_len; 390938c8a9a5SSteve French } 391038c8a9a5SSteve French 391138c8a9a5SSteve French static int smb2_calc_max_out_buf_len(struct ksmbd_work *work, 391238c8a9a5SSteve French unsigned short hdr2_len, 391338c8a9a5SSteve French unsigned int out_buf_len) 391438c8a9a5SSteve French { 391538c8a9a5SSteve French int free_len; 391638c8a9a5SSteve French 391738c8a9a5SSteve French if (out_buf_len > work->conn->vals->max_trans_size) 391838c8a9a5SSteve French return -EINVAL; 391938c8a9a5SSteve French 392038c8a9a5SSteve French free_len = smb2_resp_buf_len(work, hdr2_len); 392138c8a9a5SSteve French if (free_len < 0) 392238c8a9a5SSteve French return -EINVAL; 392338c8a9a5SSteve French 392438c8a9a5SSteve French return min_t(int, out_buf_len, free_len); 392538c8a9a5SSteve French } 392638c8a9a5SSteve French 392738c8a9a5SSteve French int smb2_query_dir(struct ksmbd_work *work) 392838c8a9a5SSteve French { 392938c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 393038c8a9a5SSteve French struct smb2_query_directory_req *req; 393138c8a9a5SSteve French struct smb2_query_directory_rsp *rsp; 393238c8a9a5SSteve French struct ksmbd_share_config *share = work->tcon->share_conf; 393338c8a9a5SSteve French struct ksmbd_file *dir_fp = NULL; 393438c8a9a5SSteve French struct ksmbd_dir_info d_info; 393538c8a9a5SSteve French int rc = 0; 393638c8a9a5SSteve French char *srch_ptr = NULL; 393738c8a9a5SSteve French unsigned char srch_flag; 393838c8a9a5SSteve French int buffer_sz; 393938c8a9a5SSteve French struct smb2_query_dir_private query_dir_private = {NULL, }; 394038c8a9a5SSteve French 394138c8a9a5SSteve French WORK_BUFFERS(work, req, rsp); 394238c8a9a5SSteve French 394338c8a9a5SSteve French if (ksmbd_override_fsids(work)) { 394438c8a9a5SSteve French rsp->hdr.Status = STATUS_NO_MEMORY; 394538c8a9a5SSteve French smb2_set_err_rsp(work); 394638c8a9a5SSteve French return -ENOMEM; 394738c8a9a5SSteve French } 394838c8a9a5SSteve French 394938c8a9a5SSteve French rc = verify_info_level(req->FileInformationClass); 395038c8a9a5SSteve French if (rc) { 395138c8a9a5SSteve French rc = -EFAULT; 395238c8a9a5SSteve French goto err_out2; 395338c8a9a5SSteve French } 395438c8a9a5SSteve French 395538c8a9a5SSteve French dir_fp = ksmbd_lookup_fd_slow(work, req->VolatileFileId, req->PersistentFileId); 395638c8a9a5SSteve French if (!dir_fp) { 395738c8a9a5SSteve French rc = -EBADF; 395838c8a9a5SSteve French goto err_out2; 395938c8a9a5SSteve French } 396038c8a9a5SSteve French 396138c8a9a5SSteve French if (!(dir_fp->daccess & FILE_LIST_DIRECTORY_LE) || 396238c8a9a5SSteve French inode_permission(file_mnt_idmap(dir_fp->filp), 396338c8a9a5SSteve French file_inode(dir_fp->filp), 396438c8a9a5SSteve French MAY_READ | MAY_EXEC)) { 396538c8a9a5SSteve French pr_err("no right to enumerate directory (%pD)\n", dir_fp->filp); 396638c8a9a5SSteve French rc = -EACCES; 396738c8a9a5SSteve French goto err_out2; 396838c8a9a5SSteve French } 396938c8a9a5SSteve French 397038c8a9a5SSteve French if (!S_ISDIR(file_inode(dir_fp->filp)->i_mode)) { 397138c8a9a5SSteve French pr_err("can't do query dir for a file\n"); 397238c8a9a5SSteve French rc = -EINVAL; 397338c8a9a5SSteve French goto err_out2; 397438c8a9a5SSteve French } 397538c8a9a5SSteve French 397638c8a9a5SSteve French srch_flag = req->Flags; 397738c8a9a5SSteve French srch_ptr = smb_strndup_from_utf16(req->Buffer, 397838c8a9a5SSteve French le16_to_cpu(req->FileNameLength), 1, 397938c8a9a5SSteve French conn->local_nls); 398038c8a9a5SSteve French if (IS_ERR(srch_ptr)) { 398138c8a9a5SSteve French ksmbd_debug(SMB, "Search Pattern not found\n"); 398238c8a9a5SSteve French rc = -EINVAL; 398338c8a9a5SSteve French goto err_out2; 398438c8a9a5SSteve French } else { 398538c8a9a5SSteve French ksmbd_debug(SMB, "Search pattern is %s\n", srch_ptr); 398638c8a9a5SSteve French } 398738c8a9a5SSteve French 398838c8a9a5SSteve French if (srch_flag & SMB2_REOPEN || srch_flag & SMB2_RESTART_SCANS) { 398938c8a9a5SSteve French ksmbd_debug(SMB, "Restart directory scan\n"); 399038c8a9a5SSteve French generic_file_llseek(dir_fp->filp, 0, SEEK_SET); 399138c8a9a5SSteve French } 399238c8a9a5SSteve French 399338c8a9a5SSteve French memset(&d_info, 0, sizeof(struct ksmbd_dir_info)); 399438c8a9a5SSteve French d_info.wptr = (char *)rsp->Buffer; 399538c8a9a5SSteve French d_info.rptr = (char *)rsp->Buffer; 399638c8a9a5SSteve French d_info.out_buf_len = 399738c8a9a5SSteve French smb2_calc_max_out_buf_len(work, 8, 399838c8a9a5SSteve French le32_to_cpu(req->OutputBufferLength)); 399938c8a9a5SSteve French if (d_info.out_buf_len < 0) { 400038c8a9a5SSteve French rc = -EINVAL; 400138c8a9a5SSteve French goto err_out; 400238c8a9a5SSteve French } 400338c8a9a5SSteve French d_info.flags = srch_flag; 400438c8a9a5SSteve French 400538c8a9a5SSteve French /* 400638c8a9a5SSteve French * reserve dot and dotdot entries in head of buffer 400738c8a9a5SSteve French * in first response 400838c8a9a5SSteve French */ 400938c8a9a5SSteve French rc = ksmbd_populate_dot_dotdot_entries(work, req->FileInformationClass, 401038c8a9a5SSteve French dir_fp, &d_info, srch_ptr, 401138c8a9a5SSteve French smb2_populate_readdir_entry); 401238c8a9a5SSteve French if (rc == -ENOSPC) 401338c8a9a5SSteve French rc = 0; 401438c8a9a5SSteve French else if (rc) 401538c8a9a5SSteve French goto err_out; 401638c8a9a5SSteve French 401738c8a9a5SSteve French if (test_share_config_flag(share, KSMBD_SHARE_FLAG_HIDE_DOT_FILES)) 401838c8a9a5SSteve French d_info.hide_dot_file = true; 401938c8a9a5SSteve French 402038c8a9a5SSteve French buffer_sz = d_info.out_buf_len; 402138c8a9a5SSteve French d_info.rptr = d_info.wptr; 402238c8a9a5SSteve French query_dir_private.work = work; 402338c8a9a5SSteve French query_dir_private.search_pattern = srch_ptr; 402438c8a9a5SSteve French query_dir_private.dir_fp = dir_fp; 402538c8a9a5SSteve French query_dir_private.d_info = &d_info; 402638c8a9a5SSteve French query_dir_private.info_level = req->FileInformationClass; 402738c8a9a5SSteve French dir_fp->readdir_data.private = &query_dir_private; 402838c8a9a5SSteve French set_ctx_actor(&dir_fp->readdir_data.ctx, __query_dir); 402938c8a9a5SSteve French 403038c8a9a5SSteve French rc = iterate_dir(dir_fp->filp, &dir_fp->readdir_data.ctx); 403138c8a9a5SSteve French /* 403238c8a9a5SSteve French * req->OutputBufferLength is too small to contain even one entry. 403338c8a9a5SSteve French * In this case, it immediately returns OutputBufferLength 0 to client. 403438c8a9a5SSteve French */ 403538c8a9a5SSteve French if (!d_info.out_buf_len && !d_info.num_entry) 403638c8a9a5SSteve French goto no_buf_len; 403738c8a9a5SSteve French if (rc > 0 || rc == -ENOSPC) 403838c8a9a5SSteve French rc = 0; 403938c8a9a5SSteve French else if (rc) 404038c8a9a5SSteve French goto err_out; 404138c8a9a5SSteve French 404238c8a9a5SSteve French d_info.wptr = d_info.rptr; 404338c8a9a5SSteve French d_info.out_buf_len = buffer_sz; 404438c8a9a5SSteve French rc = process_query_dir_entries(&query_dir_private); 404538c8a9a5SSteve French if (rc) 404638c8a9a5SSteve French goto err_out; 404738c8a9a5SSteve French 404838c8a9a5SSteve French if (!d_info.data_count && d_info.out_buf_len >= 0) { 404938c8a9a5SSteve French if (srch_flag & SMB2_RETURN_SINGLE_ENTRY && !is_asterisk(srch_ptr)) { 405038c8a9a5SSteve French rsp->hdr.Status = STATUS_NO_SUCH_FILE; 405138c8a9a5SSteve French } else { 405238c8a9a5SSteve French dir_fp->dot_dotdot[0] = dir_fp->dot_dotdot[1] = 0; 405338c8a9a5SSteve French rsp->hdr.Status = STATUS_NO_MORE_FILES; 405438c8a9a5SSteve French } 405538c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(9); 405638c8a9a5SSteve French rsp->OutputBufferOffset = cpu_to_le16(0); 405738c8a9a5SSteve French rsp->OutputBufferLength = cpu_to_le32(0); 405838c8a9a5SSteve French rsp->Buffer[0] = 0; 405938c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 9); 406038c8a9a5SSteve French } else { 406138c8a9a5SSteve French no_buf_len: 406238c8a9a5SSteve French ((struct file_directory_info *) 406338c8a9a5SSteve French ((char *)rsp->Buffer + d_info.last_entry_offset)) 406438c8a9a5SSteve French ->NextEntryOffset = 0; 406538c8a9a5SSteve French if (d_info.data_count >= d_info.last_entry_off_align) 406638c8a9a5SSteve French d_info.data_count -= d_info.last_entry_off_align; 406738c8a9a5SSteve French 406838c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(9); 406938c8a9a5SSteve French rsp->OutputBufferOffset = cpu_to_le16(72); 407038c8a9a5SSteve French rsp->OutputBufferLength = cpu_to_le32(d_info.data_count); 407138c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 8 + d_info.data_count); 407238c8a9a5SSteve French } 407338c8a9a5SSteve French 407438c8a9a5SSteve French kfree(srch_ptr); 407538c8a9a5SSteve French ksmbd_fd_put(work, dir_fp); 407638c8a9a5SSteve French ksmbd_revert_fsids(work); 407738c8a9a5SSteve French return 0; 407838c8a9a5SSteve French 407938c8a9a5SSteve French err_out: 408038c8a9a5SSteve French pr_err("error while processing smb2 query dir rc = %d\n", rc); 408138c8a9a5SSteve French kfree(srch_ptr); 408238c8a9a5SSteve French 408338c8a9a5SSteve French err_out2: 408438c8a9a5SSteve French if (rc == -EINVAL) 408538c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 408638c8a9a5SSteve French else if (rc == -EACCES) 408738c8a9a5SSteve French rsp->hdr.Status = STATUS_ACCESS_DENIED; 408838c8a9a5SSteve French else if (rc == -ENOENT) 408938c8a9a5SSteve French rsp->hdr.Status = STATUS_NO_SUCH_FILE; 409038c8a9a5SSteve French else if (rc == -EBADF) 409138c8a9a5SSteve French rsp->hdr.Status = STATUS_FILE_CLOSED; 409238c8a9a5SSteve French else if (rc == -ENOMEM) 409338c8a9a5SSteve French rsp->hdr.Status = STATUS_NO_MEMORY; 409438c8a9a5SSteve French else if (rc == -EFAULT) 409538c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_INFO_CLASS; 409638c8a9a5SSteve French else if (rc == -EIO) 409738c8a9a5SSteve French rsp->hdr.Status = STATUS_FILE_CORRUPT_ERROR; 409838c8a9a5SSteve French if (!rsp->hdr.Status) 409938c8a9a5SSteve French rsp->hdr.Status = STATUS_UNEXPECTED_IO_ERROR; 410038c8a9a5SSteve French 410138c8a9a5SSteve French smb2_set_err_rsp(work); 410238c8a9a5SSteve French ksmbd_fd_put(work, dir_fp); 410338c8a9a5SSteve French ksmbd_revert_fsids(work); 410438c8a9a5SSteve French return 0; 410538c8a9a5SSteve French } 410638c8a9a5SSteve French 410738c8a9a5SSteve French /** 410838c8a9a5SSteve French * buffer_check_err() - helper function to check buffer errors 410938c8a9a5SSteve French * @reqOutputBufferLength: max buffer length expected in command response 411038c8a9a5SSteve French * @rsp: query info response buffer contains output buffer length 411138c8a9a5SSteve French * @rsp_org: base response buffer pointer in case of chained response 411238c8a9a5SSteve French * @infoclass_size: query info class response buffer size 411338c8a9a5SSteve French * 411438c8a9a5SSteve French * Return: 0 on success, otherwise error 411538c8a9a5SSteve French */ 411638c8a9a5SSteve French static int buffer_check_err(int reqOutputBufferLength, 411738c8a9a5SSteve French struct smb2_query_info_rsp *rsp, 411838c8a9a5SSteve French void *rsp_org, int infoclass_size) 411938c8a9a5SSteve French { 412038c8a9a5SSteve French if (reqOutputBufferLength < le32_to_cpu(rsp->OutputBufferLength)) { 412138c8a9a5SSteve French if (reqOutputBufferLength < infoclass_size) { 412238c8a9a5SSteve French pr_err("Invalid Buffer Size Requested\n"); 412338c8a9a5SSteve French rsp->hdr.Status = STATUS_INFO_LENGTH_MISMATCH; 412438c8a9a5SSteve French *(__be32 *)rsp_org = cpu_to_be32(sizeof(struct smb2_hdr)); 412538c8a9a5SSteve French return -EINVAL; 412638c8a9a5SSteve French } 412738c8a9a5SSteve French 412838c8a9a5SSteve French ksmbd_debug(SMB, "Buffer Overflow\n"); 412938c8a9a5SSteve French rsp->hdr.Status = STATUS_BUFFER_OVERFLOW; 413038c8a9a5SSteve French *(__be32 *)rsp_org = cpu_to_be32(sizeof(struct smb2_hdr) + 413138c8a9a5SSteve French reqOutputBufferLength); 413238c8a9a5SSteve French rsp->OutputBufferLength = cpu_to_le32(reqOutputBufferLength); 413338c8a9a5SSteve French } 413438c8a9a5SSteve French return 0; 413538c8a9a5SSteve French } 413638c8a9a5SSteve French 413738c8a9a5SSteve French static void get_standard_info_pipe(struct smb2_query_info_rsp *rsp, 413838c8a9a5SSteve French void *rsp_org) 413938c8a9a5SSteve French { 414038c8a9a5SSteve French struct smb2_file_standard_info *sinfo; 414138c8a9a5SSteve French 414238c8a9a5SSteve French sinfo = (struct smb2_file_standard_info *)rsp->Buffer; 414338c8a9a5SSteve French 414438c8a9a5SSteve French sinfo->AllocationSize = cpu_to_le64(4096); 414538c8a9a5SSteve French sinfo->EndOfFile = cpu_to_le64(0); 414638c8a9a5SSteve French sinfo->NumberOfLinks = cpu_to_le32(1); 414738c8a9a5SSteve French sinfo->DeletePending = 1; 414838c8a9a5SSteve French sinfo->Directory = 0; 414938c8a9a5SSteve French rsp->OutputBufferLength = 415038c8a9a5SSteve French cpu_to_le32(sizeof(struct smb2_file_standard_info)); 415138c8a9a5SSteve French inc_rfc1001_len(rsp_org, sizeof(struct smb2_file_standard_info)); 415238c8a9a5SSteve French } 415338c8a9a5SSteve French 415438c8a9a5SSteve French static void get_internal_info_pipe(struct smb2_query_info_rsp *rsp, u64 num, 415538c8a9a5SSteve French void *rsp_org) 415638c8a9a5SSteve French { 415738c8a9a5SSteve French struct smb2_file_internal_info *file_info; 415838c8a9a5SSteve French 415938c8a9a5SSteve French file_info = (struct smb2_file_internal_info *)rsp->Buffer; 416038c8a9a5SSteve French 416138c8a9a5SSteve French /* any unique number */ 416238c8a9a5SSteve French file_info->IndexNumber = cpu_to_le64(num | (1ULL << 63)); 416338c8a9a5SSteve French rsp->OutputBufferLength = 416438c8a9a5SSteve French cpu_to_le32(sizeof(struct smb2_file_internal_info)); 416538c8a9a5SSteve French inc_rfc1001_len(rsp_org, sizeof(struct smb2_file_internal_info)); 416638c8a9a5SSteve French } 416738c8a9a5SSteve French 416838c8a9a5SSteve French static int smb2_get_info_file_pipe(struct ksmbd_session *sess, 416938c8a9a5SSteve French struct smb2_query_info_req *req, 417038c8a9a5SSteve French struct smb2_query_info_rsp *rsp, 417138c8a9a5SSteve French void *rsp_org) 417238c8a9a5SSteve French { 417338c8a9a5SSteve French u64 id; 417438c8a9a5SSteve French int rc; 417538c8a9a5SSteve French 417638c8a9a5SSteve French /* 417738c8a9a5SSteve French * Windows can sometime send query file info request on 417838c8a9a5SSteve French * pipe without opening it, checking error condition here 417938c8a9a5SSteve French */ 418038c8a9a5SSteve French id = req->VolatileFileId; 418138c8a9a5SSteve French if (!ksmbd_session_rpc_method(sess, id)) 418238c8a9a5SSteve French return -ENOENT; 418338c8a9a5SSteve French 418438c8a9a5SSteve French ksmbd_debug(SMB, "FileInfoClass %u, FileId 0x%llx\n", 418538c8a9a5SSteve French req->FileInfoClass, req->VolatileFileId); 418638c8a9a5SSteve French 418738c8a9a5SSteve French switch (req->FileInfoClass) { 418838c8a9a5SSteve French case FILE_STANDARD_INFORMATION: 418938c8a9a5SSteve French get_standard_info_pipe(rsp, rsp_org); 419038c8a9a5SSteve French rc = buffer_check_err(le32_to_cpu(req->OutputBufferLength), 419138c8a9a5SSteve French rsp, rsp_org, 419238c8a9a5SSteve French FILE_STANDARD_INFORMATION_SIZE); 419338c8a9a5SSteve French break; 419438c8a9a5SSteve French case FILE_INTERNAL_INFORMATION: 419538c8a9a5SSteve French get_internal_info_pipe(rsp, id, rsp_org); 419638c8a9a5SSteve French rc = buffer_check_err(le32_to_cpu(req->OutputBufferLength), 419738c8a9a5SSteve French rsp, rsp_org, 419838c8a9a5SSteve French FILE_INTERNAL_INFORMATION_SIZE); 419938c8a9a5SSteve French break; 420038c8a9a5SSteve French default: 420138c8a9a5SSteve French ksmbd_debug(SMB, "smb2_info_file_pipe for %u not supported\n", 420238c8a9a5SSteve French req->FileInfoClass); 420338c8a9a5SSteve French rc = -EOPNOTSUPP; 420438c8a9a5SSteve French } 420538c8a9a5SSteve French return rc; 420638c8a9a5SSteve French } 420738c8a9a5SSteve French 420838c8a9a5SSteve French /** 420938c8a9a5SSteve French * smb2_get_ea() - handler for smb2 get extended attribute command 421038c8a9a5SSteve French * @work: smb work containing query info command buffer 421138c8a9a5SSteve French * @fp: ksmbd_file pointer 421238c8a9a5SSteve French * @req: get extended attribute request 421338c8a9a5SSteve French * @rsp: response buffer pointer 421438c8a9a5SSteve French * @rsp_org: base response buffer pointer in case of chained response 421538c8a9a5SSteve French * 421638c8a9a5SSteve French * Return: 0 on success, otherwise error 421738c8a9a5SSteve French */ 421838c8a9a5SSteve French static int smb2_get_ea(struct ksmbd_work *work, struct ksmbd_file *fp, 421938c8a9a5SSteve French struct smb2_query_info_req *req, 422038c8a9a5SSteve French struct smb2_query_info_rsp *rsp, void *rsp_org) 422138c8a9a5SSteve French { 422238c8a9a5SSteve French struct smb2_ea_info *eainfo, *prev_eainfo; 422338c8a9a5SSteve French char *name, *ptr, *xattr_list = NULL, *buf; 422438c8a9a5SSteve French int rc, name_len, value_len, xattr_list_len, idx; 422538c8a9a5SSteve French ssize_t buf_free_len, alignment_bytes, next_offset, rsp_data_cnt = 0; 422638c8a9a5SSteve French struct smb2_ea_info_req *ea_req = NULL; 422738c8a9a5SSteve French const struct path *path; 422838c8a9a5SSteve French struct mnt_idmap *idmap = file_mnt_idmap(fp->filp); 422938c8a9a5SSteve French 423038c8a9a5SSteve French if (!(fp->daccess & FILE_READ_EA_LE)) { 423138c8a9a5SSteve French pr_err("Not permitted to read ext attr : 0x%x\n", 423238c8a9a5SSteve French fp->daccess); 423338c8a9a5SSteve French return -EACCES; 423438c8a9a5SSteve French } 423538c8a9a5SSteve French 423638c8a9a5SSteve French path = &fp->filp->f_path; 423738c8a9a5SSteve French /* single EA entry is requested with given user.* name */ 423838c8a9a5SSteve French if (req->InputBufferLength) { 423938c8a9a5SSteve French if (le32_to_cpu(req->InputBufferLength) < 424038c8a9a5SSteve French sizeof(struct smb2_ea_info_req)) 424138c8a9a5SSteve French return -EINVAL; 424238c8a9a5SSteve French 424338c8a9a5SSteve French ea_req = (struct smb2_ea_info_req *)req->Buffer; 424438c8a9a5SSteve French } else { 424538c8a9a5SSteve French /* need to send all EAs, if no specific EA is requested*/ 424638c8a9a5SSteve French if (le32_to_cpu(req->Flags) & SL_RETURN_SINGLE_ENTRY) 424738c8a9a5SSteve French ksmbd_debug(SMB, 424838c8a9a5SSteve French "All EAs are requested but need to send single EA entry in rsp flags 0x%x\n", 424938c8a9a5SSteve French le32_to_cpu(req->Flags)); 425038c8a9a5SSteve French } 425138c8a9a5SSteve French 425238c8a9a5SSteve French buf_free_len = 425338c8a9a5SSteve French smb2_calc_max_out_buf_len(work, 8, 425438c8a9a5SSteve French le32_to_cpu(req->OutputBufferLength)); 425538c8a9a5SSteve French if (buf_free_len < 0) 425638c8a9a5SSteve French return -EINVAL; 425738c8a9a5SSteve French 425838c8a9a5SSteve French rc = ksmbd_vfs_listxattr(path->dentry, &xattr_list); 425938c8a9a5SSteve French if (rc < 0) { 426038c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_HANDLE; 426138c8a9a5SSteve French goto out; 426238c8a9a5SSteve French } else if (!rc) { /* there is no EA in the file */ 426338c8a9a5SSteve French ksmbd_debug(SMB, "no ea data in the file\n"); 426438c8a9a5SSteve French goto done; 426538c8a9a5SSteve French } 426638c8a9a5SSteve French xattr_list_len = rc; 426738c8a9a5SSteve French 426838c8a9a5SSteve French ptr = (char *)rsp->Buffer; 426938c8a9a5SSteve French eainfo = (struct smb2_ea_info *)ptr; 427038c8a9a5SSteve French prev_eainfo = eainfo; 427138c8a9a5SSteve French idx = 0; 427238c8a9a5SSteve French 427338c8a9a5SSteve French while (idx < xattr_list_len) { 427438c8a9a5SSteve French name = xattr_list + idx; 427538c8a9a5SSteve French name_len = strlen(name); 427638c8a9a5SSteve French 427738c8a9a5SSteve French ksmbd_debug(SMB, "%s, len %d\n", name, name_len); 427838c8a9a5SSteve French idx += name_len + 1; 427938c8a9a5SSteve French 428038c8a9a5SSteve French /* 428138c8a9a5SSteve French * CIFS does not support EA other than user.* namespace, 428238c8a9a5SSteve French * still keep the framework generic, to list other attrs 428338c8a9a5SSteve French * in future. 428438c8a9a5SSteve French */ 428538c8a9a5SSteve French if (strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)) 428638c8a9a5SSteve French continue; 428738c8a9a5SSteve French 428838c8a9a5SSteve French if (!strncmp(&name[XATTR_USER_PREFIX_LEN], STREAM_PREFIX, 428938c8a9a5SSteve French STREAM_PREFIX_LEN)) 429038c8a9a5SSteve French continue; 429138c8a9a5SSteve French 429238c8a9a5SSteve French if (req->InputBufferLength && 429338c8a9a5SSteve French strncmp(&name[XATTR_USER_PREFIX_LEN], ea_req->name, 429438c8a9a5SSteve French ea_req->EaNameLength)) 429538c8a9a5SSteve French continue; 429638c8a9a5SSteve French 429738c8a9a5SSteve French if (!strncmp(&name[XATTR_USER_PREFIX_LEN], 429838c8a9a5SSteve French DOS_ATTRIBUTE_PREFIX, DOS_ATTRIBUTE_PREFIX_LEN)) 429938c8a9a5SSteve French continue; 430038c8a9a5SSteve French 430138c8a9a5SSteve French if (!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)) 430238c8a9a5SSteve French name_len -= XATTR_USER_PREFIX_LEN; 430338c8a9a5SSteve French 430438c8a9a5SSteve French ptr = (char *)(&eainfo->name + name_len + 1); 430538c8a9a5SSteve French buf_free_len -= (offsetof(struct smb2_ea_info, name) + 430638c8a9a5SSteve French name_len + 1); 430738c8a9a5SSteve French /* bailout if xattr can't fit in buf_free_len */ 430838c8a9a5SSteve French value_len = ksmbd_vfs_getxattr(idmap, path->dentry, 430938c8a9a5SSteve French name, &buf); 431038c8a9a5SSteve French if (value_len <= 0) { 431138c8a9a5SSteve French rc = -ENOENT; 431238c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_HANDLE; 431338c8a9a5SSteve French goto out; 431438c8a9a5SSteve French } 431538c8a9a5SSteve French 431638c8a9a5SSteve French buf_free_len -= value_len; 431738c8a9a5SSteve French if (buf_free_len < 0) { 431838c8a9a5SSteve French kfree(buf); 431938c8a9a5SSteve French break; 432038c8a9a5SSteve French } 432138c8a9a5SSteve French 432238c8a9a5SSteve French memcpy(ptr, buf, value_len); 432338c8a9a5SSteve French kfree(buf); 432438c8a9a5SSteve French 432538c8a9a5SSteve French ptr += value_len; 432638c8a9a5SSteve French eainfo->Flags = 0; 432738c8a9a5SSteve French eainfo->EaNameLength = name_len; 432838c8a9a5SSteve French 432938c8a9a5SSteve French if (!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)) 433038c8a9a5SSteve French memcpy(eainfo->name, &name[XATTR_USER_PREFIX_LEN], 433138c8a9a5SSteve French name_len); 433238c8a9a5SSteve French else 433338c8a9a5SSteve French memcpy(eainfo->name, name, name_len); 433438c8a9a5SSteve French 433538c8a9a5SSteve French eainfo->name[name_len] = '\0'; 433638c8a9a5SSteve French eainfo->EaValueLength = cpu_to_le16(value_len); 433738c8a9a5SSteve French next_offset = offsetof(struct smb2_ea_info, name) + 433838c8a9a5SSteve French name_len + 1 + value_len; 433938c8a9a5SSteve French 434038c8a9a5SSteve French /* align next xattr entry at 4 byte bundary */ 434138c8a9a5SSteve French alignment_bytes = ((next_offset + 3) & ~3) - next_offset; 434238c8a9a5SSteve French if (alignment_bytes) { 434338c8a9a5SSteve French memset(ptr, '\0', alignment_bytes); 434438c8a9a5SSteve French ptr += alignment_bytes; 434538c8a9a5SSteve French next_offset += alignment_bytes; 434638c8a9a5SSteve French buf_free_len -= alignment_bytes; 434738c8a9a5SSteve French } 434838c8a9a5SSteve French eainfo->NextEntryOffset = cpu_to_le32(next_offset); 434938c8a9a5SSteve French prev_eainfo = eainfo; 435038c8a9a5SSteve French eainfo = (struct smb2_ea_info *)ptr; 435138c8a9a5SSteve French rsp_data_cnt += next_offset; 435238c8a9a5SSteve French 435338c8a9a5SSteve French if (req->InputBufferLength) { 435438c8a9a5SSteve French ksmbd_debug(SMB, "single entry requested\n"); 435538c8a9a5SSteve French break; 435638c8a9a5SSteve French } 435738c8a9a5SSteve French } 435838c8a9a5SSteve French 435938c8a9a5SSteve French /* no more ea entries */ 436038c8a9a5SSteve French prev_eainfo->NextEntryOffset = 0; 436138c8a9a5SSteve French done: 436238c8a9a5SSteve French rc = 0; 436338c8a9a5SSteve French if (rsp_data_cnt == 0) 436438c8a9a5SSteve French rsp->hdr.Status = STATUS_NO_EAS_ON_FILE; 436538c8a9a5SSteve French rsp->OutputBufferLength = cpu_to_le32(rsp_data_cnt); 436638c8a9a5SSteve French inc_rfc1001_len(rsp_org, rsp_data_cnt); 436738c8a9a5SSteve French out: 436838c8a9a5SSteve French kvfree(xattr_list); 436938c8a9a5SSteve French return rc; 437038c8a9a5SSteve French } 437138c8a9a5SSteve French 437238c8a9a5SSteve French static void get_file_access_info(struct smb2_query_info_rsp *rsp, 437338c8a9a5SSteve French struct ksmbd_file *fp, void *rsp_org) 437438c8a9a5SSteve French { 437538c8a9a5SSteve French struct smb2_file_access_info *file_info; 437638c8a9a5SSteve French 437738c8a9a5SSteve French file_info = (struct smb2_file_access_info *)rsp->Buffer; 437838c8a9a5SSteve French file_info->AccessFlags = fp->daccess; 437938c8a9a5SSteve French rsp->OutputBufferLength = 438038c8a9a5SSteve French cpu_to_le32(sizeof(struct smb2_file_access_info)); 438138c8a9a5SSteve French inc_rfc1001_len(rsp_org, sizeof(struct smb2_file_access_info)); 438238c8a9a5SSteve French } 438338c8a9a5SSteve French 438438c8a9a5SSteve French static int get_file_basic_info(struct smb2_query_info_rsp *rsp, 438538c8a9a5SSteve French struct ksmbd_file *fp, void *rsp_org) 438638c8a9a5SSteve French { 438738c8a9a5SSteve French struct smb2_file_basic_info *basic_info; 438838c8a9a5SSteve French struct kstat stat; 438938c8a9a5SSteve French u64 time; 439038c8a9a5SSteve French 439138c8a9a5SSteve French if (!(fp->daccess & FILE_READ_ATTRIBUTES_LE)) { 439238c8a9a5SSteve French pr_err("no right to read the attributes : 0x%x\n", 439338c8a9a5SSteve French fp->daccess); 439438c8a9a5SSteve French return -EACCES; 439538c8a9a5SSteve French } 439638c8a9a5SSteve French 439738c8a9a5SSteve French basic_info = (struct smb2_file_basic_info *)rsp->Buffer; 439838c8a9a5SSteve French generic_fillattr(file_mnt_idmap(fp->filp), file_inode(fp->filp), 439938c8a9a5SSteve French &stat); 440038c8a9a5SSteve French basic_info->CreationTime = cpu_to_le64(fp->create_time); 440138c8a9a5SSteve French time = ksmbd_UnixTimeToNT(stat.atime); 440238c8a9a5SSteve French basic_info->LastAccessTime = cpu_to_le64(time); 440338c8a9a5SSteve French time = ksmbd_UnixTimeToNT(stat.mtime); 440438c8a9a5SSteve French basic_info->LastWriteTime = cpu_to_le64(time); 440538c8a9a5SSteve French time = ksmbd_UnixTimeToNT(stat.ctime); 440638c8a9a5SSteve French basic_info->ChangeTime = cpu_to_le64(time); 440738c8a9a5SSteve French basic_info->Attributes = fp->f_ci->m_fattr; 440838c8a9a5SSteve French basic_info->Pad1 = 0; 440938c8a9a5SSteve French rsp->OutputBufferLength = 441038c8a9a5SSteve French cpu_to_le32(sizeof(struct smb2_file_basic_info)); 441138c8a9a5SSteve French inc_rfc1001_len(rsp_org, sizeof(struct smb2_file_basic_info)); 441238c8a9a5SSteve French return 0; 441338c8a9a5SSteve French } 441438c8a9a5SSteve French 441538c8a9a5SSteve French static void get_file_standard_info(struct smb2_query_info_rsp *rsp, 441638c8a9a5SSteve French struct ksmbd_file *fp, void *rsp_org) 441738c8a9a5SSteve French { 441838c8a9a5SSteve French struct smb2_file_standard_info *sinfo; 441938c8a9a5SSteve French unsigned int delete_pending; 442038c8a9a5SSteve French struct inode *inode; 442138c8a9a5SSteve French struct kstat stat; 442238c8a9a5SSteve French 442338c8a9a5SSteve French inode = file_inode(fp->filp); 442438c8a9a5SSteve French generic_fillattr(file_mnt_idmap(fp->filp), inode, &stat); 442538c8a9a5SSteve French 442638c8a9a5SSteve French sinfo = (struct smb2_file_standard_info *)rsp->Buffer; 442738c8a9a5SSteve French delete_pending = ksmbd_inode_pending_delete(fp); 442838c8a9a5SSteve French 44296cc2268fSNamjae Jeon sinfo->AllocationSize = cpu_to_le64(inode->i_blocks << 9); 443038c8a9a5SSteve French sinfo->EndOfFile = S_ISDIR(stat.mode) ? 0 : cpu_to_le64(stat.size); 443138c8a9a5SSteve French sinfo->NumberOfLinks = cpu_to_le32(get_nlink(&stat) - delete_pending); 443238c8a9a5SSteve French sinfo->DeletePending = delete_pending; 443338c8a9a5SSteve French sinfo->Directory = S_ISDIR(stat.mode) ? 1 : 0; 443438c8a9a5SSteve French rsp->OutputBufferLength = 443538c8a9a5SSteve French cpu_to_le32(sizeof(struct smb2_file_standard_info)); 443638c8a9a5SSteve French inc_rfc1001_len(rsp_org, 443738c8a9a5SSteve French sizeof(struct smb2_file_standard_info)); 443838c8a9a5SSteve French } 443938c8a9a5SSteve French 444038c8a9a5SSteve French static void get_file_alignment_info(struct smb2_query_info_rsp *rsp, 444138c8a9a5SSteve French void *rsp_org) 444238c8a9a5SSteve French { 444338c8a9a5SSteve French struct smb2_file_alignment_info *file_info; 444438c8a9a5SSteve French 444538c8a9a5SSteve French file_info = (struct smb2_file_alignment_info *)rsp->Buffer; 444638c8a9a5SSteve French file_info->AlignmentRequirement = 0; 444738c8a9a5SSteve French rsp->OutputBufferLength = 444838c8a9a5SSteve French cpu_to_le32(sizeof(struct smb2_file_alignment_info)); 444938c8a9a5SSteve French inc_rfc1001_len(rsp_org, 445038c8a9a5SSteve French sizeof(struct smb2_file_alignment_info)); 445138c8a9a5SSteve French } 445238c8a9a5SSteve French 445338c8a9a5SSteve French static int get_file_all_info(struct ksmbd_work *work, 445438c8a9a5SSteve French struct smb2_query_info_rsp *rsp, 445538c8a9a5SSteve French struct ksmbd_file *fp, 445638c8a9a5SSteve French void *rsp_org) 445738c8a9a5SSteve French { 445838c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 445938c8a9a5SSteve French struct smb2_file_all_info *file_info; 446038c8a9a5SSteve French unsigned int delete_pending; 446138c8a9a5SSteve French struct inode *inode; 446238c8a9a5SSteve French struct kstat stat; 446338c8a9a5SSteve French int conv_len; 446438c8a9a5SSteve French char *filename; 446538c8a9a5SSteve French u64 time; 446638c8a9a5SSteve French 446738c8a9a5SSteve French if (!(fp->daccess & FILE_READ_ATTRIBUTES_LE)) { 446838c8a9a5SSteve French ksmbd_debug(SMB, "no right to read the attributes : 0x%x\n", 446938c8a9a5SSteve French fp->daccess); 447038c8a9a5SSteve French return -EACCES; 447138c8a9a5SSteve French } 447238c8a9a5SSteve French 447338c8a9a5SSteve French filename = convert_to_nt_pathname(work->tcon->share_conf, &fp->filp->f_path); 447438c8a9a5SSteve French if (IS_ERR(filename)) 447538c8a9a5SSteve French return PTR_ERR(filename); 447638c8a9a5SSteve French 447738c8a9a5SSteve French inode = file_inode(fp->filp); 447838c8a9a5SSteve French generic_fillattr(file_mnt_idmap(fp->filp), inode, &stat); 447938c8a9a5SSteve French 448038c8a9a5SSteve French ksmbd_debug(SMB, "filename = %s\n", filename); 448138c8a9a5SSteve French delete_pending = ksmbd_inode_pending_delete(fp); 448238c8a9a5SSteve French file_info = (struct smb2_file_all_info *)rsp->Buffer; 448338c8a9a5SSteve French 448438c8a9a5SSteve French file_info->CreationTime = cpu_to_le64(fp->create_time); 448538c8a9a5SSteve French time = ksmbd_UnixTimeToNT(stat.atime); 448638c8a9a5SSteve French file_info->LastAccessTime = cpu_to_le64(time); 448738c8a9a5SSteve French time = ksmbd_UnixTimeToNT(stat.mtime); 448838c8a9a5SSteve French file_info->LastWriteTime = cpu_to_le64(time); 448938c8a9a5SSteve French time = ksmbd_UnixTimeToNT(stat.ctime); 449038c8a9a5SSteve French file_info->ChangeTime = cpu_to_le64(time); 449138c8a9a5SSteve French file_info->Attributes = fp->f_ci->m_fattr; 449238c8a9a5SSteve French file_info->Pad1 = 0; 449338c8a9a5SSteve French file_info->AllocationSize = 44946cc2268fSNamjae Jeon cpu_to_le64(inode->i_blocks << 9); 449538c8a9a5SSteve French file_info->EndOfFile = S_ISDIR(stat.mode) ? 0 : cpu_to_le64(stat.size); 449638c8a9a5SSteve French file_info->NumberOfLinks = 449738c8a9a5SSteve French cpu_to_le32(get_nlink(&stat) - delete_pending); 449838c8a9a5SSteve French file_info->DeletePending = delete_pending; 449938c8a9a5SSteve French file_info->Directory = S_ISDIR(stat.mode) ? 1 : 0; 450038c8a9a5SSteve French file_info->Pad2 = 0; 450138c8a9a5SSteve French file_info->IndexNumber = cpu_to_le64(stat.ino); 450238c8a9a5SSteve French file_info->EASize = 0; 450338c8a9a5SSteve French file_info->AccessFlags = fp->daccess; 450438c8a9a5SSteve French file_info->CurrentByteOffset = cpu_to_le64(fp->filp->f_pos); 450538c8a9a5SSteve French file_info->Mode = fp->coption; 450638c8a9a5SSteve French file_info->AlignmentRequirement = 0; 450738c8a9a5SSteve French conv_len = smbConvertToUTF16((__le16 *)file_info->FileName, filename, 450838c8a9a5SSteve French PATH_MAX, conn->local_nls, 0); 450938c8a9a5SSteve French conv_len *= 2; 451038c8a9a5SSteve French file_info->FileNameLength = cpu_to_le32(conv_len); 451138c8a9a5SSteve French rsp->OutputBufferLength = 451238c8a9a5SSteve French cpu_to_le32(sizeof(struct smb2_file_all_info) + conv_len - 1); 451338c8a9a5SSteve French kfree(filename); 451438c8a9a5SSteve French inc_rfc1001_len(rsp_org, le32_to_cpu(rsp->OutputBufferLength)); 451538c8a9a5SSteve French return 0; 451638c8a9a5SSteve French } 451738c8a9a5SSteve French 451838c8a9a5SSteve French static void get_file_alternate_info(struct ksmbd_work *work, 451938c8a9a5SSteve French struct smb2_query_info_rsp *rsp, 452038c8a9a5SSteve French struct ksmbd_file *fp, 452138c8a9a5SSteve French void *rsp_org) 452238c8a9a5SSteve French { 452338c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 452438c8a9a5SSteve French struct smb2_file_alt_name_info *file_info; 452538c8a9a5SSteve French struct dentry *dentry = fp->filp->f_path.dentry; 452638c8a9a5SSteve French int conv_len; 452738c8a9a5SSteve French 452838c8a9a5SSteve French spin_lock(&dentry->d_lock); 452938c8a9a5SSteve French file_info = (struct smb2_file_alt_name_info *)rsp->Buffer; 453038c8a9a5SSteve French conv_len = ksmbd_extract_shortname(conn, 453138c8a9a5SSteve French dentry->d_name.name, 453238c8a9a5SSteve French file_info->FileName); 453338c8a9a5SSteve French spin_unlock(&dentry->d_lock); 453438c8a9a5SSteve French file_info->FileNameLength = cpu_to_le32(conv_len); 453538c8a9a5SSteve French rsp->OutputBufferLength = 453638c8a9a5SSteve French cpu_to_le32(sizeof(struct smb2_file_alt_name_info) + conv_len); 453738c8a9a5SSteve French inc_rfc1001_len(rsp_org, le32_to_cpu(rsp->OutputBufferLength)); 453838c8a9a5SSteve French } 453938c8a9a5SSteve French 454038c8a9a5SSteve French static void get_file_stream_info(struct ksmbd_work *work, 454138c8a9a5SSteve French struct smb2_query_info_rsp *rsp, 454238c8a9a5SSteve French struct ksmbd_file *fp, 454338c8a9a5SSteve French void *rsp_org) 454438c8a9a5SSteve French { 454538c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 454638c8a9a5SSteve French struct smb2_file_stream_info *file_info; 454738c8a9a5SSteve French char *stream_name, *xattr_list = NULL, *stream_buf; 454838c8a9a5SSteve French struct kstat stat; 454938c8a9a5SSteve French const struct path *path = &fp->filp->f_path; 455038c8a9a5SSteve French ssize_t xattr_list_len; 455138c8a9a5SSteve French int nbytes = 0, streamlen, stream_name_len, next, idx = 0; 455238c8a9a5SSteve French int buf_free_len; 455338c8a9a5SSteve French struct smb2_query_info_req *req = ksmbd_req_buf_next(work); 455438c8a9a5SSteve French 455538c8a9a5SSteve French generic_fillattr(file_mnt_idmap(fp->filp), file_inode(fp->filp), 455638c8a9a5SSteve French &stat); 455738c8a9a5SSteve French file_info = (struct smb2_file_stream_info *)rsp->Buffer; 455838c8a9a5SSteve French 455938c8a9a5SSteve French buf_free_len = 456038c8a9a5SSteve French smb2_calc_max_out_buf_len(work, 8, 456138c8a9a5SSteve French le32_to_cpu(req->OutputBufferLength)); 456238c8a9a5SSteve French if (buf_free_len < 0) 456338c8a9a5SSteve French goto out; 456438c8a9a5SSteve French 456538c8a9a5SSteve French xattr_list_len = ksmbd_vfs_listxattr(path->dentry, &xattr_list); 456638c8a9a5SSteve French if (xattr_list_len < 0) { 456738c8a9a5SSteve French goto out; 456838c8a9a5SSteve French } else if (!xattr_list_len) { 456938c8a9a5SSteve French ksmbd_debug(SMB, "empty xattr in the file\n"); 457038c8a9a5SSteve French goto out; 457138c8a9a5SSteve French } 457238c8a9a5SSteve French 457338c8a9a5SSteve French while (idx < xattr_list_len) { 457438c8a9a5SSteve French stream_name = xattr_list + idx; 457538c8a9a5SSteve French streamlen = strlen(stream_name); 457638c8a9a5SSteve French idx += streamlen + 1; 457738c8a9a5SSteve French 457838c8a9a5SSteve French ksmbd_debug(SMB, "%s, len %d\n", stream_name, streamlen); 457938c8a9a5SSteve French 458038c8a9a5SSteve French if (strncmp(&stream_name[XATTR_USER_PREFIX_LEN], 458138c8a9a5SSteve French STREAM_PREFIX, STREAM_PREFIX_LEN)) 458238c8a9a5SSteve French continue; 458338c8a9a5SSteve French 458438c8a9a5SSteve French stream_name_len = streamlen - (XATTR_USER_PREFIX_LEN + 458538c8a9a5SSteve French STREAM_PREFIX_LEN); 458638c8a9a5SSteve French streamlen = stream_name_len; 458738c8a9a5SSteve French 458838c8a9a5SSteve French /* plus : size */ 458938c8a9a5SSteve French streamlen += 1; 459038c8a9a5SSteve French stream_buf = kmalloc(streamlen + 1, GFP_KERNEL); 459138c8a9a5SSteve French if (!stream_buf) 459238c8a9a5SSteve French break; 459338c8a9a5SSteve French 459438c8a9a5SSteve French streamlen = snprintf(stream_buf, streamlen + 1, 459538c8a9a5SSteve French ":%s", &stream_name[XATTR_NAME_STREAM_LEN]); 459638c8a9a5SSteve French 459738c8a9a5SSteve French next = sizeof(struct smb2_file_stream_info) + streamlen * 2; 459838c8a9a5SSteve French if (next > buf_free_len) { 459938c8a9a5SSteve French kfree(stream_buf); 460038c8a9a5SSteve French break; 460138c8a9a5SSteve French } 460238c8a9a5SSteve French 460338c8a9a5SSteve French file_info = (struct smb2_file_stream_info *)&rsp->Buffer[nbytes]; 460438c8a9a5SSteve French streamlen = smbConvertToUTF16((__le16 *)file_info->StreamName, 460538c8a9a5SSteve French stream_buf, streamlen, 460638c8a9a5SSteve French conn->local_nls, 0); 460738c8a9a5SSteve French streamlen *= 2; 460838c8a9a5SSteve French kfree(stream_buf); 460938c8a9a5SSteve French file_info->StreamNameLength = cpu_to_le32(streamlen); 461038c8a9a5SSteve French file_info->StreamSize = cpu_to_le64(stream_name_len); 461138c8a9a5SSteve French file_info->StreamAllocationSize = cpu_to_le64(stream_name_len); 461238c8a9a5SSteve French 461338c8a9a5SSteve French nbytes += next; 461438c8a9a5SSteve French buf_free_len -= next; 461538c8a9a5SSteve French file_info->NextEntryOffset = cpu_to_le32(next); 461638c8a9a5SSteve French } 461738c8a9a5SSteve French 461838c8a9a5SSteve French out: 461938c8a9a5SSteve French if (!S_ISDIR(stat.mode) && 462038c8a9a5SSteve French buf_free_len >= sizeof(struct smb2_file_stream_info) + 7 * 2) { 462138c8a9a5SSteve French file_info = (struct smb2_file_stream_info *) 462238c8a9a5SSteve French &rsp->Buffer[nbytes]; 462338c8a9a5SSteve French streamlen = smbConvertToUTF16((__le16 *)file_info->StreamName, 462438c8a9a5SSteve French "::$DATA", 7, conn->local_nls, 0); 462538c8a9a5SSteve French streamlen *= 2; 462638c8a9a5SSteve French file_info->StreamNameLength = cpu_to_le32(streamlen); 462738c8a9a5SSteve French file_info->StreamSize = cpu_to_le64(stat.size); 462838c8a9a5SSteve French file_info->StreamAllocationSize = cpu_to_le64(stat.blocks << 9); 462938c8a9a5SSteve French nbytes += sizeof(struct smb2_file_stream_info) + streamlen; 463038c8a9a5SSteve French } 463138c8a9a5SSteve French 463238c8a9a5SSteve French /* last entry offset should be 0 */ 463338c8a9a5SSteve French file_info->NextEntryOffset = 0; 463438c8a9a5SSteve French kvfree(xattr_list); 463538c8a9a5SSteve French 463638c8a9a5SSteve French rsp->OutputBufferLength = cpu_to_le32(nbytes); 463738c8a9a5SSteve French inc_rfc1001_len(rsp_org, nbytes); 463838c8a9a5SSteve French } 463938c8a9a5SSteve French 464038c8a9a5SSteve French static void get_file_internal_info(struct smb2_query_info_rsp *rsp, 464138c8a9a5SSteve French struct ksmbd_file *fp, void *rsp_org) 464238c8a9a5SSteve French { 464338c8a9a5SSteve French struct smb2_file_internal_info *file_info; 464438c8a9a5SSteve French struct kstat stat; 464538c8a9a5SSteve French 464638c8a9a5SSteve French generic_fillattr(file_mnt_idmap(fp->filp), file_inode(fp->filp), 464738c8a9a5SSteve French &stat); 464838c8a9a5SSteve French file_info = (struct smb2_file_internal_info *)rsp->Buffer; 464938c8a9a5SSteve French file_info->IndexNumber = cpu_to_le64(stat.ino); 465038c8a9a5SSteve French rsp->OutputBufferLength = 465138c8a9a5SSteve French cpu_to_le32(sizeof(struct smb2_file_internal_info)); 465238c8a9a5SSteve French inc_rfc1001_len(rsp_org, sizeof(struct smb2_file_internal_info)); 465338c8a9a5SSteve French } 465438c8a9a5SSteve French 465538c8a9a5SSteve French static int get_file_network_open_info(struct smb2_query_info_rsp *rsp, 465638c8a9a5SSteve French struct ksmbd_file *fp, void *rsp_org) 465738c8a9a5SSteve French { 465838c8a9a5SSteve French struct smb2_file_ntwrk_info *file_info; 465938c8a9a5SSteve French struct inode *inode; 466038c8a9a5SSteve French struct kstat stat; 466138c8a9a5SSteve French u64 time; 466238c8a9a5SSteve French 466338c8a9a5SSteve French if (!(fp->daccess & FILE_READ_ATTRIBUTES_LE)) { 466438c8a9a5SSteve French pr_err("no right to read the attributes : 0x%x\n", 466538c8a9a5SSteve French fp->daccess); 466638c8a9a5SSteve French return -EACCES; 466738c8a9a5SSteve French } 466838c8a9a5SSteve French 466938c8a9a5SSteve French file_info = (struct smb2_file_ntwrk_info *)rsp->Buffer; 467038c8a9a5SSteve French 467138c8a9a5SSteve French inode = file_inode(fp->filp); 467238c8a9a5SSteve French generic_fillattr(file_mnt_idmap(fp->filp), inode, &stat); 467338c8a9a5SSteve French 467438c8a9a5SSteve French file_info->CreationTime = cpu_to_le64(fp->create_time); 467538c8a9a5SSteve French time = ksmbd_UnixTimeToNT(stat.atime); 467638c8a9a5SSteve French file_info->LastAccessTime = cpu_to_le64(time); 467738c8a9a5SSteve French time = ksmbd_UnixTimeToNT(stat.mtime); 467838c8a9a5SSteve French file_info->LastWriteTime = cpu_to_le64(time); 467938c8a9a5SSteve French time = ksmbd_UnixTimeToNT(stat.ctime); 468038c8a9a5SSteve French file_info->ChangeTime = cpu_to_le64(time); 468138c8a9a5SSteve French file_info->Attributes = fp->f_ci->m_fattr; 468238c8a9a5SSteve French file_info->AllocationSize = 46836cc2268fSNamjae Jeon cpu_to_le64(inode->i_blocks << 9); 468438c8a9a5SSteve French file_info->EndOfFile = S_ISDIR(stat.mode) ? 0 : cpu_to_le64(stat.size); 468538c8a9a5SSteve French file_info->Reserved = cpu_to_le32(0); 468638c8a9a5SSteve French rsp->OutputBufferLength = 468738c8a9a5SSteve French cpu_to_le32(sizeof(struct smb2_file_ntwrk_info)); 468838c8a9a5SSteve French inc_rfc1001_len(rsp_org, sizeof(struct smb2_file_ntwrk_info)); 468938c8a9a5SSteve French return 0; 469038c8a9a5SSteve French } 469138c8a9a5SSteve French 469238c8a9a5SSteve French static void get_file_ea_info(struct smb2_query_info_rsp *rsp, void *rsp_org) 469338c8a9a5SSteve French { 469438c8a9a5SSteve French struct smb2_file_ea_info *file_info; 469538c8a9a5SSteve French 469638c8a9a5SSteve French file_info = (struct smb2_file_ea_info *)rsp->Buffer; 469738c8a9a5SSteve French file_info->EASize = 0; 469838c8a9a5SSteve French rsp->OutputBufferLength = 469938c8a9a5SSteve French cpu_to_le32(sizeof(struct smb2_file_ea_info)); 470038c8a9a5SSteve French inc_rfc1001_len(rsp_org, sizeof(struct smb2_file_ea_info)); 470138c8a9a5SSteve French } 470238c8a9a5SSteve French 470338c8a9a5SSteve French static void get_file_position_info(struct smb2_query_info_rsp *rsp, 470438c8a9a5SSteve French struct ksmbd_file *fp, void *rsp_org) 470538c8a9a5SSteve French { 470638c8a9a5SSteve French struct smb2_file_pos_info *file_info; 470738c8a9a5SSteve French 470838c8a9a5SSteve French file_info = (struct smb2_file_pos_info *)rsp->Buffer; 470938c8a9a5SSteve French file_info->CurrentByteOffset = cpu_to_le64(fp->filp->f_pos); 471038c8a9a5SSteve French rsp->OutputBufferLength = 471138c8a9a5SSteve French cpu_to_le32(sizeof(struct smb2_file_pos_info)); 471238c8a9a5SSteve French inc_rfc1001_len(rsp_org, sizeof(struct smb2_file_pos_info)); 471338c8a9a5SSteve French } 471438c8a9a5SSteve French 471538c8a9a5SSteve French static void get_file_mode_info(struct smb2_query_info_rsp *rsp, 471638c8a9a5SSteve French struct ksmbd_file *fp, void *rsp_org) 471738c8a9a5SSteve French { 471838c8a9a5SSteve French struct smb2_file_mode_info *file_info; 471938c8a9a5SSteve French 472038c8a9a5SSteve French file_info = (struct smb2_file_mode_info *)rsp->Buffer; 472138c8a9a5SSteve French file_info->Mode = fp->coption & FILE_MODE_INFO_MASK; 472238c8a9a5SSteve French rsp->OutputBufferLength = 472338c8a9a5SSteve French cpu_to_le32(sizeof(struct smb2_file_mode_info)); 472438c8a9a5SSteve French inc_rfc1001_len(rsp_org, sizeof(struct smb2_file_mode_info)); 472538c8a9a5SSteve French } 472638c8a9a5SSteve French 472738c8a9a5SSteve French static void get_file_compression_info(struct smb2_query_info_rsp *rsp, 472838c8a9a5SSteve French struct ksmbd_file *fp, void *rsp_org) 472938c8a9a5SSteve French { 473038c8a9a5SSteve French struct smb2_file_comp_info *file_info; 473138c8a9a5SSteve French struct kstat stat; 473238c8a9a5SSteve French 473338c8a9a5SSteve French generic_fillattr(file_mnt_idmap(fp->filp), file_inode(fp->filp), 473438c8a9a5SSteve French &stat); 473538c8a9a5SSteve French 473638c8a9a5SSteve French file_info = (struct smb2_file_comp_info *)rsp->Buffer; 473738c8a9a5SSteve French file_info->CompressedFileSize = cpu_to_le64(stat.blocks << 9); 473838c8a9a5SSteve French file_info->CompressionFormat = COMPRESSION_FORMAT_NONE; 473938c8a9a5SSteve French file_info->CompressionUnitShift = 0; 474038c8a9a5SSteve French file_info->ChunkShift = 0; 474138c8a9a5SSteve French file_info->ClusterShift = 0; 474238c8a9a5SSteve French memset(&file_info->Reserved[0], 0, 3); 474338c8a9a5SSteve French 474438c8a9a5SSteve French rsp->OutputBufferLength = 474538c8a9a5SSteve French cpu_to_le32(sizeof(struct smb2_file_comp_info)); 474638c8a9a5SSteve French inc_rfc1001_len(rsp_org, sizeof(struct smb2_file_comp_info)); 474738c8a9a5SSteve French } 474838c8a9a5SSteve French 474938c8a9a5SSteve French static int get_file_attribute_tag_info(struct smb2_query_info_rsp *rsp, 475038c8a9a5SSteve French struct ksmbd_file *fp, void *rsp_org) 475138c8a9a5SSteve French { 475238c8a9a5SSteve French struct smb2_file_attr_tag_info *file_info; 475338c8a9a5SSteve French 475438c8a9a5SSteve French if (!(fp->daccess & FILE_READ_ATTRIBUTES_LE)) { 475538c8a9a5SSteve French pr_err("no right to read the attributes : 0x%x\n", 475638c8a9a5SSteve French fp->daccess); 475738c8a9a5SSteve French return -EACCES; 475838c8a9a5SSteve French } 475938c8a9a5SSteve French 476038c8a9a5SSteve French file_info = (struct smb2_file_attr_tag_info *)rsp->Buffer; 476138c8a9a5SSteve French file_info->FileAttributes = fp->f_ci->m_fattr; 476238c8a9a5SSteve French file_info->ReparseTag = 0; 476338c8a9a5SSteve French rsp->OutputBufferLength = 476438c8a9a5SSteve French cpu_to_le32(sizeof(struct smb2_file_attr_tag_info)); 476538c8a9a5SSteve French inc_rfc1001_len(rsp_org, sizeof(struct smb2_file_attr_tag_info)); 476638c8a9a5SSteve French return 0; 476738c8a9a5SSteve French } 476838c8a9a5SSteve French 476938c8a9a5SSteve French static int find_file_posix_info(struct smb2_query_info_rsp *rsp, 477038c8a9a5SSteve French struct ksmbd_file *fp, void *rsp_org) 477138c8a9a5SSteve French { 477238c8a9a5SSteve French struct smb311_posix_qinfo *file_info; 477338c8a9a5SSteve French struct inode *inode = file_inode(fp->filp); 477438c8a9a5SSteve French struct mnt_idmap *idmap = file_mnt_idmap(fp->filp); 477538c8a9a5SSteve French vfsuid_t vfsuid = i_uid_into_vfsuid(idmap, inode); 477638c8a9a5SSteve French vfsgid_t vfsgid = i_gid_into_vfsgid(idmap, inode); 477738c8a9a5SSteve French u64 time; 477838c8a9a5SSteve French int out_buf_len = sizeof(struct smb311_posix_qinfo) + 32; 477938c8a9a5SSteve French 478038c8a9a5SSteve French file_info = (struct smb311_posix_qinfo *)rsp->Buffer; 478138c8a9a5SSteve French file_info->CreationTime = cpu_to_le64(fp->create_time); 478238c8a9a5SSteve French time = ksmbd_UnixTimeToNT(inode->i_atime); 478338c8a9a5SSteve French file_info->LastAccessTime = cpu_to_le64(time); 478438c8a9a5SSteve French time = ksmbd_UnixTimeToNT(inode->i_mtime); 478538c8a9a5SSteve French file_info->LastWriteTime = cpu_to_le64(time); 478638c8a9a5SSteve French time = ksmbd_UnixTimeToNT(inode->i_ctime); 478738c8a9a5SSteve French file_info->ChangeTime = cpu_to_le64(time); 478838c8a9a5SSteve French file_info->DosAttributes = fp->f_ci->m_fattr; 478938c8a9a5SSteve French file_info->Inode = cpu_to_le64(inode->i_ino); 479038c8a9a5SSteve French file_info->EndOfFile = cpu_to_le64(inode->i_size); 479138c8a9a5SSteve French file_info->AllocationSize = cpu_to_le64(inode->i_blocks << 9); 479238c8a9a5SSteve French file_info->HardLinks = cpu_to_le32(inode->i_nlink); 479338c8a9a5SSteve French file_info->Mode = cpu_to_le32(inode->i_mode & 0777); 479438c8a9a5SSteve French file_info->DeviceId = cpu_to_le32(inode->i_rdev); 479538c8a9a5SSteve French 479638c8a9a5SSteve French /* 479738c8a9a5SSteve French * Sids(32) contain two sids(Domain sid(16), UNIX group sid(16)). 479838c8a9a5SSteve French * UNIX sid(16) = revision(1) + num_subauth(1) + authority(6) + 479938c8a9a5SSteve French * sub_auth(4 * 1(num_subauth)) + RID(4). 480038c8a9a5SSteve French */ 480138c8a9a5SSteve French id_to_sid(from_kuid_munged(&init_user_ns, vfsuid_into_kuid(vfsuid)), 480238c8a9a5SSteve French SIDUNIX_USER, (struct smb_sid *)&file_info->Sids[0]); 480338c8a9a5SSteve French id_to_sid(from_kgid_munged(&init_user_ns, vfsgid_into_kgid(vfsgid)), 480438c8a9a5SSteve French SIDUNIX_GROUP, (struct smb_sid *)&file_info->Sids[16]); 480538c8a9a5SSteve French 480638c8a9a5SSteve French rsp->OutputBufferLength = cpu_to_le32(out_buf_len); 480738c8a9a5SSteve French inc_rfc1001_len(rsp_org, out_buf_len); 480838c8a9a5SSteve French return out_buf_len; 480938c8a9a5SSteve French } 481038c8a9a5SSteve French 481138c8a9a5SSteve French static int smb2_get_info_file(struct ksmbd_work *work, 481238c8a9a5SSteve French struct smb2_query_info_req *req, 481338c8a9a5SSteve French struct smb2_query_info_rsp *rsp) 481438c8a9a5SSteve French { 481538c8a9a5SSteve French struct ksmbd_file *fp; 481638c8a9a5SSteve French int fileinfoclass = 0; 481738c8a9a5SSteve French int rc = 0; 481838c8a9a5SSteve French int file_infoclass_size; 481938c8a9a5SSteve French unsigned int id = KSMBD_NO_FID, pid = KSMBD_NO_FID; 482038c8a9a5SSteve French 482138c8a9a5SSteve French if (test_share_config_flag(work->tcon->share_conf, 482238c8a9a5SSteve French KSMBD_SHARE_FLAG_PIPE)) { 482338c8a9a5SSteve French /* smb2 info file called for pipe */ 482438c8a9a5SSteve French return smb2_get_info_file_pipe(work->sess, req, rsp, 482538c8a9a5SSteve French work->response_buf); 482638c8a9a5SSteve French } 482738c8a9a5SSteve French 482838c8a9a5SSteve French if (work->next_smb2_rcv_hdr_off) { 482938c8a9a5SSteve French if (!has_file_id(req->VolatileFileId)) { 483038c8a9a5SSteve French ksmbd_debug(SMB, "Compound request set FID = %llu\n", 483138c8a9a5SSteve French work->compound_fid); 483238c8a9a5SSteve French id = work->compound_fid; 483338c8a9a5SSteve French pid = work->compound_pfid; 483438c8a9a5SSteve French } 483538c8a9a5SSteve French } 483638c8a9a5SSteve French 483738c8a9a5SSteve French if (!has_file_id(id)) { 483838c8a9a5SSteve French id = req->VolatileFileId; 483938c8a9a5SSteve French pid = req->PersistentFileId; 484038c8a9a5SSteve French } 484138c8a9a5SSteve French 484238c8a9a5SSteve French fp = ksmbd_lookup_fd_slow(work, id, pid); 484338c8a9a5SSteve French if (!fp) 484438c8a9a5SSteve French return -ENOENT; 484538c8a9a5SSteve French 484638c8a9a5SSteve French fileinfoclass = req->FileInfoClass; 484738c8a9a5SSteve French 484838c8a9a5SSteve French switch (fileinfoclass) { 484938c8a9a5SSteve French case FILE_ACCESS_INFORMATION: 485038c8a9a5SSteve French get_file_access_info(rsp, fp, work->response_buf); 485138c8a9a5SSteve French file_infoclass_size = FILE_ACCESS_INFORMATION_SIZE; 485238c8a9a5SSteve French break; 485338c8a9a5SSteve French 485438c8a9a5SSteve French case FILE_BASIC_INFORMATION: 485538c8a9a5SSteve French rc = get_file_basic_info(rsp, fp, work->response_buf); 485638c8a9a5SSteve French file_infoclass_size = FILE_BASIC_INFORMATION_SIZE; 485738c8a9a5SSteve French break; 485838c8a9a5SSteve French 485938c8a9a5SSteve French case FILE_STANDARD_INFORMATION: 486038c8a9a5SSteve French get_file_standard_info(rsp, fp, work->response_buf); 486138c8a9a5SSteve French file_infoclass_size = FILE_STANDARD_INFORMATION_SIZE; 486238c8a9a5SSteve French break; 486338c8a9a5SSteve French 486438c8a9a5SSteve French case FILE_ALIGNMENT_INFORMATION: 486538c8a9a5SSteve French get_file_alignment_info(rsp, work->response_buf); 486638c8a9a5SSteve French file_infoclass_size = FILE_ALIGNMENT_INFORMATION_SIZE; 486738c8a9a5SSteve French break; 486838c8a9a5SSteve French 486938c8a9a5SSteve French case FILE_ALL_INFORMATION: 487038c8a9a5SSteve French rc = get_file_all_info(work, rsp, fp, work->response_buf); 487138c8a9a5SSteve French file_infoclass_size = FILE_ALL_INFORMATION_SIZE; 487238c8a9a5SSteve French break; 487338c8a9a5SSteve French 487438c8a9a5SSteve French case FILE_ALTERNATE_NAME_INFORMATION: 487538c8a9a5SSteve French get_file_alternate_info(work, rsp, fp, work->response_buf); 487638c8a9a5SSteve French file_infoclass_size = FILE_ALTERNATE_NAME_INFORMATION_SIZE; 487738c8a9a5SSteve French break; 487838c8a9a5SSteve French 487938c8a9a5SSteve French case FILE_STREAM_INFORMATION: 488038c8a9a5SSteve French get_file_stream_info(work, rsp, fp, work->response_buf); 488138c8a9a5SSteve French file_infoclass_size = FILE_STREAM_INFORMATION_SIZE; 488238c8a9a5SSteve French break; 488338c8a9a5SSteve French 488438c8a9a5SSteve French case FILE_INTERNAL_INFORMATION: 488538c8a9a5SSteve French get_file_internal_info(rsp, fp, work->response_buf); 488638c8a9a5SSteve French file_infoclass_size = FILE_INTERNAL_INFORMATION_SIZE; 488738c8a9a5SSteve French break; 488838c8a9a5SSteve French 488938c8a9a5SSteve French case FILE_NETWORK_OPEN_INFORMATION: 489038c8a9a5SSteve French rc = get_file_network_open_info(rsp, fp, work->response_buf); 489138c8a9a5SSteve French file_infoclass_size = FILE_NETWORK_OPEN_INFORMATION_SIZE; 489238c8a9a5SSteve French break; 489338c8a9a5SSteve French 489438c8a9a5SSteve French case FILE_EA_INFORMATION: 489538c8a9a5SSteve French get_file_ea_info(rsp, work->response_buf); 489638c8a9a5SSteve French file_infoclass_size = FILE_EA_INFORMATION_SIZE; 489738c8a9a5SSteve French break; 489838c8a9a5SSteve French 489938c8a9a5SSteve French case FILE_FULL_EA_INFORMATION: 490038c8a9a5SSteve French rc = smb2_get_ea(work, fp, req, rsp, work->response_buf); 490138c8a9a5SSteve French file_infoclass_size = FILE_FULL_EA_INFORMATION_SIZE; 490238c8a9a5SSteve French break; 490338c8a9a5SSteve French 490438c8a9a5SSteve French case FILE_POSITION_INFORMATION: 490538c8a9a5SSteve French get_file_position_info(rsp, fp, work->response_buf); 490638c8a9a5SSteve French file_infoclass_size = FILE_POSITION_INFORMATION_SIZE; 490738c8a9a5SSteve French break; 490838c8a9a5SSteve French 490938c8a9a5SSteve French case FILE_MODE_INFORMATION: 491038c8a9a5SSteve French get_file_mode_info(rsp, fp, work->response_buf); 491138c8a9a5SSteve French file_infoclass_size = FILE_MODE_INFORMATION_SIZE; 491238c8a9a5SSteve French break; 491338c8a9a5SSteve French 491438c8a9a5SSteve French case FILE_COMPRESSION_INFORMATION: 491538c8a9a5SSteve French get_file_compression_info(rsp, fp, work->response_buf); 491638c8a9a5SSteve French file_infoclass_size = FILE_COMPRESSION_INFORMATION_SIZE; 491738c8a9a5SSteve French break; 491838c8a9a5SSteve French 491938c8a9a5SSteve French case FILE_ATTRIBUTE_TAG_INFORMATION: 492038c8a9a5SSteve French rc = get_file_attribute_tag_info(rsp, fp, work->response_buf); 492138c8a9a5SSteve French file_infoclass_size = FILE_ATTRIBUTE_TAG_INFORMATION_SIZE; 492238c8a9a5SSteve French break; 492338c8a9a5SSteve French case SMB_FIND_FILE_POSIX_INFO: 492438c8a9a5SSteve French if (!work->tcon->posix_extensions) { 492538c8a9a5SSteve French pr_err("client doesn't negotiate with SMB3.1.1 POSIX Extensions\n"); 492638c8a9a5SSteve French rc = -EOPNOTSUPP; 492738c8a9a5SSteve French } else { 492838c8a9a5SSteve French file_infoclass_size = find_file_posix_info(rsp, fp, 492938c8a9a5SSteve French work->response_buf); 493038c8a9a5SSteve French } 493138c8a9a5SSteve French break; 493238c8a9a5SSteve French default: 493338c8a9a5SSteve French ksmbd_debug(SMB, "fileinfoclass %d not supported yet\n", 493438c8a9a5SSteve French fileinfoclass); 493538c8a9a5SSteve French rc = -EOPNOTSUPP; 493638c8a9a5SSteve French } 493738c8a9a5SSteve French if (!rc) 493838c8a9a5SSteve French rc = buffer_check_err(le32_to_cpu(req->OutputBufferLength), 493938c8a9a5SSteve French rsp, work->response_buf, 494038c8a9a5SSteve French file_infoclass_size); 494138c8a9a5SSteve French ksmbd_fd_put(work, fp); 494238c8a9a5SSteve French return rc; 494338c8a9a5SSteve French } 494438c8a9a5SSteve French 494538c8a9a5SSteve French static int smb2_get_info_filesystem(struct ksmbd_work *work, 494638c8a9a5SSteve French struct smb2_query_info_req *req, 494738c8a9a5SSteve French struct smb2_query_info_rsp *rsp) 494838c8a9a5SSteve French { 494938c8a9a5SSteve French struct ksmbd_session *sess = work->sess; 495038c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 495138c8a9a5SSteve French struct ksmbd_share_config *share = work->tcon->share_conf; 495238c8a9a5SSteve French int fsinfoclass = 0; 495338c8a9a5SSteve French struct kstatfs stfs; 495438c8a9a5SSteve French struct path path; 495538c8a9a5SSteve French int rc = 0, len; 495638c8a9a5SSteve French int fs_infoclass_size = 0; 495738c8a9a5SSteve French 495838c8a9a5SSteve French if (!share->path) 495938c8a9a5SSteve French return -EIO; 496038c8a9a5SSteve French 496138c8a9a5SSteve French rc = kern_path(share->path, LOOKUP_NO_SYMLINKS, &path); 496238c8a9a5SSteve French if (rc) { 496338c8a9a5SSteve French pr_err("cannot create vfs path\n"); 496438c8a9a5SSteve French return -EIO; 496538c8a9a5SSteve French } 496638c8a9a5SSteve French 496738c8a9a5SSteve French rc = vfs_statfs(&path, &stfs); 496838c8a9a5SSteve French if (rc) { 496938c8a9a5SSteve French pr_err("cannot do stat of path %s\n", share->path); 497038c8a9a5SSteve French path_put(&path); 497138c8a9a5SSteve French return -EIO; 497238c8a9a5SSteve French } 497338c8a9a5SSteve French 497438c8a9a5SSteve French fsinfoclass = req->FileInfoClass; 497538c8a9a5SSteve French 497638c8a9a5SSteve French switch (fsinfoclass) { 497738c8a9a5SSteve French case FS_DEVICE_INFORMATION: 497838c8a9a5SSteve French { 497938c8a9a5SSteve French struct filesystem_device_info *info; 498038c8a9a5SSteve French 498138c8a9a5SSteve French info = (struct filesystem_device_info *)rsp->Buffer; 498238c8a9a5SSteve French 498338c8a9a5SSteve French info->DeviceType = cpu_to_le32(stfs.f_type); 498438c8a9a5SSteve French info->DeviceCharacteristics = cpu_to_le32(0x00000020); 498538c8a9a5SSteve French rsp->OutputBufferLength = cpu_to_le32(8); 498638c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 8); 498738c8a9a5SSteve French fs_infoclass_size = FS_DEVICE_INFORMATION_SIZE; 498838c8a9a5SSteve French break; 498938c8a9a5SSteve French } 499038c8a9a5SSteve French case FS_ATTRIBUTE_INFORMATION: 499138c8a9a5SSteve French { 499238c8a9a5SSteve French struct filesystem_attribute_info *info; 499338c8a9a5SSteve French size_t sz; 499438c8a9a5SSteve French 499538c8a9a5SSteve French info = (struct filesystem_attribute_info *)rsp->Buffer; 499638c8a9a5SSteve French info->Attributes = cpu_to_le32(FILE_SUPPORTS_OBJECT_IDS | 499738c8a9a5SSteve French FILE_PERSISTENT_ACLS | 499838c8a9a5SSteve French FILE_UNICODE_ON_DISK | 499938c8a9a5SSteve French FILE_CASE_PRESERVED_NAMES | 500038c8a9a5SSteve French FILE_CASE_SENSITIVE_SEARCH | 500138c8a9a5SSteve French FILE_SUPPORTS_BLOCK_REFCOUNTING); 500238c8a9a5SSteve French 500338c8a9a5SSteve French info->Attributes |= cpu_to_le32(server_conf.share_fake_fscaps); 500438c8a9a5SSteve French 500538c8a9a5SSteve French if (test_share_config_flag(work->tcon->share_conf, 500638c8a9a5SSteve French KSMBD_SHARE_FLAG_STREAMS)) 500738c8a9a5SSteve French info->Attributes |= cpu_to_le32(FILE_NAMED_STREAMS); 500838c8a9a5SSteve French 500938c8a9a5SSteve French info->MaxPathNameComponentLength = cpu_to_le32(stfs.f_namelen); 501038c8a9a5SSteve French len = smbConvertToUTF16((__le16 *)info->FileSystemName, 501138c8a9a5SSteve French "NTFS", PATH_MAX, conn->local_nls, 0); 501238c8a9a5SSteve French len = len * 2; 501338c8a9a5SSteve French info->FileSystemNameLen = cpu_to_le32(len); 501438c8a9a5SSteve French sz = sizeof(struct filesystem_attribute_info) - 2 + len; 501538c8a9a5SSteve French rsp->OutputBufferLength = cpu_to_le32(sz); 501638c8a9a5SSteve French inc_rfc1001_len(work->response_buf, sz); 501738c8a9a5SSteve French fs_infoclass_size = FS_ATTRIBUTE_INFORMATION_SIZE; 501838c8a9a5SSteve French break; 501938c8a9a5SSteve French } 502038c8a9a5SSteve French case FS_VOLUME_INFORMATION: 502138c8a9a5SSteve French { 502238c8a9a5SSteve French struct filesystem_vol_info *info; 502338c8a9a5SSteve French size_t sz; 502438c8a9a5SSteve French unsigned int serial_crc = 0; 502538c8a9a5SSteve French 502638c8a9a5SSteve French info = (struct filesystem_vol_info *)(rsp->Buffer); 502738c8a9a5SSteve French info->VolumeCreationTime = 0; 502838c8a9a5SSteve French serial_crc = crc32_le(serial_crc, share->name, 502938c8a9a5SSteve French strlen(share->name)); 503038c8a9a5SSteve French serial_crc = crc32_le(serial_crc, share->path, 503138c8a9a5SSteve French strlen(share->path)); 503238c8a9a5SSteve French serial_crc = crc32_le(serial_crc, ksmbd_netbios_name(), 503338c8a9a5SSteve French strlen(ksmbd_netbios_name())); 503438c8a9a5SSteve French /* Taking dummy value of serial number*/ 503538c8a9a5SSteve French info->SerialNumber = cpu_to_le32(serial_crc); 503638c8a9a5SSteve French len = smbConvertToUTF16((__le16 *)info->VolumeLabel, 503738c8a9a5SSteve French share->name, PATH_MAX, 503838c8a9a5SSteve French conn->local_nls, 0); 503938c8a9a5SSteve French len = len * 2; 504038c8a9a5SSteve French info->VolumeLabelSize = cpu_to_le32(len); 504138c8a9a5SSteve French info->Reserved = 0; 504238c8a9a5SSteve French sz = sizeof(struct filesystem_vol_info) - 2 + len; 504338c8a9a5SSteve French rsp->OutputBufferLength = cpu_to_le32(sz); 504438c8a9a5SSteve French inc_rfc1001_len(work->response_buf, sz); 504538c8a9a5SSteve French fs_infoclass_size = FS_VOLUME_INFORMATION_SIZE; 504638c8a9a5SSteve French break; 504738c8a9a5SSteve French } 504838c8a9a5SSteve French case FS_SIZE_INFORMATION: 504938c8a9a5SSteve French { 505038c8a9a5SSteve French struct filesystem_info *info; 505138c8a9a5SSteve French 505238c8a9a5SSteve French info = (struct filesystem_info *)(rsp->Buffer); 505338c8a9a5SSteve French info->TotalAllocationUnits = cpu_to_le64(stfs.f_blocks); 505438c8a9a5SSteve French info->FreeAllocationUnits = cpu_to_le64(stfs.f_bfree); 505538c8a9a5SSteve French info->SectorsPerAllocationUnit = cpu_to_le32(1); 505638c8a9a5SSteve French info->BytesPerSector = cpu_to_le32(stfs.f_bsize); 505738c8a9a5SSteve French rsp->OutputBufferLength = cpu_to_le32(24); 505838c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 24); 505938c8a9a5SSteve French fs_infoclass_size = FS_SIZE_INFORMATION_SIZE; 506038c8a9a5SSteve French break; 506138c8a9a5SSteve French } 506238c8a9a5SSteve French case FS_FULL_SIZE_INFORMATION: 506338c8a9a5SSteve French { 506438c8a9a5SSteve French struct smb2_fs_full_size_info *info; 506538c8a9a5SSteve French 506638c8a9a5SSteve French info = (struct smb2_fs_full_size_info *)(rsp->Buffer); 506738c8a9a5SSteve French info->TotalAllocationUnits = cpu_to_le64(stfs.f_blocks); 506838c8a9a5SSteve French info->CallerAvailableAllocationUnits = 506938c8a9a5SSteve French cpu_to_le64(stfs.f_bavail); 507038c8a9a5SSteve French info->ActualAvailableAllocationUnits = 507138c8a9a5SSteve French cpu_to_le64(stfs.f_bfree); 507238c8a9a5SSteve French info->SectorsPerAllocationUnit = cpu_to_le32(1); 507338c8a9a5SSteve French info->BytesPerSector = cpu_to_le32(stfs.f_bsize); 507438c8a9a5SSteve French rsp->OutputBufferLength = cpu_to_le32(32); 507538c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 32); 507638c8a9a5SSteve French fs_infoclass_size = FS_FULL_SIZE_INFORMATION_SIZE; 507738c8a9a5SSteve French break; 507838c8a9a5SSteve French } 507938c8a9a5SSteve French case FS_OBJECT_ID_INFORMATION: 508038c8a9a5SSteve French { 508138c8a9a5SSteve French struct object_id_info *info; 508238c8a9a5SSteve French 508338c8a9a5SSteve French info = (struct object_id_info *)(rsp->Buffer); 508438c8a9a5SSteve French 508538c8a9a5SSteve French if (!user_guest(sess->user)) 508638c8a9a5SSteve French memcpy(info->objid, user_passkey(sess->user), 16); 508738c8a9a5SSteve French else 508838c8a9a5SSteve French memset(info->objid, 0, 16); 508938c8a9a5SSteve French 509038c8a9a5SSteve French info->extended_info.magic = cpu_to_le32(EXTENDED_INFO_MAGIC); 509138c8a9a5SSteve French info->extended_info.version = cpu_to_le32(1); 509238c8a9a5SSteve French info->extended_info.release = cpu_to_le32(1); 509338c8a9a5SSteve French info->extended_info.rel_date = 0; 509438c8a9a5SSteve French memcpy(info->extended_info.version_string, "1.1.0", strlen("1.1.0")); 509538c8a9a5SSteve French rsp->OutputBufferLength = cpu_to_le32(64); 509638c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 64); 509738c8a9a5SSteve French fs_infoclass_size = FS_OBJECT_ID_INFORMATION_SIZE; 509838c8a9a5SSteve French break; 509938c8a9a5SSteve French } 510038c8a9a5SSteve French case FS_SECTOR_SIZE_INFORMATION: 510138c8a9a5SSteve French { 510238c8a9a5SSteve French struct smb3_fs_ss_info *info; 510338c8a9a5SSteve French unsigned int sector_size = 510438c8a9a5SSteve French min_t(unsigned int, path.mnt->mnt_sb->s_blocksize, 4096); 510538c8a9a5SSteve French 510638c8a9a5SSteve French info = (struct smb3_fs_ss_info *)(rsp->Buffer); 510738c8a9a5SSteve French 510838c8a9a5SSteve French info->LogicalBytesPerSector = cpu_to_le32(sector_size); 510938c8a9a5SSteve French info->PhysicalBytesPerSectorForAtomicity = 511038c8a9a5SSteve French cpu_to_le32(sector_size); 511138c8a9a5SSteve French info->PhysicalBytesPerSectorForPerf = cpu_to_le32(sector_size); 511238c8a9a5SSteve French info->FSEffPhysicalBytesPerSectorForAtomicity = 511338c8a9a5SSteve French cpu_to_le32(sector_size); 511438c8a9a5SSteve French info->Flags = cpu_to_le32(SSINFO_FLAGS_ALIGNED_DEVICE | 511538c8a9a5SSteve French SSINFO_FLAGS_PARTITION_ALIGNED_ON_DEVICE); 511638c8a9a5SSteve French info->ByteOffsetForSectorAlignment = 0; 511738c8a9a5SSteve French info->ByteOffsetForPartitionAlignment = 0; 511838c8a9a5SSteve French rsp->OutputBufferLength = cpu_to_le32(28); 511938c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 28); 512038c8a9a5SSteve French fs_infoclass_size = FS_SECTOR_SIZE_INFORMATION_SIZE; 512138c8a9a5SSteve French break; 512238c8a9a5SSteve French } 512338c8a9a5SSteve French case FS_CONTROL_INFORMATION: 512438c8a9a5SSteve French { 512538c8a9a5SSteve French /* 512638c8a9a5SSteve French * TODO : The current implementation is based on 512738c8a9a5SSteve French * test result with win7(NTFS) server. It's need to 512838c8a9a5SSteve French * modify this to get valid Quota values 512938c8a9a5SSteve French * from Linux kernel 513038c8a9a5SSteve French */ 513138c8a9a5SSteve French struct smb2_fs_control_info *info; 513238c8a9a5SSteve French 513338c8a9a5SSteve French info = (struct smb2_fs_control_info *)(rsp->Buffer); 513438c8a9a5SSteve French info->FreeSpaceStartFiltering = 0; 513538c8a9a5SSteve French info->FreeSpaceThreshold = 0; 513638c8a9a5SSteve French info->FreeSpaceStopFiltering = 0; 513738c8a9a5SSteve French info->DefaultQuotaThreshold = cpu_to_le64(SMB2_NO_FID); 513838c8a9a5SSteve French info->DefaultQuotaLimit = cpu_to_le64(SMB2_NO_FID); 513938c8a9a5SSteve French info->Padding = 0; 514038c8a9a5SSteve French rsp->OutputBufferLength = cpu_to_le32(48); 514138c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 48); 514238c8a9a5SSteve French fs_infoclass_size = FS_CONTROL_INFORMATION_SIZE; 514338c8a9a5SSteve French break; 514438c8a9a5SSteve French } 514538c8a9a5SSteve French case FS_POSIX_INFORMATION: 514638c8a9a5SSteve French { 514738c8a9a5SSteve French struct filesystem_posix_info *info; 514838c8a9a5SSteve French 514938c8a9a5SSteve French if (!work->tcon->posix_extensions) { 515038c8a9a5SSteve French pr_err("client doesn't negotiate with SMB3.1.1 POSIX Extensions\n"); 515138c8a9a5SSteve French rc = -EOPNOTSUPP; 515238c8a9a5SSteve French } else { 515338c8a9a5SSteve French info = (struct filesystem_posix_info *)(rsp->Buffer); 515438c8a9a5SSteve French info->OptimalTransferSize = cpu_to_le32(stfs.f_bsize); 515538c8a9a5SSteve French info->BlockSize = cpu_to_le32(stfs.f_bsize); 515638c8a9a5SSteve French info->TotalBlocks = cpu_to_le64(stfs.f_blocks); 515738c8a9a5SSteve French info->BlocksAvail = cpu_to_le64(stfs.f_bfree); 515838c8a9a5SSteve French info->UserBlocksAvail = cpu_to_le64(stfs.f_bavail); 515938c8a9a5SSteve French info->TotalFileNodes = cpu_to_le64(stfs.f_files); 516038c8a9a5SSteve French info->FreeFileNodes = cpu_to_le64(stfs.f_ffree); 516138c8a9a5SSteve French rsp->OutputBufferLength = cpu_to_le32(56); 516238c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 56); 516338c8a9a5SSteve French fs_infoclass_size = FS_POSIX_INFORMATION_SIZE; 516438c8a9a5SSteve French } 516538c8a9a5SSteve French break; 516638c8a9a5SSteve French } 516738c8a9a5SSteve French default: 516838c8a9a5SSteve French path_put(&path); 516938c8a9a5SSteve French return -EOPNOTSUPP; 517038c8a9a5SSteve French } 517138c8a9a5SSteve French rc = buffer_check_err(le32_to_cpu(req->OutputBufferLength), 517238c8a9a5SSteve French rsp, work->response_buf, 517338c8a9a5SSteve French fs_infoclass_size); 517438c8a9a5SSteve French path_put(&path); 517538c8a9a5SSteve French return rc; 517638c8a9a5SSteve French } 517738c8a9a5SSteve French 517838c8a9a5SSteve French static int smb2_get_info_sec(struct ksmbd_work *work, 517938c8a9a5SSteve French struct smb2_query_info_req *req, 518038c8a9a5SSteve French struct smb2_query_info_rsp *rsp) 518138c8a9a5SSteve French { 518238c8a9a5SSteve French struct ksmbd_file *fp; 518338c8a9a5SSteve French struct mnt_idmap *idmap; 518438c8a9a5SSteve French struct smb_ntsd *pntsd = (struct smb_ntsd *)rsp->Buffer, *ppntsd = NULL; 518538c8a9a5SSteve French struct smb_fattr fattr = {{0}}; 518638c8a9a5SSteve French struct inode *inode; 518738c8a9a5SSteve French __u32 secdesclen = 0; 518838c8a9a5SSteve French unsigned int id = KSMBD_NO_FID, pid = KSMBD_NO_FID; 518938c8a9a5SSteve French int addition_info = le32_to_cpu(req->AdditionalInformation); 519038c8a9a5SSteve French int rc = 0, ppntsd_size = 0; 519138c8a9a5SSteve French 519238c8a9a5SSteve French if (addition_info & ~(OWNER_SECINFO | GROUP_SECINFO | DACL_SECINFO | 519338c8a9a5SSteve French PROTECTED_DACL_SECINFO | 519438c8a9a5SSteve French UNPROTECTED_DACL_SECINFO)) { 519538c8a9a5SSteve French ksmbd_debug(SMB, "Unsupported addition info: 0x%x)\n", 519638c8a9a5SSteve French addition_info); 519738c8a9a5SSteve French 519838c8a9a5SSteve French pntsd->revision = cpu_to_le16(1); 519938c8a9a5SSteve French pntsd->type = cpu_to_le16(SELF_RELATIVE | DACL_PROTECTED); 520038c8a9a5SSteve French pntsd->osidoffset = 0; 520138c8a9a5SSteve French pntsd->gsidoffset = 0; 520238c8a9a5SSteve French pntsd->sacloffset = 0; 520338c8a9a5SSteve French pntsd->dacloffset = 0; 520438c8a9a5SSteve French 520538c8a9a5SSteve French secdesclen = sizeof(struct smb_ntsd); 520638c8a9a5SSteve French rsp->OutputBufferLength = cpu_to_le32(secdesclen); 520738c8a9a5SSteve French inc_rfc1001_len(work->response_buf, secdesclen); 520838c8a9a5SSteve French 520938c8a9a5SSteve French return 0; 521038c8a9a5SSteve French } 521138c8a9a5SSteve French 521238c8a9a5SSteve French if (work->next_smb2_rcv_hdr_off) { 521338c8a9a5SSteve French if (!has_file_id(req->VolatileFileId)) { 521438c8a9a5SSteve French ksmbd_debug(SMB, "Compound request set FID = %llu\n", 521538c8a9a5SSteve French work->compound_fid); 521638c8a9a5SSteve French id = work->compound_fid; 521738c8a9a5SSteve French pid = work->compound_pfid; 521838c8a9a5SSteve French } 521938c8a9a5SSteve French } 522038c8a9a5SSteve French 522138c8a9a5SSteve French if (!has_file_id(id)) { 522238c8a9a5SSteve French id = req->VolatileFileId; 522338c8a9a5SSteve French pid = req->PersistentFileId; 522438c8a9a5SSteve French } 522538c8a9a5SSteve French 522638c8a9a5SSteve French fp = ksmbd_lookup_fd_slow(work, id, pid); 522738c8a9a5SSteve French if (!fp) 522838c8a9a5SSteve French return -ENOENT; 522938c8a9a5SSteve French 523038c8a9a5SSteve French idmap = file_mnt_idmap(fp->filp); 523138c8a9a5SSteve French inode = file_inode(fp->filp); 523238c8a9a5SSteve French ksmbd_acls_fattr(&fattr, idmap, inode); 523338c8a9a5SSteve French 523438c8a9a5SSteve French if (test_share_config_flag(work->tcon->share_conf, 523538c8a9a5SSteve French KSMBD_SHARE_FLAG_ACL_XATTR)) 523638c8a9a5SSteve French ppntsd_size = ksmbd_vfs_get_sd_xattr(work->conn, idmap, 523738c8a9a5SSteve French fp->filp->f_path.dentry, 523838c8a9a5SSteve French &ppntsd); 523938c8a9a5SSteve French 524038c8a9a5SSteve French /* Check if sd buffer size exceeds response buffer size */ 524138c8a9a5SSteve French if (smb2_resp_buf_len(work, 8) > ppntsd_size) 524238c8a9a5SSteve French rc = build_sec_desc(idmap, pntsd, ppntsd, ppntsd_size, 524338c8a9a5SSteve French addition_info, &secdesclen, &fattr); 524438c8a9a5SSteve French posix_acl_release(fattr.cf_acls); 524538c8a9a5SSteve French posix_acl_release(fattr.cf_dacls); 524638c8a9a5SSteve French kfree(ppntsd); 524738c8a9a5SSteve French ksmbd_fd_put(work, fp); 524838c8a9a5SSteve French if (rc) 524938c8a9a5SSteve French return rc; 525038c8a9a5SSteve French 525138c8a9a5SSteve French rsp->OutputBufferLength = cpu_to_le32(secdesclen); 525238c8a9a5SSteve French inc_rfc1001_len(work->response_buf, secdesclen); 525338c8a9a5SSteve French return 0; 525438c8a9a5SSteve French } 525538c8a9a5SSteve French 525638c8a9a5SSteve French /** 525738c8a9a5SSteve French * smb2_query_info() - handler for smb2 query info command 525838c8a9a5SSteve French * @work: smb work containing query info request buffer 525938c8a9a5SSteve French * 526038c8a9a5SSteve French * Return: 0 on success, otherwise error 526138c8a9a5SSteve French */ 526238c8a9a5SSteve French int smb2_query_info(struct ksmbd_work *work) 526338c8a9a5SSteve French { 526438c8a9a5SSteve French struct smb2_query_info_req *req; 526538c8a9a5SSteve French struct smb2_query_info_rsp *rsp; 526638c8a9a5SSteve French int rc = 0; 526738c8a9a5SSteve French 526838c8a9a5SSteve French WORK_BUFFERS(work, req, rsp); 526938c8a9a5SSteve French 527038c8a9a5SSteve French ksmbd_debug(SMB, "GOT query info request\n"); 527138c8a9a5SSteve French 527238c8a9a5SSteve French switch (req->InfoType) { 527338c8a9a5SSteve French case SMB2_O_INFO_FILE: 527438c8a9a5SSteve French ksmbd_debug(SMB, "GOT SMB2_O_INFO_FILE\n"); 527538c8a9a5SSteve French rc = smb2_get_info_file(work, req, rsp); 527638c8a9a5SSteve French break; 527738c8a9a5SSteve French case SMB2_O_INFO_FILESYSTEM: 527838c8a9a5SSteve French ksmbd_debug(SMB, "GOT SMB2_O_INFO_FILESYSTEM\n"); 527938c8a9a5SSteve French rc = smb2_get_info_filesystem(work, req, rsp); 528038c8a9a5SSteve French break; 528138c8a9a5SSteve French case SMB2_O_INFO_SECURITY: 528238c8a9a5SSteve French ksmbd_debug(SMB, "GOT SMB2_O_INFO_SECURITY\n"); 528338c8a9a5SSteve French rc = smb2_get_info_sec(work, req, rsp); 528438c8a9a5SSteve French break; 528538c8a9a5SSteve French default: 528638c8a9a5SSteve French ksmbd_debug(SMB, "InfoType %d not supported yet\n", 528738c8a9a5SSteve French req->InfoType); 528838c8a9a5SSteve French rc = -EOPNOTSUPP; 528938c8a9a5SSteve French } 529038c8a9a5SSteve French 529138c8a9a5SSteve French if (rc < 0) { 529238c8a9a5SSteve French if (rc == -EACCES) 529338c8a9a5SSteve French rsp->hdr.Status = STATUS_ACCESS_DENIED; 529438c8a9a5SSteve French else if (rc == -ENOENT) 529538c8a9a5SSteve French rsp->hdr.Status = STATUS_FILE_CLOSED; 529638c8a9a5SSteve French else if (rc == -EIO) 529738c8a9a5SSteve French rsp->hdr.Status = STATUS_UNEXPECTED_IO_ERROR; 529838c8a9a5SSteve French else if (rc == -EOPNOTSUPP || rsp->hdr.Status == 0) 529938c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_INFO_CLASS; 530038c8a9a5SSteve French smb2_set_err_rsp(work); 530138c8a9a5SSteve French 530238c8a9a5SSteve French ksmbd_debug(SMB, "error while processing smb2 query rc = %d\n", 530338c8a9a5SSteve French rc); 530438c8a9a5SSteve French return rc; 530538c8a9a5SSteve French } 530638c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(9); 530738c8a9a5SSteve French rsp->OutputBufferOffset = cpu_to_le16(72); 530838c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 8); 530938c8a9a5SSteve French return 0; 531038c8a9a5SSteve French } 531138c8a9a5SSteve French 531238c8a9a5SSteve French /** 531338c8a9a5SSteve French * smb2_close_pipe() - handler for closing IPC pipe 531438c8a9a5SSteve French * @work: smb work containing close request buffer 531538c8a9a5SSteve French * 531638c8a9a5SSteve French * Return: 0 531738c8a9a5SSteve French */ 531838c8a9a5SSteve French static noinline int smb2_close_pipe(struct ksmbd_work *work) 531938c8a9a5SSteve French { 532038c8a9a5SSteve French u64 id; 53217b7d709eSNamjae Jeon struct smb2_close_req *req; 53227b7d709eSNamjae Jeon struct smb2_close_rsp *rsp; 53237b7d709eSNamjae Jeon 53247b7d709eSNamjae Jeon WORK_BUFFERS(work, req, rsp); 532538c8a9a5SSteve French 532638c8a9a5SSteve French id = req->VolatileFileId; 532738c8a9a5SSteve French ksmbd_session_rpc_close(work->sess, id); 532838c8a9a5SSteve French 532938c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(60); 533038c8a9a5SSteve French rsp->Flags = 0; 533138c8a9a5SSteve French rsp->Reserved = 0; 533238c8a9a5SSteve French rsp->CreationTime = 0; 533338c8a9a5SSteve French rsp->LastAccessTime = 0; 533438c8a9a5SSteve French rsp->LastWriteTime = 0; 533538c8a9a5SSteve French rsp->ChangeTime = 0; 533638c8a9a5SSteve French rsp->AllocationSize = 0; 533738c8a9a5SSteve French rsp->EndOfFile = 0; 533838c8a9a5SSteve French rsp->Attributes = 0; 533938c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 60); 534038c8a9a5SSteve French return 0; 534138c8a9a5SSteve French } 534238c8a9a5SSteve French 534338c8a9a5SSteve French /** 534438c8a9a5SSteve French * smb2_close() - handler for smb2 close file command 534538c8a9a5SSteve French * @work: smb work containing close request buffer 534638c8a9a5SSteve French * 534738c8a9a5SSteve French * Return: 0 534838c8a9a5SSteve French */ 534938c8a9a5SSteve French int smb2_close(struct ksmbd_work *work) 535038c8a9a5SSteve French { 535138c8a9a5SSteve French u64 volatile_id = KSMBD_NO_FID; 535238c8a9a5SSteve French u64 sess_id; 535338c8a9a5SSteve French struct smb2_close_req *req; 535438c8a9a5SSteve French struct smb2_close_rsp *rsp; 535538c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 535638c8a9a5SSteve French struct ksmbd_file *fp; 535738c8a9a5SSteve French struct inode *inode; 535838c8a9a5SSteve French u64 time; 535938c8a9a5SSteve French int err = 0; 536038c8a9a5SSteve French 536138c8a9a5SSteve French WORK_BUFFERS(work, req, rsp); 536238c8a9a5SSteve French 536338c8a9a5SSteve French if (test_share_config_flag(work->tcon->share_conf, 536438c8a9a5SSteve French KSMBD_SHARE_FLAG_PIPE)) { 536538c8a9a5SSteve French ksmbd_debug(SMB, "IPC pipe close request\n"); 536638c8a9a5SSteve French return smb2_close_pipe(work); 536738c8a9a5SSteve French } 536838c8a9a5SSteve French 536938c8a9a5SSteve French sess_id = le64_to_cpu(req->hdr.SessionId); 537038c8a9a5SSteve French if (req->hdr.Flags & SMB2_FLAGS_RELATED_OPERATIONS) 537138c8a9a5SSteve French sess_id = work->compound_sid; 537238c8a9a5SSteve French 537338c8a9a5SSteve French work->compound_sid = 0; 537438c8a9a5SSteve French if (check_session_id(conn, sess_id)) { 537538c8a9a5SSteve French work->compound_sid = sess_id; 537638c8a9a5SSteve French } else { 537738c8a9a5SSteve French rsp->hdr.Status = STATUS_USER_SESSION_DELETED; 537838c8a9a5SSteve French if (req->hdr.Flags & SMB2_FLAGS_RELATED_OPERATIONS) 537938c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 538038c8a9a5SSteve French err = -EBADF; 538138c8a9a5SSteve French goto out; 538238c8a9a5SSteve French } 538338c8a9a5SSteve French 538438c8a9a5SSteve French if (work->next_smb2_rcv_hdr_off && 538538c8a9a5SSteve French !has_file_id(req->VolatileFileId)) { 538638c8a9a5SSteve French if (!has_file_id(work->compound_fid)) { 538738c8a9a5SSteve French /* file already closed, return FILE_CLOSED */ 538838c8a9a5SSteve French ksmbd_debug(SMB, "file already closed\n"); 538938c8a9a5SSteve French rsp->hdr.Status = STATUS_FILE_CLOSED; 539038c8a9a5SSteve French err = -EBADF; 539138c8a9a5SSteve French goto out; 539238c8a9a5SSteve French } else { 539338c8a9a5SSteve French ksmbd_debug(SMB, 539438c8a9a5SSteve French "Compound request set FID = %llu:%llu\n", 539538c8a9a5SSteve French work->compound_fid, 539638c8a9a5SSteve French work->compound_pfid); 539738c8a9a5SSteve French volatile_id = work->compound_fid; 539838c8a9a5SSteve French 539938c8a9a5SSteve French /* file closed, stored id is not valid anymore */ 540038c8a9a5SSteve French work->compound_fid = KSMBD_NO_FID; 540138c8a9a5SSteve French work->compound_pfid = KSMBD_NO_FID; 540238c8a9a5SSteve French } 540338c8a9a5SSteve French } else { 540438c8a9a5SSteve French volatile_id = req->VolatileFileId; 540538c8a9a5SSteve French } 540638c8a9a5SSteve French ksmbd_debug(SMB, "volatile_id = %llu\n", volatile_id); 540738c8a9a5SSteve French 540838c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(60); 540938c8a9a5SSteve French rsp->Reserved = 0; 541038c8a9a5SSteve French 541138c8a9a5SSteve French if (req->Flags == SMB2_CLOSE_FLAG_POSTQUERY_ATTRIB) { 541238c8a9a5SSteve French fp = ksmbd_lookup_fd_fast(work, volatile_id); 541338c8a9a5SSteve French if (!fp) { 541438c8a9a5SSteve French err = -ENOENT; 541538c8a9a5SSteve French goto out; 541638c8a9a5SSteve French } 541738c8a9a5SSteve French 541838c8a9a5SSteve French inode = file_inode(fp->filp); 541938c8a9a5SSteve French rsp->Flags = SMB2_CLOSE_FLAG_POSTQUERY_ATTRIB; 542038c8a9a5SSteve French rsp->AllocationSize = S_ISDIR(inode->i_mode) ? 0 : 542138c8a9a5SSteve French cpu_to_le64(inode->i_blocks << 9); 542238c8a9a5SSteve French rsp->EndOfFile = cpu_to_le64(inode->i_size); 542338c8a9a5SSteve French rsp->Attributes = fp->f_ci->m_fattr; 542438c8a9a5SSteve French rsp->CreationTime = cpu_to_le64(fp->create_time); 542538c8a9a5SSteve French time = ksmbd_UnixTimeToNT(inode->i_atime); 542638c8a9a5SSteve French rsp->LastAccessTime = cpu_to_le64(time); 542738c8a9a5SSteve French time = ksmbd_UnixTimeToNT(inode->i_mtime); 542838c8a9a5SSteve French rsp->LastWriteTime = cpu_to_le64(time); 542938c8a9a5SSteve French time = ksmbd_UnixTimeToNT(inode->i_ctime); 543038c8a9a5SSteve French rsp->ChangeTime = cpu_to_le64(time); 543138c8a9a5SSteve French ksmbd_fd_put(work, fp); 543238c8a9a5SSteve French } else { 543338c8a9a5SSteve French rsp->Flags = 0; 543438c8a9a5SSteve French rsp->AllocationSize = 0; 543538c8a9a5SSteve French rsp->EndOfFile = 0; 543638c8a9a5SSteve French rsp->Attributes = 0; 543738c8a9a5SSteve French rsp->CreationTime = 0; 543838c8a9a5SSteve French rsp->LastAccessTime = 0; 543938c8a9a5SSteve French rsp->LastWriteTime = 0; 544038c8a9a5SSteve French rsp->ChangeTime = 0; 544138c8a9a5SSteve French } 544238c8a9a5SSteve French 544338c8a9a5SSteve French err = ksmbd_close_fd(work, volatile_id); 544438c8a9a5SSteve French out: 544538c8a9a5SSteve French if (err) { 544638c8a9a5SSteve French if (rsp->hdr.Status == 0) 544738c8a9a5SSteve French rsp->hdr.Status = STATUS_FILE_CLOSED; 544838c8a9a5SSteve French smb2_set_err_rsp(work); 544938c8a9a5SSteve French } else { 545038c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 60); 545138c8a9a5SSteve French } 545238c8a9a5SSteve French 545338c8a9a5SSteve French return 0; 545438c8a9a5SSteve French } 545538c8a9a5SSteve French 545638c8a9a5SSteve French /** 545738c8a9a5SSteve French * smb2_echo() - handler for smb2 echo(ping) command 545838c8a9a5SSteve French * @work: smb work containing echo request buffer 545938c8a9a5SSteve French * 546038c8a9a5SSteve French * Return: 0 546138c8a9a5SSteve French */ 546238c8a9a5SSteve French int smb2_echo(struct ksmbd_work *work) 546338c8a9a5SSteve French { 546438c8a9a5SSteve French struct smb2_echo_rsp *rsp = smb2_get_msg(work->response_buf); 546538c8a9a5SSteve French 54667b7d709eSNamjae Jeon if (work->next_smb2_rcv_hdr_off) 54677b7d709eSNamjae Jeon rsp = ksmbd_resp_buf_next(work); 54687b7d709eSNamjae Jeon 546938c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(4); 547038c8a9a5SSteve French rsp->Reserved = 0; 547138c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 4); 547238c8a9a5SSteve French return 0; 547338c8a9a5SSteve French } 547438c8a9a5SSteve French 547538c8a9a5SSteve French static int smb2_rename(struct ksmbd_work *work, 547638c8a9a5SSteve French struct ksmbd_file *fp, 547738c8a9a5SSteve French struct smb2_file_rename_info *file_info, 547838c8a9a5SSteve French struct nls_table *local_nls) 547938c8a9a5SSteve French { 548038c8a9a5SSteve French struct ksmbd_share_config *share = fp->tcon->share_conf; 548138c8a9a5SSteve French char *new_name = NULL; 548238c8a9a5SSteve French int rc, flags = 0; 548338c8a9a5SSteve French 548438c8a9a5SSteve French ksmbd_debug(SMB, "setting FILE_RENAME_INFO\n"); 548538c8a9a5SSteve French new_name = smb2_get_name(file_info->FileName, 548638c8a9a5SSteve French le32_to_cpu(file_info->FileNameLength), 548738c8a9a5SSteve French local_nls); 548838c8a9a5SSteve French if (IS_ERR(new_name)) 548938c8a9a5SSteve French return PTR_ERR(new_name); 549038c8a9a5SSteve French 549138c8a9a5SSteve French if (strchr(new_name, ':')) { 549238c8a9a5SSteve French int s_type; 549338c8a9a5SSteve French char *xattr_stream_name, *stream_name = NULL; 549438c8a9a5SSteve French size_t xattr_stream_size; 549538c8a9a5SSteve French int len; 549638c8a9a5SSteve French 549738c8a9a5SSteve French rc = parse_stream_name(new_name, &stream_name, &s_type); 549838c8a9a5SSteve French if (rc < 0) 549938c8a9a5SSteve French goto out; 550038c8a9a5SSteve French 550138c8a9a5SSteve French len = strlen(new_name); 550238c8a9a5SSteve French if (len > 0 && new_name[len - 1] != '/') { 550338c8a9a5SSteve French pr_err("not allow base filename in rename\n"); 550438c8a9a5SSteve French rc = -ESHARE; 550538c8a9a5SSteve French goto out; 550638c8a9a5SSteve French } 550738c8a9a5SSteve French 550838c8a9a5SSteve French rc = ksmbd_vfs_xattr_stream_name(stream_name, 550938c8a9a5SSteve French &xattr_stream_name, 551038c8a9a5SSteve French &xattr_stream_size, 551138c8a9a5SSteve French s_type); 551238c8a9a5SSteve French if (rc) 551338c8a9a5SSteve French goto out; 551438c8a9a5SSteve French 551538c8a9a5SSteve French rc = ksmbd_vfs_setxattr(file_mnt_idmap(fp->filp), 551640b268d3SNamjae Jeon &fp->filp->f_path, 551738c8a9a5SSteve French xattr_stream_name, 551838c8a9a5SSteve French NULL, 0, 0); 551938c8a9a5SSteve French if (rc < 0) { 552038c8a9a5SSteve French pr_err("failed to store stream name in xattr: %d\n", 552138c8a9a5SSteve French rc); 552238c8a9a5SSteve French rc = -EINVAL; 552338c8a9a5SSteve French goto out; 552438c8a9a5SSteve French } 552538c8a9a5SSteve French 552638c8a9a5SSteve French goto out; 552738c8a9a5SSteve French } 552838c8a9a5SSteve French 552938c8a9a5SSteve French ksmbd_debug(SMB, "new name %s\n", new_name); 553038c8a9a5SSteve French if (ksmbd_share_veto_filename(share, new_name)) { 553138c8a9a5SSteve French rc = -ENOENT; 553238c8a9a5SSteve French ksmbd_debug(SMB, "Can't rename vetoed file: %s\n", new_name); 553338c8a9a5SSteve French goto out; 553438c8a9a5SSteve French } 553538c8a9a5SSteve French 553638c8a9a5SSteve French if (!file_info->ReplaceIfExists) 553738c8a9a5SSteve French flags = RENAME_NOREPLACE; 553838c8a9a5SSteve French 553938c8a9a5SSteve French rc = ksmbd_vfs_rename(work, &fp->filp->f_path, new_name, flags); 554038c8a9a5SSteve French out: 554138c8a9a5SSteve French kfree(new_name); 554238c8a9a5SSteve French return rc; 554338c8a9a5SSteve French } 554438c8a9a5SSteve French 554538c8a9a5SSteve French static int smb2_create_link(struct ksmbd_work *work, 554638c8a9a5SSteve French struct ksmbd_share_config *share, 554738c8a9a5SSteve French struct smb2_file_link_info *file_info, 554838c8a9a5SSteve French unsigned int buf_len, struct file *filp, 554938c8a9a5SSteve French struct nls_table *local_nls) 555038c8a9a5SSteve French { 555138c8a9a5SSteve French char *link_name = NULL, *target_name = NULL, *pathname = NULL; 5552*2b57a432SNamjae Jeon struct path path, parent_path; 5553df14afeeSNamjae Jeon bool file_present = false; 555438c8a9a5SSteve French int rc; 555538c8a9a5SSteve French 555638c8a9a5SSteve French if (buf_len < (u64)sizeof(struct smb2_file_link_info) + 555738c8a9a5SSteve French le32_to_cpu(file_info->FileNameLength)) 555838c8a9a5SSteve French return -EINVAL; 555938c8a9a5SSteve French 556038c8a9a5SSteve French ksmbd_debug(SMB, "setting FILE_LINK_INFORMATION\n"); 556138c8a9a5SSteve French pathname = kmalloc(PATH_MAX, GFP_KERNEL); 556238c8a9a5SSteve French if (!pathname) 556338c8a9a5SSteve French return -ENOMEM; 556438c8a9a5SSteve French 556538c8a9a5SSteve French link_name = smb2_get_name(file_info->FileName, 556638c8a9a5SSteve French le32_to_cpu(file_info->FileNameLength), 556738c8a9a5SSteve French local_nls); 556838c8a9a5SSteve French if (IS_ERR(link_name) || S_ISDIR(file_inode(filp)->i_mode)) { 556938c8a9a5SSteve French rc = -EINVAL; 557038c8a9a5SSteve French goto out; 557138c8a9a5SSteve French } 557238c8a9a5SSteve French 557338c8a9a5SSteve French ksmbd_debug(SMB, "link name is %s\n", link_name); 557438c8a9a5SSteve French target_name = file_path(filp, pathname, PATH_MAX); 557538c8a9a5SSteve French if (IS_ERR(target_name)) { 557638c8a9a5SSteve French rc = -EINVAL; 557738c8a9a5SSteve French goto out; 557838c8a9a5SSteve French } 557938c8a9a5SSteve French 558038c8a9a5SSteve French ksmbd_debug(SMB, "target name is %s\n", target_name); 558138c8a9a5SSteve French rc = ksmbd_vfs_kern_path_locked(work, link_name, LOOKUP_NO_SYMLINKS, 5582*2b57a432SNamjae Jeon &parent_path, &path, 0); 558338c8a9a5SSteve French if (rc) { 558438c8a9a5SSteve French if (rc != -ENOENT) 558538c8a9a5SSteve French goto out; 5586df14afeeSNamjae Jeon } else 5587df14afeeSNamjae Jeon file_present = true; 558838c8a9a5SSteve French 558938c8a9a5SSteve French if (file_info->ReplaceIfExists) { 559038c8a9a5SSteve French if (file_present) { 559138c8a9a5SSteve French rc = ksmbd_vfs_remove_file(work, &path); 559238c8a9a5SSteve French if (rc) { 559338c8a9a5SSteve French rc = -EINVAL; 559438c8a9a5SSteve French ksmbd_debug(SMB, "cannot delete %s\n", 559538c8a9a5SSteve French link_name); 559638c8a9a5SSteve French goto out; 559738c8a9a5SSteve French } 559838c8a9a5SSteve French } 559938c8a9a5SSteve French } else { 560038c8a9a5SSteve French if (file_present) { 560138c8a9a5SSteve French rc = -EEXIST; 560238c8a9a5SSteve French ksmbd_debug(SMB, "link already exists\n"); 560338c8a9a5SSteve French goto out; 560438c8a9a5SSteve French } 560538c8a9a5SSteve French } 560638c8a9a5SSteve French 560738c8a9a5SSteve French rc = ksmbd_vfs_link(work, target_name, link_name); 560838c8a9a5SSteve French if (rc) 560938c8a9a5SSteve French rc = -EINVAL; 561038c8a9a5SSteve French out: 561138c8a9a5SSteve French if (file_present) { 5612*2b57a432SNamjae Jeon inode_unlock(d_inode(parent_path.dentry)); 561338c8a9a5SSteve French path_put(&path); 5614*2b57a432SNamjae Jeon path_put(&parent_path); 561538c8a9a5SSteve French } 561638c8a9a5SSteve French if (!IS_ERR(link_name)) 561738c8a9a5SSteve French kfree(link_name); 561838c8a9a5SSteve French kfree(pathname); 561938c8a9a5SSteve French return rc; 562038c8a9a5SSteve French } 562138c8a9a5SSteve French 562238c8a9a5SSteve French static int set_file_basic_info(struct ksmbd_file *fp, 562338c8a9a5SSteve French struct smb2_file_basic_info *file_info, 562438c8a9a5SSteve French struct ksmbd_share_config *share) 562538c8a9a5SSteve French { 562638c8a9a5SSteve French struct iattr attrs; 562738c8a9a5SSteve French struct file *filp; 562838c8a9a5SSteve French struct inode *inode; 562938c8a9a5SSteve French struct mnt_idmap *idmap; 563038c8a9a5SSteve French int rc = 0; 563138c8a9a5SSteve French 563238c8a9a5SSteve French if (!(fp->daccess & FILE_WRITE_ATTRIBUTES_LE)) 563338c8a9a5SSteve French return -EACCES; 563438c8a9a5SSteve French 563538c8a9a5SSteve French attrs.ia_valid = 0; 563638c8a9a5SSteve French filp = fp->filp; 563738c8a9a5SSteve French inode = file_inode(filp); 563838c8a9a5SSteve French idmap = file_mnt_idmap(filp); 563938c8a9a5SSteve French 564038c8a9a5SSteve French if (file_info->CreationTime) 564138c8a9a5SSteve French fp->create_time = le64_to_cpu(file_info->CreationTime); 564238c8a9a5SSteve French 564338c8a9a5SSteve French if (file_info->LastAccessTime) { 564438c8a9a5SSteve French attrs.ia_atime = ksmbd_NTtimeToUnix(file_info->LastAccessTime); 564538c8a9a5SSteve French attrs.ia_valid |= (ATTR_ATIME | ATTR_ATIME_SET); 564638c8a9a5SSteve French } 564738c8a9a5SSteve French 564838c8a9a5SSteve French attrs.ia_valid |= ATTR_CTIME; 564938c8a9a5SSteve French if (file_info->ChangeTime) 565038c8a9a5SSteve French attrs.ia_ctime = ksmbd_NTtimeToUnix(file_info->ChangeTime); 565138c8a9a5SSteve French else 565238c8a9a5SSteve French attrs.ia_ctime = inode->i_ctime; 565338c8a9a5SSteve French 565438c8a9a5SSteve French if (file_info->LastWriteTime) { 565538c8a9a5SSteve French attrs.ia_mtime = ksmbd_NTtimeToUnix(file_info->LastWriteTime); 565638c8a9a5SSteve French attrs.ia_valid |= (ATTR_MTIME | ATTR_MTIME_SET); 565738c8a9a5SSteve French } 565838c8a9a5SSteve French 565938c8a9a5SSteve French if (file_info->Attributes) { 566038c8a9a5SSteve French if (!S_ISDIR(inode->i_mode) && 566138c8a9a5SSteve French file_info->Attributes & FILE_ATTRIBUTE_DIRECTORY_LE) { 566238c8a9a5SSteve French pr_err("can't change a file to a directory\n"); 566338c8a9a5SSteve French return -EINVAL; 566438c8a9a5SSteve French } 566538c8a9a5SSteve French 566638c8a9a5SSteve French if (!(S_ISDIR(inode->i_mode) && file_info->Attributes == FILE_ATTRIBUTE_NORMAL_LE)) 566738c8a9a5SSteve French fp->f_ci->m_fattr = file_info->Attributes | 566838c8a9a5SSteve French (fp->f_ci->m_fattr & FILE_ATTRIBUTE_DIRECTORY_LE); 566938c8a9a5SSteve French } 567038c8a9a5SSteve French 567138c8a9a5SSteve French if (test_share_config_flag(share, KSMBD_SHARE_FLAG_STORE_DOS_ATTRS) && 567238c8a9a5SSteve French (file_info->CreationTime || file_info->Attributes)) { 567338c8a9a5SSteve French struct xattr_dos_attrib da = {0}; 567438c8a9a5SSteve French 567538c8a9a5SSteve French da.version = 4; 567638c8a9a5SSteve French da.itime = fp->itime; 567738c8a9a5SSteve French da.create_time = fp->create_time; 567838c8a9a5SSteve French da.attr = le32_to_cpu(fp->f_ci->m_fattr); 567938c8a9a5SSteve French da.flags = XATTR_DOSINFO_ATTRIB | XATTR_DOSINFO_CREATE_TIME | 568038c8a9a5SSteve French XATTR_DOSINFO_ITIME; 568138c8a9a5SSteve French 568240b268d3SNamjae Jeon rc = ksmbd_vfs_set_dos_attrib_xattr(idmap, &filp->f_path, &da); 568338c8a9a5SSteve French if (rc) 568438c8a9a5SSteve French ksmbd_debug(SMB, 568538c8a9a5SSteve French "failed to restore file attribute in EA\n"); 568638c8a9a5SSteve French rc = 0; 568738c8a9a5SSteve French } 568838c8a9a5SSteve French 568938c8a9a5SSteve French if (attrs.ia_valid) { 569038c8a9a5SSteve French struct dentry *dentry = filp->f_path.dentry; 569138c8a9a5SSteve French struct inode *inode = d_inode(dentry); 569238c8a9a5SSteve French 569338c8a9a5SSteve French if (IS_IMMUTABLE(inode) || IS_APPEND(inode)) 569438c8a9a5SSteve French return -EACCES; 569538c8a9a5SSteve French 569638c8a9a5SSteve French inode_lock(inode); 569738c8a9a5SSteve French inode->i_ctime = attrs.ia_ctime; 569838c8a9a5SSteve French attrs.ia_valid &= ~ATTR_CTIME; 569938c8a9a5SSteve French rc = notify_change(idmap, dentry, &attrs, NULL); 570038c8a9a5SSteve French inode_unlock(inode); 570138c8a9a5SSteve French } 570238c8a9a5SSteve French return rc; 570338c8a9a5SSteve French } 570438c8a9a5SSteve French 570538c8a9a5SSteve French static int set_file_allocation_info(struct ksmbd_work *work, 570638c8a9a5SSteve French struct ksmbd_file *fp, 570738c8a9a5SSteve French struct smb2_file_alloc_info *file_alloc_info) 570838c8a9a5SSteve French { 570938c8a9a5SSteve French /* 571038c8a9a5SSteve French * TODO : It's working fine only when store dos attributes 571138c8a9a5SSteve French * is not yes. need to implement a logic which works 571238c8a9a5SSteve French * properly with any smb.conf option 571338c8a9a5SSteve French */ 571438c8a9a5SSteve French 571538c8a9a5SSteve French loff_t alloc_blks; 571638c8a9a5SSteve French struct inode *inode; 571738c8a9a5SSteve French int rc; 571838c8a9a5SSteve French 571938c8a9a5SSteve French if (!(fp->daccess & FILE_WRITE_DATA_LE)) 572038c8a9a5SSteve French return -EACCES; 572138c8a9a5SSteve French 572238c8a9a5SSteve French alloc_blks = (le64_to_cpu(file_alloc_info->AllocationSize) + 511) >> 9; 572338c8a9a5SSteve French inode = file_inode(fp->filp); 572438c8a9a5SSteve French 572538c8a9a5SSteve French if (alloc_blks > inode->i_blocks) { 572638c8a9a5SSteve French smb_break_all_levII_oplock(work, fp, 1); 572738c8a9a5SSteve French rc = vfs_fallocate(fp->filp, FALLOC_FL_KEEP_SIZE, 0, 572838c8a9a5SSteve French alloc_blks * 512); 572938c8a9a5SSteve French if (rc && rc != -EOPNOTSUPP) { 573038c8a9a5SSteve French pr_err("vfs_fallocate is failed : %d\n", rc); 573138c8a9a5SSteve French return rc; 573238c8a9a5SSteve French } 573338c8a9a5SSteve French } else if (alloc_blks < inode->i_blocks) { 573438c8a9a5SSteve French loff_t size; 573538c8a9a5SSteve French 573638c8a9a5SSteve French /* 573738c8a9a5SSteve French * Allocation size could be smaller than original one 573838c8a9a5SSteve French * which means allocated blocks in file should be 573938c8a9a5SSteve French * deallocated. use truncate to cut out it, but inode 574038c8a9a5SSteve French * size is also updated with truncate offset. 574138c8a9a5SSteve French * inode size is retained by backup inode size. 574238c8a9a5SSteve French */ 574338c8a9a5SSteve French size = i_size_read(inode); 574438c8a9a5SSteve French rc = ksmbd_vfs_truncate(work, fp, alloc_blks * 512); 574538c8a9a5SSteve French if (rc) { 574638c8a9a5SSteve French pr_err("truncate failed!, err %d\n", rc); 574738c8a9a5SSteve French return rc; 574838c8a9a5SSteve French } 574938c8a9a5SSteve French if (size < alloc_blks * 512) 575038c8a9a5SSteve French i_size_write(inode, size); 575138c8a9a5SSteve French } 575238c8a9a5SSteve French return 0; 575338c8a9a5SSteve French } 575438c8a9a5SSteve French 575538c8a9a5SSteve French static int set_end_of_file_info(struct ksmbd_work *work, struct ksmbd_file *fp, 575638c8a9a5SSteve French struct smb2_file_eof_info *file_eof_info) 575738c8a9a5SSteve French { 575838c8a9a5SSteve French loff_t newsize; 575938c8a9a5SSteve French struct inode *inode; 576038c8a9a5SSteve French int rc; 576138c8a9a5SSteve French 576238c8a9a5SSteve French if (!(fp->daccess & FILE_WRITE_DATA_LE)) 576338c8a9a5SSteve French return -EACCES; 576438c8a9a5SSteve French 576538c8a9a5SSteve French newsize = le64_to_cpu(file_eof_info->EndOfFile); 576638c8a9a5SSteve French inode = file_inode(fp->filp); 576738c8a9a5SSteve French 576838c8a9a5SSteve French /* 576938c8a9a5SSteve French * If FILE_END_OF_FILE_INFORMATION of set_info_file is called 577038c8a9a5SSteve French * on FAT32 shared device, truncate execution time is too long 577138c8a9a5SSteve French * and network error could cause from windows client. because 577238c8a9a5SSteve French * truncate of some filesystem like FAT32 fill zero data in 577338c8a9a5SSteve French * truncated range. 577438c8a9a5SSteve French */ 577538c8a9a5SSteve French if (inode->i_sb->s_magic != MSDOS_SUPER_MAGIC) { 577638c8a9a5SSteve French ksmbd_debug(SMB, "truncated to newsize %lld\n", newsize); 577738c8a9a5SSteve French rc = ksmbd_vfs_truncate(work, fp, newsize); 577838c8a9a5SSteve French if (rc) { 577938c8a9a5SSteve French ksmbd_debug(SMB, "truncate failed!, err %d\n", rc); 578038c8a9a5SSteve French if (rc != -EAGAIN) 578138c8a9a5SSteve French rc = -EBADF; 578238c8a9a5SSteve French return rc; 578338c8a9a5SSteve French } 578438c8a9a5SSteve French } 578538c8a9a5SSteve French return 0; 578638c8a9a5SSteve French } 578738c8a9a5SSteve French 578838c8a9a5SSteve French static int set_rename_info(struct ksmbd_work *work, struct ksmbd_file *fp, 578938c8a9a5SSteve French struct smb2_file_rename_info *rename_info, 579038c8a9a5SSteve French unsigned int buf_len) 579138c8a9a5SSteve French { 579238c8a9a5SSteve French if (!(fp->daccess & FILE_DELETE_LE)) { 579338c8a9a5SSteve French pr_err("no right to delete : 0x%x\n", fp->daccess); 579438c8a9a5SSteve French return -EACCES; 579538c8a9a5SSteve French } 579638c8a9a5SSteve French 579738c8a9a5SSteve French if (buf_len < (u64)sizeof(struct smb2_file_rename_info) + 579838c8a9a5SSteve French le32_to_cpu(rename_info->FileNameLength)) 579938c8a9a5SSteve French return -EINVAL; 580038c8a9a5SSteve French 580138c8a9a5SSteve French if (!le32_to_cpu(rename_info->FileNameLength)) 580238c8a9a5SSteve French return -EINVAL; 580338c8a9a5SSteve French 580438c8a9a5SSteve French return smb2_rename(work, fp, rename_info, work->conn->local_nls); 580538c8a9a5SSteve French } 580638c8a9a5SSteve French 580738c8a9a5SSteve French static int set_file_disposition_info(struct ksmbd_file *fp, 580838c8a9a5SSteve French struct smb2_file_disposition_info *file_info) 580938c8a9a5SSteve French { 581038c8a9a5SSteve French struct inode *inode; 581138c8a9a5SSteve French 581238c8a9a5SSteve French if (!(fp->daccess & FILE_DELETE_LE)) { 581338c8a9a5SSteve French pr_err("no right to delete : 0x%x\n", fp->daccess); 581438c8a9a5SSteve French return -EACCES; 581538c8a9a5SSteve French } 581638c8a9a5SSteve French 581738c8a9a5SSteve French inode = file_inode(fp->filp); 581838c8a9a5SSteve French if (file_info->DeletePending) { 581938c8a9a5SSteve French if (S_ISDIR(inode->i_mode) && 582038c8a9a5SSteve French ksmbd_vfs_empty_dir(fp) == -ENOTEMPTY) 582138c8a9a5SSteve French return -EBUSY; 582238c8a9a5SSteve French ksmbd_set_inode_pending_delete(fp); 582338c8a9a5SSteve French } else { 582438c8a9a5SSteve French ksmbd_clear_inode_pending_delete(fp); 582538c8a9a5SSteve French } 582638c8a9a5SSteve French return 0; 582738c8a9a5SSteve French } 582838c8a9a5SSteve French 582938c8a9a5SSteve French static int set_file_position_info(struct ksmbd_file *fp, 583038c8a9a5SSteve French struct smb2_file_pos_info *file_info) 583138c8a9a5SSteve French { 583238c8a9a5SSteve French loff_t current_byte_offset; 583338c8a9a5SSteve French unsigned long sector_size; 583438c8a9a5SSteve French struct inode *inode; 583538c8a9a5SSteve French 583638c8a9a5SSteve French inode = file_inode(fp->filp); 583738c8a9a5SSteve French current_byte_offset = le64_to_cpu(file_info->CurrentByteOffset); 583838c8a9a5SSteve French sector_size = inode->i_sb->s_blocksize; 583938c8a9a5SSteve French 584038c8a9a5SSteve French if (current_byte_offset < 0 || 584138c8a9a5SSteve French (fp->coption == FILE_NO_INTERMEDIATE_BUFFERING_LE && 584238c8a9a5SSteve French current_byte_offset & (sector_size - 1))) { 584338c8a9a5SSteve French pr_err("CurrentByteOffset is not valid : %llu\n", 584438c8a9a5SSteve French current_byte_offset); 584538c8a9a5SSteve French return -EINVAL; 584638c8a9a5SSteve French } 584738c8a9a5SSteve French 584838c8a9a5SSteve French fp->filp->f_pos = current_byte_offset; 584938c8a9a5SSteve French return 0; 585038c8a9a5SSteve French } 585138c8a9a5SSteve French 585238c8a9a5SSteve French static int set_file_mode_info(struct ksmbd_file *fp, 585338c8a9a5SSteve French struct smb2_file_mode_info *file_info) 585438c8a9a5SSteve French { 585538c8a9a5SSteve French __le32 mode; 585638c8a9a5SSteve French 585738c8a9a5SSteve French mode = file_info->Mode; 585838c8a9a5SSteve French 585938c8a9a5SSteve French if ((mode & ~FILE_MODE_INFO_MASK)) { 586038c8a9a5SSteve French pr_err("Mode is not valid : 0x%x\n", le32_to_cpu(mode)); 586138c8a9a5SSteve French return -EINVAL; 586238c8a9a5SSteve French } 586338c8a9a5SSteve French 586438c8a9a5SSteve French /* 586538c8a9a5SSteve French * TODO : need to implement consideration for 586638c8a9a5SSteve French * FILE_SYNCHRONOUS_IO_ALERT and FILE_SYNCHRONOUS_IO_NONALERT 586738c8a9a5SSteve French */ 586838c8a9a5SSteve French ksmbd_vfs_set_fadvise(fp->filp, mode); 586938c8a9a5SSteve French fp->coption = mode; 587038c8a9a5SSteve French return 0; 587138c8a9a5SSteve French } 587238c8a9a5SSteve French 587338c8a9a5SSteve French /** 587438c8a9a5SSteve French * smb2_set_info_file() - handler for smb2 set info command 587538c8a9a5SSteve French * @work: smb work containing set info command buffer 587638c8a9a5SSteve French * @fp: ksmbd_file pointer 587738c8a9a5SSteve French * @req: request buffer pointer 587838c8a9a5SSteve French * @share: ksmbd_share_config pointer 587938c8a9a5SSteve French * 588038c8a9a5SSteve French * Return: 0 on success, otherwise error 588138c8a9a5SSteve French * TODO: need to implement an error handling for STATUS_INFO_LENGTH_MISMATCH 588238c8a9a5SSteve French */ 588338c8a9a5SSteve French static int smb2_set_info_file(struct ksmbd_work *work, struct ksmbd_file *fp, 588438c8a9a5SSteve French struct smb2_set_info_req *req, 588538c8a9a5SSteve French struct ksmbd_share_config *share) 588638c8a9a5SSteve French { 588738c8a9a5SSteve French unsigned int buf_len = le32_to_cpu(req->BufferLength); 588838c8a9a5SSteve French 588938c8a9a5SSteve French switch (req->FileInfoClass) { 589038c8a9a5SSteve French case FILE_BASIC_INFORMATION: 589138c8a9a5SSteve French { 589238c8a9a5SSteve French if (buf_len < sizeof(struct smb2_file_basic_info)) 589338c8a9a5SSteve French return -EINVAL; 589438c8a9a5SSteve French 589538c8a9a5SSteve French return set_file_basic_info(fp, (struct smb2_file_basic_info *)req->Buffer, share); 589638c8a9a5SSteve French } 589738c8a9a5SSteve French case FILE_ALLOCATION_INFORMATION: 589838c8a9a5SSteve French { 589938c8a9a5SSteve French if (buf_len < sizeof(struct smb2_file_alloc_info)) 590038c8a9a5SSteve French return -EINVAL; 590138c8a9a5SSteve French 590238c8a9a5SSteve French return set_file_allocation_info(work, fp, 590338c8a9a5SSteve French (struct smb2_file_alloc_info *)req->Buffer); 590438c8a9a5SSteve French } 590538c8a9a5SSteve French case FILE_END_OF_FILE_INFORMATION: 590638c8a9a5SSteve French { 590738c8a9a5SSteve French if (buf_len < sizeof(struct smb2_file_eof_info)) 590838c8a9a5SSteve French return -EINVAL; 590938c8a9a5SSteve French 591038c8a9a5SSteve French return set_end_of_file_info(work, fp, 591138c8a9a5SSteve French (struct smb2_file_eof_info *)req->Buffer); 591238c8a9a5SSteve French } 591338c8a9a5SSteve French case FILE_RENAME_INFORMATION: 591438c8a9a5SSteve French { 591538c8a9a5SSteve French if (!test_tree_conn_flag(work->tcon, KSMBD_TREE_CONN_FLAG_WRITABLE)) { 591638c8a9a5SSteve French ksmbd_debug(SMB, 591738c8a9a5SSteve French "User does not have write permission\n"); 591838c8a9a5SSteve French return -EACCES; 591938c8a9a5SSteve French } 592038c8a9a5SSteve French 592138c8a9a5SSteve French if (buf_len < sizeof(struct smb2_file_rename_info)) 592238c8a9a5SSteve French return -EINVAL; 592338c8a9a5SSteve French 592438c8a9a5SSteve French return set_rename_info(work, fp, 592538c8a9a5SSteve French (struct smb2_file_rename_info *)req->Buffer, 592638c8a9a5SSteve French buf_len); 592738c8a9a5SSteve French } 592838c8a9a5SSteve French case FILE_LINK_INFORMATION: 592938c8a9a5SSteve French { 593038c8a9a5SSteve French if (buf_len < sizeof(struct smb2_file_link_info)) 593138c8a9a5SSteve French return -EINVAL; 593238c8a9a5SSteve French 593338c8a9a5SSteve French return smb2_create_link(work, work->tcon->share_conf, 593438c8a9a5SSteve French (struct smb2_file_link_info *)req->Buffer, 593538c8a9a5SSteve French buf_len, fp->filp, 593638c8a9a5SSteve French work->conn->local_nls); 593738c8a9a5SSteve French } 593838c8a9a5SSteve French case FILE_DISPOSITION_INFORMATION: 593938c8a9a5SSteve French { 594038c8a9a5SSteve French if (!test_tree_conn_flag(work->tcon, KSMBD_TREE_CONN_FLAG_WRITABLE)) { 594138c8a9a5SSteve French ksmbd_debug(SMB, 594238c8a9a5SSteve French "User does not have write permission\n"); 594338c8a9a5SSteve French return -EACCES; 594438c8a9a5SSteve French } 594538c8a9a5SSteve French 594638c8a9a5SSteve French if (buf_len < sizeof(struct smb2_file_disposition_info)) 594738c8a9a5SSteve French return -EINVAL; 594838c8a9a5SSteve French 594938c8a9a5SSteve French return set_file_disposition_info(fp, 595038c8a9a5SSteve French (struct smb2_file_disposition_info *)req->Buffer); 595138c8a9a5SSteve French } 595238c8a9a5SSteve French case FILE_FULL_EA_INFORMATION: 595338c8a9a5SSteve French { 595438c8a9a5SSteve French if (!(fp->daccess & FILE_WRITE_EA_LE)) { 595538c8a9a5SSteve French pr_err("Not permitted to write ext attr: 0x%x\n", 595638c8a9a5SSteve French fp->daccess); 595738c8a9a5SSteve French return -EACCES; 595838c8a9a5SSteve French } 595938c8a9a5SSteve French 596038c8a9a5SSteve French if (buf_len < sizeof(struct smb2_ea_info)) 596138c8a9a5SSteve French return -EINVAL; 596238c8a9a5SSteve French 596338c8a9a5SSteve French return smb2_set_ea((struct smb2_ea_info *)req->Buffer, 596438c8a9a5SSteve French buf_len, &fp->filp->f_path); 596538c8a9a5SSteve French } 596638c8a9a5SSteve French case FILE_POSITION_INFORMATION: 596738c8a9a5SSteve French { 596838c8a9a5SSteve French if (buf_len < sizeof(struct smb2_file_pos_info)) 596938c8a9a5SSteve French return -EINVAL; 597038c8a9a5SSteve French 597138c8a9a5SSteve French return set_file_position_info(fp, (struct smb2_file_pos_info *)req->Buffer); 597238c8a9a5SSteve French } 597338c8a9a5SSteve French case FILE_MODE_INFORMATION: 597438c8a9a5SSteve French { 597538c8a9a5SSteve French if (buf_len < sizeof(struct smb2_file_mode_info)) 597638c8a9a5SSteve French return -EINVAL; 597738c8a9a5SSteve French 597838c8a9a5SSteve French return set_file_mode_info(fp, (struct smb2_file_mode_info *)req->Buffer); 597938c8a9a5SSteve French } 598038c8a9a5SSteve French } 598138c8a9a5SSteve French 598238c8a9a5SSteve French pr_err("Unimplemented Fileinfoclass :%d\n", req->FileInfoClass); 598338c8a9a5SSteve French return -EOPNOTSUPP; 598438c8a9a5SSteve French } 598538c8a9a5SSteve French 598638c8a9a5SSteve French static int smb2_set_info_sec(struct ksmbd_file *fp, int addition_info, 598738c8a9a5SSteve French char *buffer, int buf_len) 598838c8a9a5SSteve French { 598938c8a9a5SSteve French struct smb_ntsd *pntsd = (struct smb_ntsd *)buffer; 599038c8a9a5SSteve French 599138c8a9a5SSteve French fp->saccess |= FILE_SHARE_DELETE_LE; 599238c8a9a5SSteve French 599338c8a9a5SSteve French return set_info_sec(fp->conn, fp->tcon, &fp->filp->f_path, pntsd, 599438c8a9a5SSteve French buf_len, false); 599538c8a9a5SSteve French } 599638c8a9a5SSteve French 599738c8a9a5SSteve French /** 599838c8a9a5SSteve French * smb2_set_info() - handler for smb2 set info command handler 599938c8a9a5SSteve French * @work: smb work containing set info request buffer 600038c8a9a5SSteve French * 600138c8a9a5SSteve French * Return: 0 on success, otherwise error 600238c8a9a5SSteve French */ 600338c8a9a5SSteve French int smb2_set_info(struct ksmbd_work *work) 600438c8a9a5SSteve French { 600538c8a9a5SSteve French struct smb2_set_info_req *req; 600638c8a9a5SSteve French struct smb2_set_info_rsp *rsp; 600738c8a9a5SSteve French struct ksmbd_file *fp; 600838c8a9a5SSteve French int rc = 0; 600938c8a9a5SSteve French unsigned int id = KSMBD_NO_FID, pid = KSMBD_NO_FID; 601038c8a9a5SSteve French 601138c8a9a5SSteve French ksmbd_debug(SMB, "Received set info request\n"); 601238c8a9a5SSteve French 601338c8a9a5SSteve French if (work->next_smb2_rcv_hdr_off) { 601438c8a9a5SSteve French req = ksmbd_req_buf_next(work); 601538c8a9a5SSteve French rsp = ksmbd_resp_buf_next(work); 601638c8a9a5SSteve French if (!has_file_id(req->VolatileFileId)) { 601738c8a9a5SSteve French ksmbd_debug(SMB, "Compound request set FID = %llu\n", 601838c8a9a5SSteve French work->compound_fid); 601938c8a9a5SSteve French id = work->compound_fid; 602038c8a9a5SSteve French pid = work->compound_pfid; 602138c8a9a5SSteve French } 602238c8a9a5SSteve French } else { 602338c8a9a5SSteve French req = smb2_get_msg(work->request_buf); 602438c8a9a5SSteve French rsp = smb2_get_msg(work->response_buf); 602538c8a9a5SSteve French } 602638c8a9a5SSteve French 602738c8a9a5SSteve French if (!has_file_id(id)) { 602838c8a9a5SSteve French id = req->VolatileFileId; 602938c8a9a5SSteve French pid = req->PersistentFileId; 603038c8a9a5SSteve French } 603138c8a9a5SSteve French 603238c8a9a5SSteve French fp = ksmbd_lookup_fd_slow(work, id, pid); 603338c8a9a5SSteve French if (!fp) { 603438c8a9a5SSteve French ksmbd_debug(SMB, "Invalid id for close: %u\n", id); 603538c8a9a5SSteve French rc = -ENOENT; 603638c8a9a5SSteve French goto err_out; 603738c8a9a5SSteve French } 603838c8a9a5SSteve French 603938c8a9a5SSteve French switch (req->InfoType) { 604038c8a9a5SSteve French case SMB2_O_INFO_FILE: 604138c8a9a5SSteve French ksmbd_debug(SMB, "GOT SMB2_O_INFO_FILE\n"); 604238c8a9a5SSteve French rc = smb2_set_info_file(work, fp, req, work->tcon->share_conf); 604338c8a9a5SSteve French break; 604438c8a9a5SSteve French case SMB2_O_INFO_SECURITY: 604538c8a9a5SSteve French ksmbd_debug(SMB, "GOT SMB2_O_INFO_SECURITY\n"); 604638c8a9a5SSteve French if (ksmbd_override_fsids(work)) { 604738c8a9a5SSteve French rc = -ENOMEM; 604838c8a9a5SSteve French goto err_out; 604938c8a9a5SSteve French } 605038c8a9a5SSteve French rc = smb2_set_info_sec(fp, 605138c8a9a5SSteve French le32_to_cpu(req->AdditionalInformation), 605238c8a9a5SSteve French req->Buffer, 605338c8a9a5SSteve French le32_to_cpu(req->BufferLength)); 605438c8a9a5SSteve French ksmbd_revert_fsids(work); 605538c8a9a5SSteve French break; 605638c8a9a5SSteve French default: 605738c8a9a5SSteve French rc = -EOPNOTSUPP; 605838c8a9a5SSteve French } 605938c8a9a5SSteve French 606038c8a9a5SSteve French if (rc < 0) 606138c8a9a5SSteve French goto err_out; 606238c8a9a5SSteve French 606338c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(2); 606438c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 2); 606538c8a9a5SSteve French ksmbd_fd_put(work, fp); 606638c8a9a5SSteve French return 0; 606738c8a9a5SSteve French 606838c8a9a5SSteve French err_out: 606938c8a9a5SSteve French if (rc == -EACCES || rc == -EPERM || rc == -EXDEV) 607038c8a9a5SSteve French rsp->hdr.Status = STATUS_ACCESS_DENIED; 607138c8a9a5SSteve French else if (rc == -EINVAL) 607238c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 607338c8a9a5SSteve French else if (rc == -ESHARE) 607438c8a9a5SSteve French rsp->hdr.Status = STATUS_SHARING_VIOLATION; 607538c8a9a5SSteve French else if (rc == -ENOENT) 607638c8a9a5SSteve French rsp->hdr.Status = STATUS_OBJECT_NAME_INVALID; 607738c8a9a5SSteve French else if (rc == -EBUSY || rc == -ENOTEMPTY) 607838c8a9a5SSteve French rsp->hdr.Status = STATUS_DIRECTORY_NOT_EMPTY; 607938c8a9a5SSteve French else if (rc == -EAGAIN) 608038c8a9a5SSteve French rsp->hdr.Status = STATUS_FILE_LOCK_CONFLICT; 608138c8a9a5SSteve French else if (rc == -EBADF || rc == -ESTALE) 608238c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_HANDLE; 608338c8a9a5SSteve French else if (rc == -EEXIST) 608438c8a9a5SSteve French rsp->hdr.Status = STATUS_OBJECT_NAME_COLLISION; 608538c8a9a5SSteve French else if (rsp->hdr.Status == 0 || rc == -EOPNOTSUPP) 608638c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_INFO_CLASS; 608738c8a9a5SSteve French smb2_set_err_rsp(work); 608838c8a9a5SSteve French ksmbd_fd_put(work, fp); 608938c8a9a5SSteve French ksmbd_debug(SMB, "error while processing smb2 query rc = %d\n", rc); 609038c8a9a5SSteve French return rc; 609138c8a9a5SSteve French } 609238c8a9a5SSteve French 609338c8a9a5SSteve French /** 609438c8a9a5SSteve French * smb2_read_pipe() - handler for smb2 read from IPC pipe 609538c8a9a5SSteve French * @work: smb work containing read IPC pipe command buffer 609638c8a9a5SSteve French * 609738c8a9a5SSteve French * Return: 0 on success, otherwise error 609838c8a9a5SSteve French */ 609938c8a9a5SSteve French static noinline int smb2_read_pipe(struct ksmbd_work *work) 610038c8a9a5SSteve French { 610138c8a9a5SSteve French int nbytes = 0, err; 610238c8a9a5SSteve French u64 id; 610338c8a9a5SSteve French struct ksmbd_rpc_command *rpc_resp; 61047b7d709eSNamjae Jeon struct smb2_read_req *req; 61057b7d709eSNamjae Jeon struct smb2_read_rsp *rsp; 61067b7d709eSNamjae Jeon 61077b7d709eSNamjae Jeon WORK_BUFFERS(work, req, rsp); 610838c8a9a5SSteve French 610938c8a9a5SSteve French id = req->VolatileFileId; 611038c8a9a5SSteve French 611138c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 16); 611238c8a9a5SSteve French rpc_resp = ksmbd_rpc_read(work->sess, id); 611338c8a9a5SSteve French if (rpc_resp) { 611438c8a9a5SSteve French if (rpc_resp->flags != KSMBD_RPC_OK) { 611538c8a9a5SSteve French err = -EINVAL; 611638c8a9a5SSteve French goto out; 611738c8a9a5SSteve French } 611838c8a9a5SSteve French 611938c8a9a5SSteve French work->aux_payload_buf = 612081a94b27SNamjae Jeon kvmalloc(rpc_resp->payload_sz, GFP_KERNEL); 612138c8a9a5SSteve French if (!work->aux_payload_buf) { 612238c8a9a5SSteve French err = -ENOMEM; 612338c8a9a5SSteve French goto out; 612438c8a9a5SSteve French } 612538c8a9a5SSteve French 612638c8a9a5SSteve French memcpy(work->aux_payload_buf, rpc_resp->payload, 612738c8a9a5SSteve French rpc_resp->payload_sz); 612838c8a9a5SSteve French 612938c8a9a5SSteve French nbytes = rpc_resp->payload_sz; 613038c8a9a5SSteve French work->resp_hdr_sz = get_rfc1002_len(work->response_buf) + 4; 613138c8a9a5SSteve French work->aux_payload_sz = nbytes; 613238c8a9a5SSteve French kvfree(rpc_resp); 613338c8a9a5SSteve French } 613438c8a9a5SSteve French 613538c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(17); 613638c8a9a5SSteve French rsp->DataOffset = 80; 613738c8a9a5SSteve French rsp->Reserved = 0; 613838c8a9a5SSteve French rsp->DataLength = cpu_to_le32(nbytes); 613938c8a9a5SSteve French rsp->DataRemaining = 0; 614038c8a9a5SSteve French rsp->Flags = 0; 614138c8a9a5SSteve French inc_rfc1001_len(work->response_buf, nbytes); 614238c8a9a5SSteve French return 0; 614338c8a9a5SSteve French 614438c8a9a5SSteve French out: 614538c8a9a5SSteve French rsp->hdr.Status = STATUS_UNEXPECTED_IO_ERROR; 614638c8a9a5SSteve French smb2_set_err_rsp(work); 614738c8a9a5SSteve French kvfree(rpc_resp); 614838c8a9a5SSteve French return err; 614938c8a9a5SSteve French } 615038c8a9a5SSteve French 615138c8a9a5SSteve French static int smb2_set_remote_key_for_rdma(struct ksmbd_work *work, 615238c8a9a5SSteve French struct smb2_buffer_desc_v1 *desc, 615338c8a9a5SSteve French __le32 Channel, 615438c8a9a5SSteve French __le16 ChannelInfoLength) 615538c8a9a5SSteve French { 615638c8a9a5SSteve French unsigned int i, ch_count; 615738c8a9a5SSteve French 615838c8a9a5SSteve French if (work->conn->dialect == SMB30_PROT_ID && 615938c8a9a5SSteve French Channel != SMB2_CHANNEL_RDMA_V1) 616038c8a9a5SSteve French return -EINVAL; 616138c8a9a5SSteve French 616238c8a9a5SSteve French ch_count = le16_to_cpu(ChannelInfoLength) / sizeof(*desc); 616338c8a9a5SSteve French if (ksmbd_debug_types & KSMBD_DEBUG_RDMA) { 616438c8a9a5SSteve French for (i = 0; i < ch_count; i++) { 616538c8a9a5SSteve French pr_info("RDMA r/w request %#x: token %#x, length %#x\n", 616638c8a9a5SSteve French i, 616738c8a9a5SSteve French le32_to_cpu(desc[i].token), 616838c8a9a5SSteve French le32_to_cpu(desc[i].length)); 616938c8a9a5SSteve French } 617038c8a9a5SSteve French } 617138c8a9a5SSteve French if (!ch_count) 617238c8a9a5SSteve French return -EINVAL; 617338c8a9a5SSteve French 617438c8a9a5SSteve French work->need_invalidate_rkey = 617538c8a9a5SSteve French (Channel == SMB2_CHANNEL_RDMA_V1_INVALIDATE); 617638c8a9a5SSteve French if (Channel == SMB2_CHANNEL_RDMA_V1_INVALIDATE) 617738c8a9a5SSteve French work->remote_key = le32_to_cpu(desc->token); 617838c8a9a5SSteve French return 0; 617938c8a9a5SSteve French } 618038c8a9a5SSteve French 618138c8a9a5SSteve French static ssize_t smb2_read_rdma_channel(struct ksmbd_work *work, 618238c8a9a5SSteve French struct smb2_read_req *req, void *data_buf, 618338c8a9a5SSteve French size_t length) 618438c8a9a5SSteve French { 618538c8a9a5SSteve French int err; 618638c8a9a5SSteve French 618738c8a9a5SSteve French err = ksmbd_conn_rdma_write(work->conn, data_buf, length, 618838c8a9a5SSteve French (struct smb2_buffer_desc_v1 *) 618938c8a9a5SSteve French ((char *)req + le16_to_cpu(req->ReadChannelInfoOffset)), 619038c8a9a5SSteve French le16_to_cpu(req->ReadChannelInfoLength)); 619138c8a9a5SSteve French if (err) 619238c8a9a5SSteve French return err; 619338c8a9a5SSteve French 619438c8a9a5SSteve French return length; 619538c8a9a5SSteve French } 619638c8a9a5SSteve French 619738c8a9a5SSteve French /** 619838c8a9a5SSteve French * smb2_read() - handler for smb2 read from file 619938c8a9a5SSteve French * @work: smb work containing read command buffer 620038c8a9a5SSteve French * 620138c8a9a5SSteve French * Return: 0 on success, otherwise error 620238c8a9a5SSteve French */ 620338c8a9a5SSteve French int smb2_read(struct ksmbd_work *work) 620438c8a9a5SSteve French { 620538c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 620638c8a9a5SSteve French struct smb2_read_req *req; 620738c8a9a5SSteve French struct smb2_read_rsp *rsp; 620838c8a9a5SSteve French struct ksmbd_file *fp = NULL; 620938c8a9a5SSteve French loff_t offset; 621038c8a9a5SSteve French size_t length, mincount; 621138c8a9a5SSteve French ssize_t nbytes = 0, remain_bytes = 0; 621238c8a9a5SSteve French int err = 0; 621338c8a9a5SSteve French bool is_rdma_channel = false; 621438c8a9a5SSteve French unsigned int max_read_size = conn->vals->max_read_size; 621538c8a9a5SSteve French 621638c8a9a5SSteve French WORK_BUFFERS(work, req, rsp); 621738c8a9a5SSteve French 621838c8a9a5SSteve French if (test_share_config_flag(work->tcon->share_conf, 621938c8a9a5SSteve French KSMBD_SHARE_FLAG_PIPE)) { 622038c8a9a5SSteve French ksmbd_debug(SMB, "IPC pipe read request\n"); 622138c8a9a5SSteve French return smb2_read_pipe(work); 622238c8a9a5SSteve French } 622338c8a9a5SSteve French 622438c8a9a5SSteve French if (req->Channel == SMB2_CHANNEL_RDMA_V1_INVALIDATE || 622538c8a9a5SSteve French req->Channel == SMB2_CHANNEL_RDMA_V1) { 622638c8a9a5SSteve French is_rdma_channel = true; 622738c8a9a5SSteve French max_read_size = get_smbd_max_read_write_size(); 622838c8a9a5SSteve French } 622938c8a9a5SSteve French 623038c8a9a5SSteve French if (is_rdma_channel == true) { 623138c8a9a5SSteve French unsigned int ch_offset = le16_to_cpu(req->ReadChannelInfoOffset); 623238c8a9a5SSteve French 623338c8a9a5SSteve French if (ch_offset < offsetof(struct smb2_read_req, Buffer)) { 623438c8a9a5SSteve French err = -EINVAL; 623538c8a9a5SSteve French goto out; 623638c8a9a5SSteve French } 623738c8a9a5SSteve French err = smb2_set_remote_key_for_rdma(work, 623838c8a9a5SSteve French (struct smb2_buffer_desc_v1 *) 623938c8a9a5SSteve French ((char *)req + ch_offset), 624038c8a9a5SSteve French req->Channel, 624138c8a9a5SSteve French req->ReadChannelInfoLength); 624238c8a9a5SSteve French if (err) 624338c8a9a5SSteve French goto out; 624438c8a9a5SSteve French } 624538c8a9a5SSteve French 624638c8a9a5SSteve French fp = ksmbd_lookup_fd_slow(work, req->VolatileFileId, req->PersistentFileId); 624738c8a9a5SSteve French if (!fp) { 624838c8a9a5SSteve French err = -ENOENT; 624938c8a9a5SSteve French goto out; 625038c8a9a5SSteve French } 625138c8a9a5SSteve French 625238c8a9a5SSteve French if (!(fp->daccess & (FILE_READ_DATA_LE | FILE_READ_ATTRIBUTES_LE))) { 625338c8a9a5SSteve French pr_err("Not permitted to read : 0x%x\n", fp->daccess); 625438c8a9a5SSteve French err = -EACCES; 625538c8a9a5SSteve French goto out; 625638c8a9a5SSteve French } 625738c8a9a5SSteve French 625838c8a9a5SSteve French offset = le64_to_cpu(req->Offset); 625938c8a9a5SSteve French length = le32_to_cpu(req->Length); 626038c8a9a5SSteve French mincount = le32_to_cpu(req->MinimumCount); 626138c8a9a5SSteve French 626238c8a9a5SSteve French if (length > max_read_size) { 626338c8a9a5SSteve French ksmbd_debug(SMB, "limiting read size to max size(%u)\n", 626438c8a9a5SSteve French max_read_size); 626538c8a9a5SSteve French err = -EINVAL; 626638c8a9a5SSteve French goto out; 626738c8a9a5SSteve French } 626838c8a9a5SSteve French 626938c8a9a5SSteve French ksmbd_debug(SMB, "filename %pD, offset %lld, len %zu\n", 627038c8a9a5SSteve French fp->filp, offset, length); 627138c8a9a5SSteve French 627281a94b27SNamjae Jeon work->aux_payload_buf = kvzalloc(length, GFP_KERNEL); 627338c8a9a5SSteve French if (!work->aux_payload_buf) { 627438c8a9a5SSteve French err = -ENOMEM; 627538c8a9a5SSteve French goto out; 627638c8a9a5SSteve French } 627738c8a9a5SSteve French 627838c8a9a5SSteve French nbytes = ksmbd_vfs_read(work, fp, length, &offset); 627938c8a9a5SSteve French if (nbytes < 0) { 628038c8a9a5SSteve French err = nbytes; 628138c8a9a5SSteve French goto out; 628238c8a9a5SSteve French } 628338c8a9a5SSteve French 628438c8a9a5SSteve French if ((nbytes == 0 && length != 0) || nbytes < mincount) { 628538c8a9a5SSteve French kvfree(work->aux_payload_buf); 628638c8a9a5SSteve French work->aux_payload_buf = NULL; 628738c8a9a5SSteve French rsp->hdr.Status = STATUS_END_OF_FILE; 628838c8a9a5SSteve French smb2_set_err_rsp(work); 628938c8a9a5SSteve French ksmbd_fd_put(work, fp); 629038c8a9a5SSteve French return 0; 629138c8a9a5SSteve French } 629238c8a9a5SSteve French 629338c8a9a5SSteve French ksmbd_debug(SMB, "nbytes %zu, offset %lld mincount %zu\n", 629438c8a9a5SSteve French nbytes, offset, mincount); 629538c8a9a5SSteve French 629638c8a9a5SSteve French if (is_rdma_channel == true) { 629738c8a9a5SSteve French /* write data to the client using rdma channel */ 629838c8a9a5SSteve French remain_bytes = smb2_read_rdma_channel(work, req, 629938c8a9a5SSteve French work->aux_payload_buf, 630038c8a9a5SSteve French nbytes); 630138c8a9a5SSteve French kvfree(work->aux_payload_buf); 630238c8a9a5SSteve French work->aux_payload_buf = NULL; 630338c8a9a5SSteve French 630438c8a9a5SSteve French nbytes = 0; 630538c8a9a5SSteve French if (remain_bytes < 0) { 630638c8a9a5SSteve French err = (int)remain_bytes; 630738c8a9a5SSteve French goto out; 630838c8a9a5SSteve French } 630938c8a9a5SSteve French } 631038c8a9a5SSteve French 631138c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(17); 631238c8a9a5SSteve French rsp->DataOffset = 80; 631338c8a9a5SSteve French rsp->Reserved = 0; 631438c8a9a5SSteve French rsp->DataLength = cpu_to_le32(nbytes); 631538c8a9a5SSteve French rsp->DataRemaining = cpu_to_le32(remain_bytes); 631638c8a9a5SSteve French rsp->Flags = 0; 631738c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 16); 631838c8a9a5SSteve French work->resp_hdr_sz = get_rfc1002_len(work->response_buf) + 4; 631938c8a9a5SSteve French work->aux_payload_sz = nbytes; 632038c8a9a5SSteve French inc_rfc1001_len(work->response_buf, nbytes); 632138c8a9a5SSteve French ksmbd_fd_put(work, fp); 632238c8a9a5SSteve French return 0; 632338c8a9a5SSteve French 632438c8a9a5SSteve French out: 632538c8a9a5SSteve French if (err) { 632638c8a9a5SSteve French if (err == -EISDIR) 632738c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_DEVICE_REQUEST; 632838c8a9a5SSteve French else if (err == -EAGAIN) 632938c8a9a5SSteve French rsp->hdr.Status = STATUS_FILE_LOCK_CONFLICT; 633038c8a9a5SSteve French else if (err == -ENOENT) 633138c8a9a5SSteve French rsp->hdr.Status = STATUS_FILE_CLOSED; 633238c8a9a5SSteve French else if (err == -EACCES) 633338c8a9a5SSteve French rsp->hdr.Status = STATUS_ACCESS_DENIED; 633438c8a9a5SSteve French else if (err == -ESHARE) 633538c8a9a5SSteve French rsp->hdr.Status = STATUS_SHARING_VIOLATION; 633638c8a9a5SSteve French else if (err == -EINVAL) 633738c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 633838c8a9a5SSteve French else 633938c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_HANDLE; 634038c8a9a5SSteve French 634138c8a9a5SSteve French smb2_set_err_rsp(work); 634238c8a9a5SSteve French } 634338c8a9a5SSteve French ksmbd_fd_put(work, fp); 634438c8a9a5SSteve French return err; 634538c8a9a5SSteve French } 634638c8a9a5SSteve French 634738c8a9a5SSteve French /** 634838c8a9a5SSteve French * smb2_write_pipe() - handler for smb2 write on IPC pipe 634938c8a9a5SSteve French * @work: smb work containing write IPC pipe command buffer 635038c8a9a5SSteve French * 635138c8a9a5SSteve French * Return: 0 on success, otherwise error 635238c8a9a5SSteve French */ 635338c8a9a5SSteve French static noinline int smb2_write_pipe(struct ksmbd_work *work) 635438c8a9a5SSteve French { 63557b7d709eSNamjae Jeon struct smb2_write_req *req; 63567b7d709eSNamjae Jeon struct smb2_write_rsp *rsp; 635738c8a9a5SSteve French struct ksmbd_rpc_command *rpc_resp; 635838c8a9a5SSteve French u64 id = 0; 635938c8a9a5SSteve French int err = 0, ret = 0; 636038c8a9a5SSteve French char *data_buf; 636138c8a9a5SSteve French size_t length; 636238c8a9a5SSteve French 63637b7d709eSNamjae Jeon WORK_BUFFERS(work, req, rsp); 63647b7d709eSNamjae Jeon 636538c8a9a5SSteve French length = le32_to_cpu(req->Length); 636638c8a9a5SSteve French id = req->VolatileFileId; 636738c8a9a5SSteve French 636838c8a9a5SSteve French if ((u64)le16_to_cpu(req->DataOffset) + length > 636938c8a9a5SSteve French get_rfc1002_len(work->request_buf)) { 637038c8a9a5SSteve French pr_err("invalid write data offset %u, smb_len %u\n", 637138c8a9a5SSteve French le16_to_cpu(req->DataOffset), 637238c8a9a5SSteve French get_rfc1002_len(work->request_buf)); 637338c8a9a5SSteve French err = -EINVAL; 637438c8a9a5SSteve French goto out; 637538c8a9a5SSteve French } 637638c8a9a5SSteve French 637738c8a9a5SSteve French data_buf = (char *)(((char *)&req->hdr.ProtocolId) + 637838c8a9a5SSteve French le16_to_cpu(req->DataOffset)); 637938c8a9a5SSteve French 638038c8a9a5SSteve French rpc_resp = ksmbd_rpc_write(work->sess, id, data_buf, length); 638138c8a9a5SSteve French if (rpc_resp) { 638238c8a9a5SSteve French if (rpc_resp->flags == KSMBD_RPC_ENOTIMPLEMENTED) { 638338c8a9a5SSteve French rsp->hdr.Status = STATUS_NOT_SUPPORTED; 638438c8a9a5SSteve French kvfree(rpc_resp); 638538c8a9a5SSteve French smb2_set_err_rsp(work); 638638c8a9a5SSteve French return -EOPNOTSUPP; 638738c8a9a5SSteve French } 638838c8a9a5SSteve French if (rpc_resp->flags != KSMBD_RPC_OK) { 638938c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_HANDLE; 639038c8a9a5SSteve French smb2_set_err_rsp(work); 639138c8a9a5SSteve French kvfree(rpc_resp); 639238c8a9a5SSteve French return ret; 639338c8a9a5SSteve French } 639438c8a9a5SSteve French kvfree(rpc_resp); 639538c8a9a5SSteve French } 639638c8a9a5SSteve French 639738c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(17); 639838c8a9a5SSteve French rsp->DataOffset = 0; 639938c8a9a5SSteve French rsp->Reserved = 0; 640038c8a9a5SSteve French rsp->DataLength = cpu_to_le32(length); 640138c8a9a5SSteve French rsp->DataRemaining = 0; 640238c8a9a5SSteve French rsp->Reserved2 = 0; 640338c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 16); 640438c8a9a5SSteve French return 0; 640538c8a9a5SSteve French out: 640638c8a9a5SSteve French if (err) { 640738c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_HANDLE; 640838c8a9a5SSteve French smb2_set_err_rsp(work); 640938c8a9a5SSteve French } 641038c8a9a5SSteve French 641138c8a9a5SSteve French return err; 641238c8a9a5SSteve French } 641338c8a9a5SSteve French 641438c8a9a5SSteve French static ssize_t smb2_write_rdma_channel(struct ksmbd_work *work, 641538c8a9a5SSteve French struct smb2_write_req *req, 641638c8a9a5SSteve French struct ksmbd_file *fp, 641738c8a9a5SSteve French loff_t offset, size_t length, bool sync) 641838c8a9a5SSteve French { 641938c8a9a5SSteve French char *data_buf; 642038c8a9a5SSteve French int ret; 642138c8a9a5SSteve French ssize_t nbytes; 642238c8a9a5SSteve French 642381a94b27SNamjae Jeon data_buf = kvzalloc(length, GFP_KERNEL); 642438c8a9a5SSteve French if (!data_buf) 642538c8a9a5SSteve French return -ENOMEM; 642638c8a9a5SSteve French 642738c8a9a5SSteve French ret = ksmbd_conn_rdma_read(work->conn, data_buf, length, 642838c8a9a5SSteve French (struct smb2_buffer_desc_v1 *) 642938c8a9a5SSteve French ((char *)req + le16_to_cpu(req->WriteChannelInfoOffset)), 643038c8a9a5SSteve French le16_to_cpu(req->WriteChannelInfoLength)); 643138c8a9a5SSteve French if (ret < 0) { 643238c8a9a5SSteve French kvfree(data_buf); 643338c8a9a5SSteve French return ret; 643438c8a9a5SSteve French } 643538c8a9a5SSteve French 643638c8a9a5SSteve French ret = ksmbd_vfs_write(work, fp, data_buf, length, &offset, sync, &nbytes); 643738c8a9a5SSteve French kvfree(data_buf); 643838c8a9a5SSteve French if (ret < 0) 643938c8a9a5SSteve French return ret; 644038c8a9a5SSteve French 644138c8a9a5SSteve French return nbytes; 644238c8a9a5SSteve French } 644338c8a9a5SSteve French 644438c8a9a5SSteve French /** 644538c8a9a5SSteve French * smb2_write() - handler for smb2 write from file 644638c8a9a5SSteve French * @work: smb work containing write command buffer 644738c8a9a5SSteve French * 644838c8a9a5SSteve French * Return: 0 on success, otherwise error 644938c8a9a5SSteve French */ 645038c8a9a5SSteve French int smb2_write(struct ksmbd_work *work) 645138c8a9a5SSteve French { 645238c8a9a5SSteve French struct smb2_write_req *req; 645338c8a9a5SSteve French struct smb2_write_rsp *rsp; 645438c8a9a5SSteve French struct ksmbd_file *fp = NULL; 645538c8a9a5SSteve French loff_t offset; 645638c8a9a5SSteve French size_t length; 645738c8a9a5SSteve French ssize_t nbytes; 645838c8a9a5SSteve French char *data_buf; 645938c8a9a5SSteve French bool writethrough = false, is_rdma_channel = false; 646038c8a9a5SSteve French int err = 0; 646138c8a9a5SSteve French unsigned int max_write_size = work->conn->vals->max_write_size; 646238c8a9a5SSteve French 646338c8a9a5SSteve French WORK_BUFFERS(work, req, rsp); 646438c8a9a5SSteve French 646538c8a9a5SSteve French if (test_share_config_flag(work->tcon->share_conf, KSMBD_SHARE_FLAG_PIPE)) { 646638c8a9a5SSteve French ksmbd_debug(SMB, "IPC pipe write request\n"); 646738c8a9a5SSteve French return smb2_write_pipe(work); 646838c8a9a5SSteve French } 646938c8a9a5SSteve French 647038c8a9a5SSteve French offset = le64_to_cpu(req->Offset); 647138c8a9a5SSteve French length = le32_to_cpu(req->Length); 647238c8a9a5SSteve French 647338c8a9a5SSteve French if (req->Channel == SMB2_CHANNEL_RDMA_V1 || 647438c8a9a5SSteve French req->Channel == SMB2_CHANNEL_RDMA_V1_INVALIDATE) { 647538c8a9a5SSteve French is_rdma_channel = true; 647638c8a9a5SSteve French max_write_size = get_smbd_max_read_write_size(); 647738c8a9a5SSteve French length = le32_to_cpu(req->RemainingBytes); 647838c8a9a5SSteve French } 647938c8a9a5SSteve French 648038c8a9a5SSteve French if (is_rdma_channel == true) { 648138c8a9a5SSteve French unsigned int ch_offset = le16_to_cpu(req->WriteChannelInfoOffset); 648238c8a9a5SSteve French 648338c8a9a5SSteve French if (req->Length != 0 || req->DataOffset != 0 || 648438c8a9a5SSteve French ch_offset < offsetof(struct smb2_write_req, Buffer)) { 648538c8a9a5SSteve French err = -EINVAL; 648638c8a9a5SSteve French goto out; 648738c8a9a5SSteve French } 648838c8a9a5SSteve French err = smb2_set_remote_key_for_rdma(work, 648938c8a9a5SSteve French (struct smb2_buffer_desc_v1 *) 649038c8a9a5SSteve French ((char *)req + ch_offset), 649138c8a9a5SSteve French req->Channel, 649238c8a9a5SSteve French req->WriteChannelInfoLength); 649338c8a9a5SSteve French if (err) 649438c8a9a5SSteve French goto out; 649538c8a9a5SSteve French } 649638c8a9a5SSteve French 649738c8a9a5SSteve French if (!test_tree_conn_flag(work->tcon, KSMBD_TREE_CONN_FLAG_WRITABLE)) { 649838c8a9a5SSteve French ksmbd_debug(SMB, "User does not have write permission\n"); 649938c8a9a5SSteve French err = -EACCES; 650038c8a9a5SSteve French goto out; 650138c8a9a5SSteve French } 650238c8a9a5SSteve French 650338c8a9a5SSteve French fp = ksmbd_lookup_fd_slow(work, req->VolatileFileId, req->PersistentFileId); 650438c8a9a5SSteve French if (!fp) { 650538c8a9a5SSteve French err = -ENOENT; 650638c8a9a5SSteve French goto out; 650738c8a9a5SSteve French } 650838c8a9a5SSteve French 650938c8a9a5SSteve French if (!(fp->daccess & (FILE_WRITE_DATA_LE | FILE_READ_ATTRIBUTES_LE))) { 651038c8a9a5SSteve French pr_err("Not permitted to write : 0x%x\n", fp->daccess); 651138c8a9a5SSteve French err = -EACCES; 651238c8a9a5SSteve French goto out; 651338c8a9a5SSteve French } 651438c8a9a5SSteve French 651538c8a9a5SSteve French if (length > max_write_size) { 651638c8a9a5SSteve French ksmbd_debug(SMB, "limiting write size to max size(%u)\n", 651738c8a9a5SSteve French max_write_size); 651838c8a9a5SSteve French err = -EINVAL; 651938c8a9a5SSteve French goto out; 652038c8a9a5SSteve French } 652138c8a9a5SSteve French 652238c8a9a5SSteve French ksmbd_debug(SMB, "flags %u\n", le32_to_cpu(req->Flags)); 652338c8a9a5SSteve French if (le32_to_cpu(req->Flags) & SMB2_WRITEFLAG_WRITE_THROUGH) 652438c8a9a5SSteve French writethrough = true; 652538c8a9a5SSteve French 652638c8a9a5SSteve French if (is_rdma_channel == false) { 652738c8a9a5SSteve French if (le16_to_cpu(req->DataOffset) < 652838c8a9a5SSteve French offsetof(struct smb2_write_req, Buffer)) { 652938c8a9a5SSteve French err = -EINVAL; 653038c8a9a5SSteve French goto out; 653138c8a9a5SSteve French } 653238c8a9a5SSteve French 653338c8a9a5SSteve French data_buf = (char *)(((char *)&req->hdr.ProtocolId) + 653438c8a9a5SSteve French le16_to_cpu(req->DataOffset)); 653538c8a9a5SSteve French 653638c8a9a5SSteve French ksmbd_debug(SMB, "filename %pD, offset %lld, len %zu\n", 653738c8a9a5SSteve French fp->filp, offset, length); 653838c8a9a5SSteve French err = ksmbd_vfs_write(work, fp, data_buf, length, &offset, 653938c8a9a5SSteve French writethrough, &nbytes); 654038c8a9a5SSteve French if (err < 0) 654138c8a9a5SSteve French goto out; 654238c8a9a5SSteve French } else { 654338c8a9a5SSteve French /* read data from the client using rdma channel, and 654438c8a9a5SSteve French * write the data. 654538c8a9a5SSteve French */ 654638c8a9a5SSteve French nbytes = smb2_write_rdma_channel(work, req, fp, offset, length, 654738c8a9a5SSteve French writethrough); 654838c8a9a5SSteve French if (nbytes < 0) { 654938c8a9a5SSteve French err = (int)nbytes; 655038c8a9a5SSteve French goto out; 655138c8a9a5SSteve French } 655238c8a9a5SSteve French } 655338c8a9a5SSteve French 655438c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(17); 655538c8a9a5SSteve French rsp->DataOffset = 0; 655638c8a9a5SSteve French rsp->Reserved = 0; 655738c8a9a5SSteve French rsp->DataLength = cpu_to_le32(nbytes); 655838c8a9a5SSteve French rsp->DataRemaining = 0; 655938c8a9a5SSteve French rsp->Reserved2 = 0; 656038c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 16); 656138c8a9a5SSteve French ksmbd_fd_put(work, fp); 656238c8a9a5SSteve French return 0; 656338c8a9a5SSteve French 656438c8a9a5SSteve French out: 656538c8a9a5SSteve French if (err == -EAGAIN) 656638c8a9a5SSteve French rsp->hdr.Status = STATUS_FILE_LOCK_CONFLICT; 656738c8a9a5SSteve French else if (err == -ENOSPC || err == -EFBIG) 656838c8a9a5SSteve French rsp->hdr.Status = STATUS_DISK_FULL; 656938c8a9a5SSteve French else if (err == -ENOENT) 657038c8a9a5SSteve French rsp->hdr.Status = STATUS_FILE_CLOSED; 657138c8a9a5SSteve French else if (err == -EACCES) 657238c8a9a5SSteve French rsp->hdr.Status = STATUS_ACCESS_DENIED; 657338c8a9a5SSteve French else if (err == -ESHARE) 657438c8a9a5SSteve French rsp->hdr.Status = STATUS_SHARING_VIOLATION; 657538c8a9a5SSteve French else if (err == -EINVAL) 657638c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 657738c8a9a5SSteve French else 657838c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_HANDLE; 657938c8a9a5SSteve French 658038c8a9a5SSteve French smb2_set_err_rsp(work); 658138c8a9a5SSteve French ksmbd_fd_put(work, fp); 658238c8a9a5SSteve French return err; 658338c8a9a5SSteve French } 658438c8a9a5SSteve French 658538c8a9a5SSteve French /** 658638c8a9a5SSteve French * smb2_flush() - handler for smb2 flush file - fsync 658738c8a9a5SSteve French * @work: smb work containing flush command buffer 658838c8a9a5SSteve French * 658938c8a9a5SSteve French * Return: 0 on success, otherwise error 659038c8a9a5SSteve French */ 659138c8a9a5SSteve French int smb2_flush(struct ksmbd_work *work) 659238c8a9a5SSteve French { 659338c8a9a5SSteve French struct smb2_flush_req *req; 659438c8a9a5SSteve French struct smb2_flush_rsp *rsp; 659538c8a9a5SSteve French int err; 659638c8a9a5SSteve French 659738c8a9a5SSteve French WORK_BUFFERS(work, req, rsp); 659838c8a9a5SSteve French 659938c8a9a5SSteve French ksmbd_debug(SMB, "SMB2_FLUSH called for fid %llu\n", req->VolatileFileId); 660038c8a9a5SSteve French 660138c8a9a5SSteve French err = ksmbd_vfs_fsync(work, req->VolatileFileId, req->PersistentFileId); 660238c8a9a5SSteve French if (err) 660338c8a9a5SSteve French goto out; 660438c8a9a5SSteve French 660538c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(4); 660638c8a9a5SSteve French rsp->Reserved = 0; 660738c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 4); 660838c8a9a5SSteve French return 0; 660938c8a9a5SSteve French 661038c8a9a5SSteve French out: 661138c8a9a5SSteve French if (err) { 661238c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_HANDLE; 661338c8a9a5SSteve French smb2_set_err_rsp(work); 661438c8a9a5SSteve French } 661538c8a9a5SSteve French 661638c8a9a5SSteve French return err; 661738c8a9a5SSteve French } 661838c8a9a5SSteve French 661938c8a9a5SSteve French /** 662038c8a9a5SSteve French * smb2_cancel() - handler for smb2 cancel command 662138c8a9a5SSteve French * @work: smb work containing cancel command buffer 662238c8a9a5SSteve French * 662338c8a9a5SSteve French * Return: 0 on success, otherwise error 662438c8a9a5SSteve French */ 662538c8a9a5SSteve French int smb2_cancel(struct ksmbd_work *work) 662638c8a9a5SSteve French { 662738c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 662838c8a9a5SSteve French struct smb2_hdr *hdr = smb2_get_msg(work->request_buf); 662938c8a9a5SSteve French struct smb2_hdr *chdr; 663038c8a9a5SSteve French struct ksmbd_work *iter; 663138c8a9a5SSteve French struct list_head *command_list; 663238c8a9a5SSteve French 66337b7d709eSNamjae Jeon if (work->next_smb2_rcv_hdr_off) 66347b7d709eSNamjae Jeon hdr = ksmbd_resp_buf_next(work); 66357b7d709eSNamjae Jeon 663638c8a9a5SSteve French ksmbd_debug(SMB, "smb2 cancel called on mid %llu, async flags 0x%x\n", 663738c8a9a5SSteve French hdr->MessageId, hdr->Flags); 663838c8a9a5SSteve French 663938c8a9a5SSteve French if (hdr->Flags & SMB2_FLAGS_ASYNC_COMMAND) { 664038c8a9a5SSteve French command_list = &conn->async_requests; 664138c8a9a5SSteve French 664238c8a9a5SSteve French spin_lock(&conn->request_lock); 664338c8a9a5SSteve French list_for_each_entry(iter, command_list, 664438c8a9a5SSteve French async_request_entry) { 664538c8a9a5SSteve French chdr = smb2_get_msg(iter->request_buf); 664638c8a9a5SSteve French 664738c8a9a5SSteve French if (iter->async_id != 664838c8a9a5SSteve French le64_to_cpu(hdr->Id.AsyncId)) 664938c8a9a5SSteve French continue; 665038c8a9a5SSteve French 665138c8a9a5SSteve French ksmbd_debug(SMB, 665238c8a9a5SSteve French "smb2 with AsyncId %llu cancelled command = 0x%x\n", 665338c8a9a5SSteve French le64_to_cpu(hdr->Id.AsyncId), 665438c8a9a5SSteve French le16_to_cpu(chdr->Command)); 665538c8a9a5SSteve French iter->state = KSMBD_WORK_CANCELLED; 665638c8a9a5SSteve French if (iter->cancel_fn) 665738c8a9a5SSteve French iter->cancel_fn(iter->cancel_argv); 665838c8a9a5SSteve French break; 665938c8a9a5SSteve French } 666038c8a9a5SSteve French spin_unlock(&conn->request_lock); 666138c8a9a5SSteve French } else { 666238c8a9a5SSteve French command_list = &conn->requests; 666338c8a9a5SSteve French 666438c8a9a5SSteve French spin_lock(&conn->request_lock); 666538c8a9a5SSteve French list_for_each_entry(iter, command_list, request_entry) { 666638c8a9a5SSteve French chdr = smb2_get_msg(iter->request_buf); 666738c8a9a5SSteve French 666838c8a9a5SSteve French if (chdr->MessageId != hdr->MessageId || 666938c8a9a5SSteve French iter == work) 667038c8a9a5SSteve French continue; 667138c8a9a5SSteve French 667238c8a9a5SSteve French ksmbd_debug(SMB, 667338c8a9a5SSteve French "smb2 with mid %llu cancelled command = 0x%x\n", 667438c8a9a5SSteve French le64_to_cpu(hdr->MessageId), 667538c8a9a5SSteve French le16_to_cpu(chdr->Command)); 667638c8a9a5SSteve French iter->state = KSMBD_WORK_CANCELLED; 667738c8a9a5SSteve French break; 667838c8a9a5SSteve French } 667938c8a9a5SSteve French spin_unlock(&conn->request_lock); 668038c8a9a5SSteve French } 668138c8a9a5SSteve French 668238c8a9a5SSteve French /* For SMB2_CANCEL command itself send no response*/ 668338c8a9a5SSteve French work->send_no_response = 1; 668438c8a9a5SSteve French return 0; 668538c8a9a5SSteve French } 668638c8a9a5SSteve French 668738c8a9a5SSteve French struct file_lock *smb_flock_init(struct file *f) 668838c8a9a5SSteve French { 668938c8a9a5SSteve French struct file_lock *fl; 669038c8a9a5SSteve French 669138c8a9a5SSteve French fl = locks_alloc_lock(); 669238c8a9a5SSteve French if (!fl) 669338c8a9a5SSteve French goto out; 669438c8a9a5SSteve French 669538c8a9a5SSteve French locks_init_lock(fl); 669638c8a9a5SSteve French 669738c8a9a5SSteve French fl->fl_owner = f; 669838c8a9a5SSteve French fl->fl_pid = current->tgid; 669938c8a9a5SSteve French fl->fl_file = f; 670038c8a9a5SSteve French fl->fl_flags = FL_POSIX; 670138c8a9a5SSteve French fl->fl_ops = NULL; 670238c8a9a5SSteve French fl->fl_lmops = NULL; 670338c8a9a5SSteve French 670438c8a9a5SSteve French out: 670538c8a9a5SSteve French return fl; 670638c8a9a5SSteve French } 670738c8a9a5SSteve French 670838c8a9a5SSteve French static int smb2_set_flock_flags(struct file_lock *flock, int flags) 670938c8a9a5SSteve French { 671038c8a9a5SSteve French int cmd = -EINVAL; 671138c8a9a5SSteve French 671238c8a9a5SSteve French /* Checking for wrong flag combination during lock request*/ 671338c8a9a5SSteve French switch (flags) { 671438c8a9a5SSteve French case SMB2_LOCKFLAG_SHARED: 671538c8a9a5SSteve French ksmbd_debug(SMB, "received shared request\n"); 671638c8a9a5SSteve French cmd = F_SETLKW; 671738c8a9a5SSteve French flock->fl_type = F_RDLCK; 671838c8a9a5SSteve French flock->fl_flags |= FL_SLEEP; 671938c8a9a5SSteve French break; 672038c8a9a5SSteve French case SMB2_LOCKFLAG_EXCLUSIVE: 672138c8a9a5SSteve French ksmbd_debug(SMB, "received exclusive request\n"); 672238c8a9a5SSteve French cmd = F_SETLKW; 672338c8a9a5SSteve French flock->fl_type = F_WRLCK; 672438c8a9a5SSteve French flock->fl_flags |= FL_SLEEP; 672538c8a9a5SSteve French break; 672638c8a9a5SSteve French case SMB2_LOCKFLAG_SHARED | SMB2_LOCKFLAG_FAIL_IMMEDIATELY: 672738c8a9a5SSteve French ksmbd_debug(SMB, 672838c8a9a5SSteve French "received shared & fail immediately request\n"); 672938c8a9a5SSteve French cmd = F_SETLK; 673038c8a9a5SSteve French flock->fl_type = F_RDLCK; 673138c8a9a5SSteve French break; 673238c8a9a5SSteve French case SMB2_LOCKFLAG_EXCLUSIVE | SMB2_LOCKFLAG_FAIL_IMMEDIATELY: 673338c8a9a5SSteve French ksmbd_debug(SMB, 673438c8a9a5SSteve French "received exclusive & fail immediately request\n"); 673538c8a9a5SSteve French cmd = F_SETLK; 673638c8a9a5SSteve French flock->fl_type = F_WRLCK; 673738c8a9a5SSteve French break; 673838c8a9a5SSteve French case SMB2_LOCKFLAG_UNLOCK: 673938c8a9a5SSteve French ksmbd_debug(SMB, "received unlock request\n"); 674038c8a9a5SSteve French flock->fl_type = F_UNLCK; 674138c8a9a5SSteve French cmd = F_SETLK; 674238c8a9a5SSteve French break; 674338c8a9a5SSteve French } 674438c8a9a5SSteve French 674538c8a9a5SSteve French return cmd; 674638c8a9a5SSteve French } 674738c8a9a5SSteve French 674838c8a9a5SSteve French static struct ksmbd_lock *smb2_lock_init(struct file_lock *flock, 674938c8a9a5SSteve French unsigned int cmd, int flags, 675038c8a9a5SSteve French struct list_head *lock_list) 675138c8a9a5SSteve French { 675238c8a9a5SSteve French struct ksmbd_lock *lock; 675338c8a9a5SSteve French 675438c8a9a5SSteve French lock = kzalloc(sizeof(struct ksmbd_lock), GFP_KERNEL); 675538c8a9a5SSteve French if (!lock) 675638c8a9a5SSteve French return NULL; 675738c8a9a5SSteve French 675838c8a9a5SSteve French lock->cmd = cmd; 675938c8a9a5SSteve French lock->fl = flock; 676038c8a9a5SSteve French lock->start = flock->fl_start; 676138c8a9a5SSteve French lock->end = flock->fl_end; 676238c8a9a5SSteve French lock->flags = flags; 676338c8a9a5SSteve French if (lock->start == lock->end) 676438c8a9a5SSteve French lock->zero_len = 1; 676538c8a9a5SSteve French INIT_LIST_HEAD(&lock->clist); 676638c8a9a5SSteve French INIT_LIST_HEAD(&lock->flist); 676738c8a9a5SSteve French INIT_LIST_HEAD(&lock->llist); 676838c8a9a5SSteve French list_add_tail(&lock->llist, lock_list); 676938c8a9a5SSteve French 677038c8a9a5SSteve French return lock; 677138c8a9a5SSteve French } 677238c8a9a5SSteve French 677338c8a9a5SSteve French static void smb2_remove_blocked_lock(void **argv) 677438c8a9a5SSteve French { 677538c8a9a5SSteve French struct file_lock *flock = (struct file_lock *)argv[0]; 677638c8a9a5SSteve French 677738c8a9a5SSteve French ksmbd_vfs_posix_lock_unblock(flock); 677838c8a9a5SSteve French wake_up(&flock->fl_wait); 677938c8a9a5SSteve French } 678038c8a9a5SSteve French 678138c8a9a5SSteve French static inline bool lock_defer_pending(struct file_lock *fl) 678238c8a9a5SSteve French { 678338c8a9a5SSteve French /* check pending lock waiters */ 678438c8a9a5SSteve French return waitqueue_active(&fl->fl_wait); 678538c8a9a5SSteve French } 678638c8a9a5SSteve French 678738c8a9a5SSteve French /** 678838c8a9a5SSteve French * smb2_lock() - handler for smb2 file lock command 678938c8a9a5SSteve French * @work: smb work containing lock command buffer 679038c8a9a5SSteve French * 679138c8a9a5SSteve French * Return: 0 on success, otherwise error 679238c8a9a5SSteve French */ 679338c8a9a5SSteve French int smb2_lock(struct ksmbd_work *work) 679438c8a9a5SSteve French { 67957b7d709eSNamjae Jeon struct smb2_lock_req *req; 67967b7d709eSNamjae Jeon struct smb2_lock_rsp *rsp; 679738c8a9a5SSteve French struct smb2_lock_element *lock_ele; 679838c8a9a5SSteve French struct ksmbd_file *fp = NULL; 679938c8a9a5SSteve French struct file_lock *flock = NULL; 680038c8a9a5SSteve French struct file *filp = NULL; 680138c8a9a5SSteve French int lock_count; 680238c8a9a5SSteve French int flags = 0; 680338c8a9a5SSteve French int cmd = 0; 680438c8a9a5SSteve French int err = -EIO, i, rc = 0; 680538c8a9a5SSteve French u64 lock_start, lock_length; 680638c8a9a5SSteve French struct ksmbd_lock *smb_lock = NULL, *cmp_lock, *tmp, *tmp2; 680738c8a9a5SSteve French struct ksmbd_conn *conn; 680838c8a9a5SSteve French int nolock = 0; 680938c8a9a5SSteve French LIST_HEAD(lock_list); 681038c8a9a5SSteve French LIST_HEAD(rollback_list); 681138c8a9a5SSteve French int prior_lock = 0; 681238c8a9a5SSteve French 68137b7d709eSNamjae Jeon WORK_BUFFERS(work, req, rsp); 68147b7d709eSNamjae Jeon 681538c8a9a5SSteve French ksmbd_debug(SMB, "Received lock request\n"); 681638c8a9a5SSteve French fp = ksmbd_lookup_fd_slow(work, req->VolatileFileId, req->PersistentFileId); 681738c8a9a5SSteve French if (!fp) { 681838c8a9a5SSteve French ksmbd_debug(SMB, "Invalid file id for lock : %llu\n", req->VolatileFileId); 681938c8a9a5SSteve French err = -ENOENT; 682038c8a9a5SSteve French goto out2; 682138c8a9a5SSteve French } 682238c8a9a5SSteve French 682338c8a9a5SSteve French filp = fp->filp; 682438c8a9a5SSteve French lock_count = le16_to_cpu(req->LockCount); 682538c8a9a5SSteve French lock_ele = req->locks; 682638c8a9a5SSteve French 682738c8a9a5SSteve French ksmbd_debug(SMB, "lock count is %d\n", lock_count); 682838c8a9a5SSteve French if (!lock_count) { 682938c8a9a5SSteve French err = -EINVAL; 683038c8a9a5SSteve French goto out2; 683138c8a9a5SSteve French } 683238c8a9a5SSteve French 683338c8a9a5SSteve French for (i = 0; i < lock_count; i++) { 683438c8a9a5SSteve French flags = le32_to_cpu(lock_ele[i].Flags); 683538c8a9a5SSteve French 683638c8a9a5SSteve French flock = smb_flock_init(filp); 683738c8a9a5SSteve French if (!flock) 683838c8a9a5SSteve French goto out; 683938c8a9a5SSteve French 684038c8a9a5SSteve French cmd = smb2_set_flock_flags(flock, flags); 684138c8a9a5SSteve French 684238c8a9a5SSteve French lock_start = le64_to_cpu(lock_ele[i].Offset); 684338c8a9a5SSteve French lock_length = le64_to_cpu(lock_ele[i].Length); 684438c8a9a5SSteve French if (lock_start > U64_MAX - lock_length) { 684538c8a9a5SSteve French pr_err("Invalid lock range requested\n"); 684638c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_LOCK_RANGE; 684738c8a9a5SSteve French locks_free_lock(flock); 684838c8a9a5SSteve French goto out; 684938c8a9a5SSteve French } 685038c8a9a5SSteve French 685138c8a9a5SSteve French if (lock_start > OFFSET_MAX) 685238c8a9a5SSteve French flock->fl_start = OFFSET_MAX; 685338c8a9a5SSteve French else 685438c8a9a5SSteve French flock->fl_start = lock_start; 685538c8a9a5SSteve French 685638c8a9a5SSteve French lock_length = le64_to_cpu(lock_ele[i].Length); 685738c8a9a5SSteve French if (lock_length > OFFSET_MAX - flock->fl_start) 685838c8a9a5SSteve French lock_length = OFFSET_MAX - flock->fl_start; 685938c8a9a5SSteve French 686038c8a9a5SSteve French flock->fl_end = flock->fl_start + lock_length; 686138c8a9a5SSteve French 686238c8a9a5SSteve French if (flock->fl_end < flock->fl_start) { 686338c8a9a5SSteve French ksmbd_debug(SMB, 686438c8a9a5SSteve French "the end offset(%llx) is smaller than the start offset(%llx)\n", 686538c8a9a5SSteve French flock->fl_end, flock->fl_start); 686638c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_LOCK_RANGE; 686738c8a9a5SSteve French locks_free_lock(flock); 686838c8a9a5SSteve French goto out; 686938c8a9a5SSteve French } 687038c8a9a5SSteve French 687138c8a9a5SSteve French /* Check conflict locks in one request */ 687238c8a9a5SSteve French list_for_each_entry(cmp_lock, &lock_list, llist) { 687338c8a9a5SSteve French if (cmp_lock->fl->fl_start <= flock->fl_start && 687438c8a9a5SSteve French cmp_lock->fl->fl_end >= flock->fl_end) { 687538c8a9a5SSteve French if (cmp_lock->fl->fl_type != F_UNLCK && 687638c8a9a5SSteve French flock->fl_type != F_UNLCK) { 687738c8a9a5SSteve French pr_err("conflict two locks in one request\n"); 687838c8a9a5SSteve French err = -EINVAL; 687938c8a9a5SSteve French locks_free_lock(flock); 688038c8a9a5SSteve French goto out; 688138c8a9a5SSteve French } 688238c8a9a5SSteve French } 688338c8a9a5SSteve French } 688438c8a9a5SSteve French 688538c8a9a5SSteve French smb_lock = smb2_lock_init(flock, cmd, flags, &lock_list); 688638c8a9a5SSteve French if (!smb_lock) { 688738c8a9a5SSteve French err = -EINVAL; 688838c8a9a5SSteve French locks_free_lock(flock); 688938c8a9a5SSteve French goto out; 689038c8a9a5SSteve French } 689138c8a9a5SSteve French } 689238c8a9a5SSteve French 689338c8a9a5SSteve French list_for_each_entry_safe(smb_lock, tmp, &lock_list, llist) { 689438c8a9a5SSteve French if (smb_lock->cmd < 0) { 689538c8a9a5SSteve French err = -EINVAL; 689638c8a9a5SSteve French goto out; 689738c8a9a5SSteve French } 689838c8a9a5SSteve French 689938c8a9a5SSteve French if (!(smb_lock->flags & SMB2_LOCKFLAG_MASK)) { 690038c8a9a5SSteve French err = -EINVAL; 690138c8a9a5SSteve French goto out; 690238c8a9a5SSteve French } 690338c8a9a5SSteve French 690438c8a9a5SSteve French if ((prior_lock & (SMB2_LOCKFLAG_EXCLUSIVE | SMB2_LOCKFLAG_SHARED) && 690538c8a9a5SSteve French smb_lock->flags & SMB2_LOCKFLAG_UNLOCK) || 690638c8a9a5SSteve French (prior_lock == SMB2_LOCKFLAG_UNLOCK && 690738c8a9a5SSteve French !(smb_lock->flags & SMB2_LOCKFLAG_UNLOCK))) { 690838c8a9a5SSteve French err = -EINVAL; 690938c8a9a5SSteve French goto out; 691038c8a9a5SSteve French } 691138c8a9a5SSteve French 691238c8a9a5SSteve French prior_lock = smb_lock->flags; 691338c8a9a5SSteve French 691438c8a9a5SSteve French if (!(smb_lock->flags & SMB2_LOCKFLAG_UNLOCK) && 691538c8a9a5SSteve French !(smb_lock->flags & SMB2_LOCKFLAG_FAIL_IMMEDIATELY)) 691638c8a9a5SSteve French goto no_check_cl; 691738c8a9a5SSteve French 691838c8a9a5SSteve French nolock = 1; 691938c8a9a5SSteve French /* check locks in connection list */ 692038c8a9a5SSteve French down_read(&conn_list_lock); 692138c8a9a5SSteve French list_for_each_entry(conn, &conn_list, conns_list) { 692238c8a9a5SSteve French spin_lock(&conn->llist_lock); 692338c8a9a5SSteve French list_for_each_entry_safe(cmp_lock, tmp2, &conn->lock_list, clist) { 692438c8a9a5SSteve French if (file_inode(cmp_lock->fl->fl_file) != 692538c8a9a5SSteve French file_inode(smb_lock->fl->fl_file)) 692638c8a9a5SSteve French continue; 692738c8a9a5SSteve French 692838c8a9a5SSteve French if (smb_lock->fl->fl_type == F_UNLCK) { 692938c8a9a5SSteve French if (cmp_lock->fl->fl_file == smb_lock->fl->fl_file && 693038c8a9a5SSteve French cmp_lock->start == smb_lock->start && 693138c8a9a5SSteve French cmp_lock->end == smb_lock->end && 693238c8a9a5SSteve French !lock_defer_pending(cmp_lock->fl)) { 693338c8a9a5SSteve French nolock = 0; 693438c8a9a5SSteve French list_del(&cmp_lock->flist); 693538c8a9a5SSteve French list_del(&cmp_lock->clist); 693638c8a9a5SSteve French spin_unlock(&conn->llist_lock); 693738c8a9a5SSteve French up_read(&conn_list_lock); 693838c8a9a5SSteve French 693938c8a9a5SSteve French locks_free_lock(cmp_lock->fl); 694038c8a9a5SSteve French kfree(cmp_lock); 694138c8a9a5SSteve French goto out_check_cl; 694238c8a9a5SSteve French } 694338c8a9a5SSteve French continue; 694438c8a9a5SSteve French } 694538c8a9a5SSteve French 694638c8a9a5SSteve French if (cmp_lock->fl->fl_file == smb_lock->fl->fl_file) { 694738c8a9a5SSteve French if (smb_lock->flags & SMB2_LOCKFLAG_SHARED) 694838c8a9a5SSteve French continue; 694938c8a9a5SSteve French } else { 695038c8a9a5SSteve French if (cmp_lock->flags & SMB2_LOCKFLAG_SHARED) 695138c8a9a5SSteve French continue; 695238c8a9a5SSteve French } 695338c8a9a5SSteve French 695438c8a9a5SSteve French /* check zero byte lock range */ 695538c8a9a5SSteve French if (cmp_lock->zero_len && !smb_lock->zero_len && 695638c8a9a5SSteve French cmp_lock->start > smb_lock->start && 695738c8a9a5SSteve French cmp_lock->start < smb_lock->end) { 695838c8a9a5SSteve French spin_unlock(&conn->llist_lock); 695938c8a9a5SSteve French up_read(&conn_list_lock); 696038c8a9a5SSteve French pr_err("previous lock conflict with zero byte lock range\n"); 696138c8a9a5SSteve French goto out; 696238c8a9a5SSteve French } 696338c8a9a5SSteve French 696438c8a9a5SSteve French if (smb_lock->zero_len && !cmp_lock->zero_len && 696538c8a9a5SSteve French smb_lock->start > cmp_lock->start && 696638c8a9a5SSteve French smb_lock->start < cmp_lock->end) { 696738c8a9a5SSteve French spin_unlock(&conn->llist_lock); 696838c8a9a5SSteve French up_read(&conn_list_lock); 696938c8a9a5SSteve French pr_err("current lock conflict with zero byte lock range\n"); 697038c8a9a5SSteve French goto out; 697138c8a9a5SSteve French } 697238c8a9a5SSteve French 697338c8a9a5SSteve French if (((cmp_lock->start <= smb_lock->start && 697438c8a9a5SSteve French cmp_lock->end > smb_lock->start) || 697538c8a9a5SSteve French (cmp_lock->start < smb_lock->end && 697638c8a9a5SSteve French cmp_lock->end >= smb_lock->end)) && 697738c8a9a5SSteve French !cmp_lock->zero_len && !smb_lock->zero_len) { 697838c8a9a5SSteve French spin_unlock(&conn->llist_lock); 697938c8a9a5SSteve French up_read(&conn_list_lock); 698038c8a9a5SSteve French pr_err("Not allow lock operation on exclusive lock range\n"); 698138c8a9a5SSteve French goto out; 698238c8a9a5SSteve French } 698338c8a9a5SSteve French } 698438c8a9a5SSteve French spin_unlock(&conn->llist_lock); 698538c8a9a5SSteve French } 698638c8a9a5SSteve French up_read(&conn_list_lock); 698738c8a9a5SSteve French out_check_cl: 698838c8a9a5SSteve French if (smb_lock->fl->fl_type == F_UNLCK && nolock) { 698938c8a9a5SSteve French pr_err("Try to unlock nolocked range\n"); 699038c8a9a5SSteve French rsp->hdr.Status = STATUS_RANGE_NOT_LOCKED; 699138c8a9a5SSteve French goto out; 699238c8a9a5SSteve French } 699338c8a9a5SSteve French 699438c8a9a5SSteve French no_check_cl: 699538c8a9a5SSteve French if (smb_lock->zero_len) { 699638c8a9a5SSteve French err = 0; 699738c8a9a5SSteve French goto skip; 699838c8a9a5SSteve French } 699938c8a9a5SSteve French 700038c8a9a5SSteve French flock = smb_lock->fl; 700138c8a9a5SSteve French list_del(&smb_lock->llist); 700238c8a9a5SSteve French retry: 700338c8a9a5SSteve French rc = vfs_lock_file(filp, smb_lock->cmd, flock, NULL); 700438c8a9a5SSteve French skip: 700538c8a9a5SSteve French if (flags & SMB2_LOCKFLAG_UNLOCK) { 700638c8a9a5SSteve French if (!rc) { 700738c8a9a5SSteve French ksmbd_debug(SMB, "File unlocked\n"); 700838c8a9a5SSteve French } else if (rc == -ENOENT) { 700938c8a9a5SSteve French rsp->hdr.Status = STATUS_NOT_LOCKED; 701038c8a9a5SSteve French goto out; 701138c8a9a5SSteve French } 701238c8a9a5SSteve French locks_free_lock(flock); 701338c8a9a5SSteve French kfree(smb_lock); 701438c8a9a5SSteve French } else { 701538c8a9a5SSteve French if (rc == FILE_LOCK_DEFERRED) { 701638c8a9a5SSteve French void **argv; 701738c8a9a5SSteve French 701838c8a9a5SSteve French ksmbd_debug(SMB, 701938c8a9a5SSteve French "would have to wait for getting lock\n"); 702038c8a9a5SSteve French spin_lock(&work->conn->llist_lock); 702138c8a9a5SSteve French list_add_tail(&smb_lock->clist, 702238c8a9a5SSteve French &work->conn->lock_list); 702338c8a9a5SSteve French spin_unlock(&work->conn->llist_lock); 702438c8a9a5SSteve French list_add(&smb_lock->llist, &rollback_list); 702538c8a9a5SSteve French 702638c8a9a5SSteve French argv = kmalloc(sizeof(void *), GFP_KERNEL); 702738c8a9a5SSteve French if (!argv) { 702838c8a9a5SSteve French err = -ENOMEM; 702938c8a9a5SSteve French goto out; 703038c8a9a5SSteve French } 703138c8a9a5SSteve French argv[0] = flock; 703238c8a9a5SSteve French 703338c8a9a5SSteve French rc = setup_async_work(work, 703438c8a9a5SSteve French smb2_remove_blocked_lock, 703538c8a9a5SSteve French argv); 703638c8a9a5SSteve French if (rc) { 703738c8a9a5SSteve French err = -ENOMEM; 703838c8a9a5SSteve French goto out; 703938c8a9a5SSteve French } 704038c8a9a5SSteve French spin_lock(&fp->f_lock); 704138c8a9a5SSteve French list_add(&work->fp_entry, &fp->blocked_works); 704238c8a9a5SSteve French spin_unlock(&fp->f_lock); 704338c8a9a5SSteve French 704438c8a9a5SSteve French smb2_send_interim_resp(work, STATUS_PENDING); 704538c8a9a5SSteve French 704638c8a9a5SSteve French ksmbd_vfs_posix_lock_wait(flock); 704738c8a9a5SSteve French 704838c8a9a5SSteve French spin_lock(&fp->f_lock); 704938c8a9a5SSteve French list_del(&work->fp_entry); 705038c8a9a5SSteve French spin_unlock(&fp->f_lock); 705138c8a9a5SSteve French 705238c8a9a5SSteve French if (work->state != KSMBD_WORK_ACTIVE) { 705338c8a9a5SSteve French list_del(&smb_lock->llist); 705438c8a9a5SSteve French spin_lock(&work->conn->llist_lock); 705538c8a9a5SSteve French list_del(&smb_lock->clist); 705638c8a9a5SSteve French spin_unlock(&work->conn->llist_lock); 705738c8a9a5SSteve French locks_free_lock(flock); 705838c8a9a5SSteve French 705938c8a9a5SSteve French if (work->state == KSMBD_WORK_CANCELLED) { 706038c8a9a5SSteve French rsp->hdr.Status = 706138c8a9a5SSteve French STATUS_CANCELLED; 706238c8a9a5SSteve French kfree(smb_lock); 706338c8a9a5SSteve French smb2_send_interim_resp(work, 706438c8a9a5SSteve French STATUS_CANCELLED); 706538c8a9a5SSteve French work->send_no_response = 1; 706638c8a9a5SSteve French goto out; 706738c8a9a5SSteve French } 706838c8a9a5SSteve French 706938c8a9a5SSteve French init_smb2_rsp_hdr(work); 707038c8a9a5SSteve French smb2_set_err_rsp(work); 707138c8a9a5SSteve French rsp->hdr.Status = 707238c8a9a5SSteve French STATUS_RANGE_NOT_LOCKED; 707338c8a9a5SSteve French kfree(smb_lock); 707438c8a9a5SSteve French goto out2; 707538c8a9a5SSteve French } 707638c8a9a5SSteve French 707738c8a9a5SSteve French list_del(&smb_lock->llist); 707838c8a9a5SSteve French spin_lock(&work->conn->llist_lock); 707938c8a9a5SSteve French list_del(&smb_lock->clist); 708038c8a9a5SSteve French spin_unlock(&work->conn->llist_lock); 708138c8a9a5SSteve French release_async_work(work); 708238c8a9a5SSteve French goto retry; 708338c8a9a5SSteve French } else if (!rc) { 708438c8a9a5SSteve French spin_lock(&work->conn->llist_lock); 708538c8a9a5SSteve French list_add_tail(&smb_lock->clist, 708638c8a9a5SSteve French &work->conn->lock_list); 708738c8a9a5SSteve French list_add_tail(&smb_lock->flist, 708838c8a9a5SSteve French &fp->lock_list); 708938c8a9a5SSteve French spin_unlock(&work->conn->llist_lock); 709038c8a9a5SSteve French list_add(&smb_lock->llist, &rollback_list); 709138c8a9a5SSteve French ksmbd_debug(SMB, "successful in taking lock\n"); 709238c8a9a5SSteve French } else { 709338c8a9a5SSteve French goto out; 709438c8a9a5SSteve French } 709538c8a9a5SSteve French } 709638c8a9a5SSteve French } 709738c8a9a5SSteve French 709838c8a9a5SSteve French if (atomic_read(&fp->f_ci->op_count) > 1) 709938c8a9a5SSteve French smb_break_all_oplock(work, fp); 710038c8a9a5SSteve French 710138c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(4); 710238c8a9a5SSteve French ksmbd_debug(SMB, "successful in taking lock\n"); 710338c8a9a5SSteve French rsp->hdr.Status = STATUS_SUCCESS; 710438c8a9a5SSteve French rsp->Reserved = 0; 710538c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 4); 710638c8a9a5SSteve French ksmbd_fd_put(work, fp); 710738c8a9a5SSteve French return 0; 710838c8a9a5SSteve French 710938c8a9a5SSteve French out: 711038c8a9a5SSteve French list_for_each_entry_safe(smb_lock, tmp, &lock_list, llist) { 711138c8a9a5SSteve French locks_free_lock(smb_lock->fl); 711238c8a9a5SSteve French list_del(&smb_lock->llist); 711338c8a9a5SSteve French kfree(smb_lock); 711438c8a9a5SSteve French } 711538c8a9a5SSteve French 711638c8a9a5SSteve French list_for_each_entry_safe(smb_lock, tmp, &rollback_list, llist) { 711738c8a9a5SSteve French struct file_lock *rlock = NULL; 711838c8a9a5SSteve French 711938c8a9a5SSteve French rlock = smb_flock_init(filp); 712038c8a9a5SSteve French rlock->fl_type = F_UNLCK; 712138c8a9a5SSteve French rlock->fl_start = smb_lock->start; 712238c8a9a5SSteve French rlock->fl_end = smb_lock->end; 712338c8a9a5SSteve French 712438c8a9a5SSteve French rc = vfs_lock_file(filp, F_SETLK, rlock, NULL); 712538c8a9a5SSteve French if (rc) 712638c8a9a5SSteve French pr_err("rollback unlock fail : %d\n", rc); 712738c8a9a5SSteve French 712838c8a9a5SSteve French list_del(&smb_lock->llist); 712938c8a9a5SSteve French spin_lock(&work->conn->llist_lock); 713038c8a9a5SSteve French if (!list_empty(&smb_lock->flist)) 713138c8a9a5SSteve French list_del(&smb_lock->flist); 713238c8a9a5SSteve French list_del(&smb_lock->clist); 713338c8a9a5SSteve French spin_unlock(&work->conn->llist_lock); 713438c8a9a5SSteve French 713538c8a9a5SSteve French locks_free_lock(smb_lock->fl); 713638c8a9a5SSteve French locks_free_lock(rlock); 713738c8a9a5SSteve French kfree(smb_lock); 713838c8a9a5SSteve French } 713938c8a9a5SSteve French out2: 714038c8a9a5SSteve French ksmbd_debug(SMB, "failed in taking lock(flags : %x), err : %d\n", flags, err); 714138c8a9a5SSteve French 714238c8a9a5SSteve French if (!rsp->hdr.Status) { 714338c8a9a5SSteve French if (err == -EINVAL) 714438c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 714538c8a9a5SSteve French else if (err == -ENOMEM) 714638c8a9a5SSteve French rsp->hdr.Status = STATUS_INSUFFICIENT_RESOURCES; 714738c8a9a5SSteve French else if (err == -ENOENT) 714838c8a9a5SSteve French rsp->hdr.Status = STATUS_FILE_CLOSED; 714938c8a9a5SSteve French else 715038c8a9a5SSteve French rsp->hdr.Status = STATUS_LOCK_NOT_GRANTED; 715138c8a9a5SSteve French } 715238c8a9a5SSteve French 715338c8a9a5SSteve French smb2_set_err_rsp(work); 715438c8a9a5SSteve French ksmbd_fd_put(work, fp); 715538c8a9a5SSteve French return err; 715638c8a9a5SSteve French } 715738c8a9a5SSteve French 715838c8a9a5SSteve French static int fsctl_copychunk(struct ksmbd_work *work, 715938c8a9a5SSteve French struct copychunk_ioctl_req *ci_req, 716038c8a9a5SSteve French unsigned int cnt_code, 716138c8a9a5SSteve French unsigned int input_count, 716238c8a9a5SSteve French unsigned long long volatile_id, 716338c8a9a5SSteve French unsigned long long persistent_id, 716438c8a9a5SSteve French struct smb2_ioctl_rsp *rsp) 716538c8a9a5SSteve French { 716638c8a9a5SSteve French struct copychunk_ioctl_rsp *ci_rsp; 716738c8a9a5SSteve French struct ksmbd_file *src_fp = NULL, *dst_fp = NULL; 716838c8a9a5SSteve French struct srv_copychunk *chunks; 716938c8a9a5SSteve French unsigned int i, chunk_count, chunk_count_written = 0; 717038c8a9a5SSteve French unsigned int chunk_size_written = 0; 717138c8a9a5SSteve French loff_t total_size_written = 0; 717238c8a9a5SSteve French int ret = 0; 717338c8a9a5SSteve French 717438c8a9a5SSteve French ci_rsp = (struct copychunk_ioctl_rsp *)&rsp->Buffer[0]; 717538c8a9a5SSteve French 717638c8a9a5SSteve French rsp->VolatileFileId = volatile_id; 717738c8a9a5SSteve French rsp->PersistentFileId = persistent_id; 717838c8a9a5SSteve French ci_rsp->ChunksWritten = 717938c8a9a5SSteve French cpu_to_le32(ksmbd_server_side_copy_max_chunk_count()); 718038c8a9a5SSteve French ci_rsp->ChunkBytesWritten = 718138c8a9a5SSteve French cpu_to_le32(ksmbd_server_side_copy_max_chunk_size()); 718238c8a9a5SSteve French ci_rsp->TotalBytesWritten = 718338c8a9a5SSteve French cpu_to_le32(ksmbd_server_side_copy_max_total_size()); 718438c8a9a5SSteve French 718538c8a9a5SSteve French chunks = (struct srv_copychunk *)&ci_req->Chunks[0]; 718638c8a9a5SSteve French chunk_count = le32_to_cpu(ci_req->ChunkCount); 718738c8a9a5SSteve French if (chunk_count == 0) 718838c8a9a5SSteve French goto out; 718938c8a9a5SSteve French total_size_written = 0; 719038c8a9a5SSteve French 719138c8a9a5SSteve French /* verify the SRV_COPYCHUNK_COPY packet */ 719238c8a9a5SSteve French if (chunk_count > ksmbd_server_side_copy_max_chunk_count() || 719338c8a9a5SSteve French input_count < offsetof(struct copychunk_ioctl_req, Chunks) + 719438c8a9a5SSteve French chunk_count * sizeof(struct srv_copychunk)) { 719538c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 719638c8a9a5SSteve French return -EINVAL; 719738c8a9a5SSteve French } 719838c8a9a5SSteve French 719938c8a9a5SSteve French for (i = 0; i < chunk_count; i++) { 720038c8a9a5SSteve French if (le32_to_cpu(chunks[i].Length) == 0 || 720138c8a9a5SSteve French le32_to_cpu(chunks[i].Length) > ksmbd_server_side_copy_max_chunk_size()) 720238c8a9a5SSteve French break; 720338c8a9a5SSteve French total_size_written += le32_to_cpu(chunks[i].Length); 720438c8a9a5SSteve French } 720538c8a9a5SSteve French 720638c8a9a5SSteve French if (i < chunk_count || 720738c8a9a5SSteve French total_size_written > ksmbd_server_side_copy_max_total_size()) { 720838c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 720938c8a9a5SSteve French return -EINVAL; 721038c8a9a5SSteve French } 721138c8a9a5SSteve French 721238c8a9a5SSteve French src_fp = ksmbd_lookup_foreign_fd(work, 721338c8a9a5SSteve French le64_to_cpu(ci_req->ResumeKey[0])); 721438c8a9a5SSteve French dst_fp = ksmbd_lookup_fd_slow(work, volatile_id, persistent_id); 721538c8a9a5SSteve French ret = -EINVAL; 721638c8a9a5SSteve French if (!src_fp || 721738c8a9a5SSteve French src_fp->persistent_id != le64_to_cpu(ci_req->ResumeKey[1])) { 721838c8a9a5SSteve French rsp->hdr.Status = STATUS_OBJECT_NAME_NOT_FOUND; 721938c8a9a5SSteve French goto out; 722038c8a9a5SSteve French } 722138c8a9a5SSteve French 722238c8a9a5SSteve French if (!dst_fp) { 722338c8a9a5SSteve French rsp->hdr.Status = STATUS_FILE_CLOSED; 722438c8a9a5SSteve French goto out; 722538c8a9a5SSteve French } 722638c8a9a5SSteve French 722738c8a9a5SSteve French /* 722838c8a9a5SSteve French * FILE_READ_DATA should only be included in 722938c8a9a5SSteve French * the FSCTL_COPYCHUNK case 723038c8a9a5SSteve French */ 723138c8a9a5SSteve French if (cnt_code == FSCTL_COPYCHUNK && 723238c8a9a5SSteve French !(dst_fp->daccess & (FILE_READ_DATA_LE | FILE_GENERIC_READ_LE))) { 723338c8a9a5SSteve French rsp->hdr.Status = STATUS_ACCESS_DENIED; 723438c8a9a5SSteve French goto out; 723538c8a9a5SSteve French } 723638c8a9a5SSteve French 723738c8a9a5SSteve French ret = ksmbd_vfs_copy_file_ranges(work, src_fp, dst_fp, 723838c8a9a5SSteve French chunks, chunk_count, 723938c8a9a5SSteve French &chunk_count_written, 724038c8a9a5SSteve French &chunk_size_written, 724138c8a9a5SSteve French &total_size_written); 724238c8a9a5SSteve French if (ret < 0) { 724338c8a9a5SSteve French if (ret == -EACCES) 724438c8a9a5SSteve French rsp->hdr.Status = STATUS_ACCESS_DENIED; 724538c8a9a5SSteve French if (ret == -EAGAIN) 724638c8a9a5SSteve French rsp->hdr.Status = STATUS_FILE_LOCK_CONFLICT; 724738c8a9a5SSteve French else if (ret == -EBADF) 724838c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_HANDLE; 724938c8a9a5SSteve French else if (ret == -EFBIG || ret == -ENOSPC) 725038c8a9a5SSteve French rsp->hdr.Status = STATUS_DISK_FULL; 725138c8a9a5SSteve French else if (ret == -EINVAL) 725238c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 725338c8a9a5SSteve French else if (ret == -EISDIR) 725438c8a9a5SSteve French rsp->hdr.Status = STATUS_FILE_IS_A_DIRECTORY; 725538c8a9a5SSteve French else if (ret == -E2BIG) 725638c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_VIEW_SIZE; 725738c8a9a5SSteve French else 725838c8a9a5SSteve French rsp->hdr.Status = STATUS_UNEXPECTED_IO_ERROR; 725938c8a9a5SSteve French } 726038c8a9a5SSteve French 726138c8a9a5SSteve French ci_rsp->ChunksWritten = cpu_to_le32(chunk_count_written); 726238c8a9a5SSteve French ci_rsp->ChunkBytesWritten = cpu_to_le32(chunk_size_written); 726338c8a9a5SSteve French ci_rsp->TotalBytesWritten = cpu_to_le32(total_size_written); 726438c8a9a5SSteve French out: 726538c8a9a5SSteve French ksmbd_fd_put(work, src_fp); 726638c8a9a5SSteve French ksmbd_fd_put(work, dst_fp); 726738c8a9a5SSteve French return ret; 726838c8a9a5SSteve French } 726938c8a9a5SSteve French 727038c8a9a5SSteve French static __be32 idev_ipv4_address(struct in_device *idev) 727138c8a9a5SSteve French { 727238c8a9a5SSteve French __be32 addr = 0; 727338c8a9a5SSteve French 727438c8a9a5SSteve French struct in_ifaddr *ifa; 727538c8a9a5SSteve French 727638c8a9a5SSteve French rcu_read_lock(); 727738c8a9a5SSteve French in_dev_for_each_ifa_rcu(ifa, idev) { 727838c8a9a5SSteve French if (ifa->ifa_flags & IFA_F_SECONDARY) 727938c8a9a5SSteve French continue; 728038c8a9a5SSteve French 728138c8a9a5SSteve French addr = ifa->ifa_address; 728238c8a9a5SSteve French break; 728338c8a9a5SSteve French } 728438c8a9a5SSteve French rcu_read_unlock(); 728538c8a9a5SSteve French return addr; 728638c8a9a5SSteve French } 728738c8a9a5SSteve French 728838c8a9a5SSteve French static int fsctl_query_iface_info_ioctl(struct ksmbd_conn *conn, 728938c8a9a5SSteve French struct smb2_ioctl_rsp *rsp, 729038c8a9a5SSteve French unsigned int out_buf_len) 729138c8a9a5SSteve French { 729238c8a9a5SSteve French struct network_interface_info_ioctl_rsp *nii_rsp = NULL; 729338c8a9a5SSteve French int nbytes = 0; 729438c8a9a5SSteve French struct net_device *netdev; 729538c8a9a5SSteve French struct sockaddr_storage_rsp *sockaddr_storage; 729638c8a9a5SSteve French unsigned int flags; 729738c8a9a5SSteve French unsigned long long speed; 729838c8a9a5SSteve French 729938c8a9a5SSteve French rtnl_lock(); 730038c8a9a5SSteve French for_each_netdev(&init_net, netdev) { 730138c8a9a5SSteve French bool ipv4_set = false; 730238c8a9a5SSteve French 730338c8a9a5SSteve French if (netdev->type == ARPHRD_LOOPBACK) 730438c8a9a5SSteve French continue; 730538c8a9a5SSteve French 730638c8a9a5SSteve French flags = dev_get_flags(netdev); 730738c8a9a5SSteve French if (!(flags & IFF_RUNNING)) 730838c8a9a5SSteve French continue; 730938c8a9a5SSteve French ipv6_retry: 731038c8a9a5SSteve French if (out_buf_len < 731138c8a9a5SSteve French nbytes + sizeof(struct network_interface_info_ioctl_rsp)) { 731238c8a9a5SSteve French rtnl_unlock(); 731338c8a9a5SSteve French return -ENOSPC; 731438c8a9a5SSteve French } 731538c8a9a5SSteve French 731638c8a9a5SSteve French nii_rsp = (struct network_interface_info_ioctl_rsp *) 731738c8a9a5SSteve French &rsp->Buffer[nbytes]; 731838c8a9a5SSteve French nii_rsp->IfIndex = cpu_to_le32(netdev->ifindex); 731938c8a9a5SSteve French 732038c8a9a5SSteve French nii_rsp->Capability = 0; 732138c8a9a5SSteve French if (netdev->real_num_tx_queues > 1) 732238c8a9a5SSteve French nii_rsp->Capability |= cpu_to_le32(RSS_CAPABLE); 732338c8a9a5SSteve French if (ksmbd_rdma_capable_netdev(netdev)) 732438c8a9a5SSteve French nii_rsp->Capability |= cpu_to_le32(RDMA_CAPABLE); 732538c8a9a5SSteve French 732638c8a9a5SSteve French nii_rsp->Next = cpu_to_le32(152); 732738c8a9a5SSteve French nii_rsp->Reserved = 0; 732838c8a9a5SSteve French 732938c8a9a5SSteve French if (netdev->ethtool_ops->get_link_ksettings) { 733038c8a9a5SSteve French struct ethtool_link_ksettings cmd; 733138c8a9a5SSteve French 733238c8a9a5SSteve French netdev->ethtool_ops->get_link_ksettings(netdev, &cmd); 733338c8a9a5SSteve French speed = cmd.base.speed; 733438c8a9a5SSteve French } else { 733538c8a9a5SSteve French ksmbd_debug(SMB, "%s %s\n", netdev->name, 733638c8a9a5SSteve French "speed is unknown, defaulting to 1Gb/sec"); 733738c8a9a5SSteve French speed = SPEED_1000; 733838c8a9a5SSteve French } 733938c8a9a5SSteve French 734038c8a9a5SSteve French speed *= 1000000; 734138c8a9a5SSteve French nii_rsp->LinkSpeed = cpu_to_le64(speed); 734238c8a9a5SSteve French 734338c8a9a5SSteve French sockaddr_storage = (struct sockaddr_storage_rsp *) 734438c8a9a5SSteve French nii_rsp->SockAddr_Storage; 734538c8a9a5SSteve French memset(sockaddr_storage, 0, 128); 734638c8a9a5SSteve French 734738c8a9a5SSteve French if (!ipv4_set) { 734838c8a9a5SSteve French struct in_device *idev; 734938c8a9a5SSteve French 735038c8a9a5SSteve French sockaddr_storage->Family = cpu_to_le16(INTERNETWORK); 735138c8a9a5SSteve French sockaddr_storage->addr4.Port = 0; 735238c8a9a5SSteve French 735338c8a9a5SSteve French idev = __in_dev_get_rtnl(netdev); 735438c8a9a5SSteve French if (!idev) 735538c8a9a5SSteve French continue; 735638c8a9a5SSteve French sockaddr_storage->addr4.IPv4address = 735738c8a9a5SSteve French idev_ipv4_address(idev); 735838c8a9a5SSteve French nbytes += sizeof(struct network_interface_info_ioctl_rsp); 735938c8a9a5SSteve French ipv4_set = true; 736038c8a9a5SSteve French goto ipv6_retry; 736138c8a9a5SSteve French } else { 736238c8a9a5SSteve French struct inet6_dev *idev6; 736338c8a9a5SSteve French struct inet6_ifaddr *ifa; 736438c8a9a5SSteve French __u8 *ipv6_addr = sockaddr_storage->addr6.IPv6address; 736538c8a9a5SSteve French 736638c8a9a5SSteve French sockaddr_storage->Family = cpu_to_le16(INTERNETWORKV6); 736738c8a9a5SSteve French sockaddr_storage->addr6.Port = 0; 736838c8a9a5SSteve French sockaddr_storage->addr6.FlowInfo = 0; 736938c8a9a5SSteve French 737038c8a9a5SSteve French idev6 = __in6_dev_get(netdev); 737138c8a9a5SSteve French if (!idev6) 737238c8a9a5SSteve French continue; 737338c8a9a5SSteve French 737438c8a9a5SSteve French list_for_each_entry(ifa, &idev6->addr_list, if_list) { 737538c8a9a5SSteve French if (ifa->flags & (IFA_F_TENTATIVE | 737638c8a9a5SSteve French IFA_F_DEPRECATED)) 737738c8a9a5SSteve French continue; 737838c8a9a5SSteve French memcpy(ipv6_addr, ifa->addr.s6_addr, 16); 737938c8a9a5SSteve French break; 738038c8a9a5SSteve French } 738138c8a9a5SSteve French sockaddr_storage->addr6.ScopeId = 0; 738238c8a9a5SSteve French nbytes += sizeof(struct network_interface_info_ioctl_rsp); 738338c8a9a5SSteve French } 738438c8a9a5SSteve French } 738538c8a9a5SSteve French rtnl_unlock(); 738638c8a9a5SSteve French 738738c8a9a5SSteve French /* zero if this is last one */ 738838c8a9a5SSteve French if (nii_rsp) 738938c8a9a5SSteve French nii_rsp->Next = 0; 739038c8a9a5SSteve French 739138c8a9a5SSteve French rsp->PersistentFileId = SMB2_NO_FID; 739238c8a9a5SSteve French rsp->VolatileFileId = SMB2_NO_FID; 739338c8a9a5SSteve French return nbytes; 739438c8a9a5SSteve French } 739538c8a9a5SSteve French 739638c8a9a5SSteve French static int fsctl_validate_negotiate_info(struct ksmbd_conn *conn, 739738c8a9a5SSteve French struct validate_negotiate_info_req *neg_req, 739838c8a9a5SSteve French struct validate_negotiate_info_rsp *neg_rsp, 739938c8a9a5SSteve French unsigned int in_buf_len) 740038c8a9a5SSteve French { 740138c8a9a5SSteve French int ret = 0; 740238c8a9a5SSteve French int dialect; 740338c8a9a5SSteve French 740438c8a9a5SSteve French if (in_buf_len < offsetof(struct validate_negotiate_info_req, Dialects) + 740538c8a9a5SSteve French le16_to_cpu(neg_req->DialectCount) * sizeof(__le16)) 740638c8a9a5SSteve French return -EINVAL; 740738c8a9a5SSteve French 740838c8a9a5SSteve French dialect = ksmbd_lookup_dialect_by_id(neg_req->Dialects, 740938c8a9a5SSteve French neg_req->DialectCount); 741038c8a9a5SSteve French if (dialect == BAD_PROT_ID || dialect != conn->dialect) { 741138c8a9a5SSteve French ret = -EINVAL; 741238c8a9a5SSteve French goto err_out; 741338c8a9a5SSteve French } 741438c8a9a5SSteve French 741538c8a9a5SSteve French if (strncmp(neg_req->Guid, conn->ClientGUID, SMB2_CLIENT_GUID_SIZE)) { 741638c8a9a5SSteve French ret = -EINVAL; 741738c8a9a5SSteve French goto err_out; 741838c8a9a5SSteve French } 741938c8a9a5SSteve French 742038c8a9a5SSteve French if (le16_to_cpu(neg_req->SecurityMode) != conn->cli_sec_mode) { 742138c8a9a5SSteve French ret = -EINVAL; 742238c8a9a5SSteve French goto err_out; 742338c8a9a5SSteve French } 742438c8a9a5SSteve French 742538c8a9a5SSteve French if (le32_to_cpu(neg_req->Capabilities) != conn->cli_cap) { 742638c8a9a5SSteve French ret = -EINVAL; 742738c8a9a5SSteve French goto err_out; 742838c8a9a5SSteve French } 742938c8a9a5SSteve French 743038c8a9a5SSteve French neg_rsp->Capabilities = cpu_to_le32(conn->vals->capabilities); 743138c8a9a5SSteve French memset(neg_rsp->Guid, 0, SMB2_CLIENT_GUID_SIZE); 743238c8a9a5SSteve French neg_rsp->SecurityMode = cpu_to_le16(conn->srv_sec_mode); 743338c8a9a5SSteve French neg_rsp->Dialect = cpu_to_le16(conn->dialect); 743438c8a9a5SSteve French err_out: 743538c8a9a5SSteve French return ret; 743638c8a9a5SSteve French } 743738c8a9a5SSteve French 743838c8a9a5SSteve French static int fsctl_query_allocated_ranges(struct ksmbd_work *work, u64 id, 743938c8a9a5SSteve French struct file_allocated_range_buffer *qar_req, 744038c8a9a5SSteve French struct file_allocated_range_buffer *qar_rsp, 744138c8a9a5SSteve French unsigned int in_count, unsigned int *out_count) 744238c8a9a5SSteve French { 744338c8a9a5SSteve French struct ksmbd_file *fp; 744438c8a9a5SSteve French loff_t start, length; 744538c8a9a5SSteve French int ret = 0; 744638c8a9a5SSteve French 744738c8a9a5SSteve French *out_count = 0; 744838c8a9a5SSteve French if (in_count == 0) 744938c8a9a5SSteve French return -EINVAL; 745038c8a9a5SSteve French 745138c8a9a5SSteve French start = le64_to_cpu(qar_req->file_offset); 745238c8a9a5SSteve French length = le64_to_cpu(qar_req->length); 745338c8a9a5SSteve French 745438c8a9a5SSteve French if (start < 0 || length < 0) 745538c8a9a5SSteve French return -EINVAL; 745638c8a9a5SSteve French 745738c8a9a5SSteve French fp = ksmbd_lookup_fd_fast(work, id); 745838c8a9a5SSteve French if (!fp) 745938c8a9a5SSteve French return -ENOENT; 746038c8a9a5SSteve French 746138c8a9a5SSteve French ret = ksmbd_vfs_fqar_lseek(fp, start, length, 746238c8a9a5SSteve French qar_rsp, in_count, out_count); 746338c8a9a5SSteve French if (ret && ret != -E2BIG) 746438c8a9a5SSteve French *out_count = 0; 746538c8a9a5SSteve French 746638c8a9a5SSteve French ksmbd_fd_put(work, fp); 746738c8a9a5SSteve French return ret; 746838c8a9a5SSteve French } 746938c8a9a5SSteve French 747038c8a9a5SSteve French static int fsctl_pipe_transceive(struct ksmbd_work *work, u64 id, 747138c8a9a5SSteve French unsigned int out_buf_len, 747238c8a9a5SSteve French struct smb2_ioctl_req *req, 747338c8a9a5SSteve French struct smb2_ioctl_rsp *rsp) 747438c8a9a5SSteve French { 747538c8a9a5SSteve French struct ksmbd_rpc_command *rpc_resp; 747638c8a9a5SSteve French char *data_buf = (char *)&req->Buffer[0]; 747738c8a9a5SSteve French int nbytes = 0; 747838c8a9a5SSteve French 747938c8a9a5SSteve French rpc_resp = ksmbd_rpc_ioctl(work->sess, id, data_buf, 748038c8a9a5SSteve French le32_to_cpu(req->InputCount)); 748138c8a9a5SSteve French if (rpc_resp) { 748238c8a9a5SSteve French if (rpc_resp->flags == KSMBD_RPC_SOME_NOT_MAPPED) { 748338c8a9a5SSteve French /* 748438c8a9a5SSteve French * set STATUS_SOME_NOT_MAPPED response 748538c8a9a5SSteve French * for unknown domain sid. 748638c8a9a5SSteve French */ 748738c8a9a5SSteve French rsp->hdr.Status = STATUS_SOME_NOT_MAPPED; 748838c8a9a5SSteve French } else if (rpc_resp->flags == KSMBD_RPC_ENOTIMPLEMENTED) { 748938c8a9a5SSteve French rsp->hdr.Status = STATUS_NOT_SUPPORTED; 749038c8a9a5SSteve French goto out; 749138c8a9a5SSteve French } else if (rpc_resp->flags != KSMBD_RPC_OK) { 749238c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 749338c8a9a5SSteve French goto out; 749438c8a9a5SSteve French } 749538c8a9a5SSteve French 749638c8a9a5SSteve French nbytes = rpc_resp->payload_sz; 749738c8a9a5SSteve French if (rpc_resp->payload_sz > out_buf_len) { 749838c8a9a5SSteve French rsp->hdr.Status = STATUS_BUFFER_OVERFLOW; 749938c8a9a5SSteve French nbytes = out_buf_len; 750038c8a9a5SSteve French } 750138c8a9a5SSteve French 750238c8a9a5SSteve French if (!rpc_resp->payload_sz) { 750338c8a9a5SSteve French rsp->hdr.Status = 750438c8a9a5SSteve French STATUS_UNEXPECTED_IO_ERROR; 750538c8a9a5SSteve French goto out; 750638c8a9a5SSteve French } 750738c8a9a5SSteve French 750838c8a9a5SSteve French memcpy((char *)rsp->Buffer, rpc_resp->payload, nbytes); 750938c8a9a5SSteve French } 751038c8a9a5SSteve French out: 751138c8a9a5SSteve French kvfree(rpc_resp); 751238c8a9a5SSteve French return nbytes; 751338c8a9a5SSteve French } 751438c8a9a5SSteve French 751538c8a9a5SSteve French static inline int fsctl_set_sparse(struct ksmbd_work *work, u64 id, 751638c8a9a5SSteve French struct file_sparse *sparse) 751738c8a9a5SSteve French { 751838c8a9a5SSteve French struct ksmbd_file *fp; 751938c8a9a5SSteve French struct mnt_idmap *idmap; 752038c8a9a5SSteve French int ret = 0; 752138c8a9a5SSteve French __le32 old_fattr; 752238c8a9a5SSteve French 752338c8a9a5SSteve French fp = ksmbd_lookup_fd_fast(work, id); 752438c8a9a5SSteve French if (!fp) 752538c8a9a5SSteve French return -ENOENT; 752638c8a9a5SSteve French idmap = file_mnt_idmap(fp->filp); 752738c8a9a5SSteve French 752838c8a9a5SSteve French old_fattr = fp->f_ci->m_fattr; 752938c8a9a5SSteve French if (sparse->SetSparse) 753038c8a9a5SSteve French fp->f_ci->m_fattr |= FILE_ATTRIBUTE_SPARSE_FILE_LE; 753138c8a9a5SSteve French else 753238c8a9a5SSteve French fp->f_ci->m_fattr &= ~FILE_ATTRIBUTE_SPARSE_FILE_LE; 753338c8a9a5SSteve French 753438c8a9a5SSteve French if (fp->f_ci->m_fattr != old_fattr && 753538c8a9a5SSteve French test_share_config_flag(work->tcon->share_conf, 753638c8a9a5SSteve French KSMBD_SHARE_FLAG_STORE_DOS_ATTRS)) { 753738c8a9a5SSteve French struct xattr_dos_attrib da; 753838c8a9a5SSteve French 753938c8a9a5SSteve French ret = ksmbd_vfs_get_dos_attrib_xattr(idmap, 754038c8a9a5SSteve French fp->filp->f_path.dentry, &da); 754138c8a9a5SSteve French if (ret <= 0) 754238c8a9a5SSteve French goto out; 754338c8a9a5SSteve French 754438c8a9a5SSteve French da.attr = le32_to_cpu(fp->f_ci->m_fattr); 754538c8a9a5SSteve French ret = ksmbd_vfs_set_dos_attrib_xattr(idmap, 754640b268d3SNamjae Jeon &fp->filp->f_path, &da); 754738c8a9a5SSteve French if (ret) 754838c8a9a5SSteve French fp->f_ci->m_fattr = old_fattr; 754938c8a9a5SSteve French } 755038c8a9a5SSteve French 755138c8a9a5SSteve French out: 755238c8a9a5SSteve French ksmbd_fd_put(work, fp); 755338c8a9a5SSteve French return ret; 755438c8a9a5SSteve French } 755538c8a9a5SSteve French 755638c8a9a5SSteve French static int fsctl_request_resume_key(struct ksmbd_work *work, 755738c8a9a5SSteve French struct smb2_ioctl_req *req, 755838c8a9a5SSteve French struct resume_key_ioctl_rsp *key_rsp) 755938c8a9a5SSteve French { 756038c8a9a5SSteve French struct ksmbd_file *fp; 756138c8a9a5SSteve French 756238c8a9a5SSteve French fp = ksmbd_lookup_fd_slow(work, req->VolatileFileId, req->PersistentFileId); 756338c8a9a5SSteve French if (!fp) 756438c8a9a5SSteve French return -ENOENT; 756538c8a9a5SSteve French 756638c8a9a5SSteve French memset(key_rsp, 0, sizeof(*key_rsp)); 756738c8a9a5SSteve French key_rsp->ResumeKey[0] = req->VolatileFileId; 756838c8a9a5SSteve French key_rsp->ResumeKey[1] = req->PersistentFileId; 756938c8a9a5SSteve French ksmbd_fd_put(work, fp); 757038c8a9a5SSteve French 757138c8a9a5SSteve French return 0; 757238c8a9a5SSteve French } 757338c8a9a5SSteve French 757438c8a9a5SSteve French /** 757538c8a9a5SSteve French * smb2_ioctl() - handler for smb2 ioctl command 757638c8a9a5SSteve French * @work: smb work containing ioctl command buffer 757738c8a9a5SSteve French * 757838c8a9a5SSteve French * Return: 0 on success, otherwise error 757938c8a9a5SSteve French */ 758038c8a9a5SSteve French int smb2_ioctl(struct ksmbd_work *work) 758138c8a9a5SSteve French { 758238c8a9a5SSteve French struct smb2_ioctl_req *req; 758338c8a9a5SSteve French struct smb2_ioctl_rsp *rsp; 758438c8a9a5SSteve French unsigned int cnt_code, nbytes = 0, out_buf_len, in_buf_len; 758538c8a9a5SSteve French u64 id = KSMBD_NO_FID; 758638c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 758738c8a9a5SSteve French int ret = 0; 758838c8a9a5SSteve French 758938c8a9a5SSteve French if (work->next_smb2_rcv_hdr_off) { 759038c8a9a5SSteve French req = ksmbd_req_buf_next(work); 759138c8a9a5SSteve French rsp = ksmbd_resp_buf_next(work); 759238c8a9a5SSteve French if (!has_file_id(req->VolatileFileId)) { 759338c8a9a5SSteve French ksmbd_debug(SMB, "Compound request set FID = %llu\n", 759438c8a9a5SSteve French work->compound_fid); 759538c8a9a5SSteve French id = work->compound_fid; 759638c8a9a5SSteve French } 759738c8a9a5SSteve French } else { 759838c8a9a5SSteve French req = smb2_get_msg(work->request_buf); 759938c8a9a5SSteve French rsp = smb2_get_msg(work->response_buf); 760038c8a9a5SSteve French } 760138c8a9a5SSteve French 760238c8a9a5SSteve French if (!has_file_id(id)) 760338c8a9a5SSteve French id = req->VolatileFileId; 760438c8a9a5SSteve French 760538c8a9a5SSteve French if (req->Flags != cpu_to_le32(SMB2_0_IOCTL_IS_FSCTL)) { 760638c8a9a5SSteve French rsp->hdr.Status = STATUS_NOT_SUPPORTED; 760738c8a9a5SSteve French goto out; 760838c8a9a5SSteve French } 760938c8a9a5SSteve French 761038c8a9a5SSteve French cnt_code = le32_to_cpu(req->CtlCode); 761138c8a9a5SSteve French ret = smb2_calc_max_out_buf_len(work, 48, 761238c8a9a5SSteve French le32_to_cpu(req->MaxOutputResponse)); 761338c8a9a5SSteve French if (ret < 0) { 761438c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 761538c8a9a5SSteve French goto out; 761638c8a9a5SSteve French } 761738c8a9a5SSteve French out_buf_len = (unsigned int)ret; 761838c8a9a5SSteve French in_buf_len = le32_to_cpu(req->InputCount); 761938c8a9a5SSteve French 762038c8a9a5SSteve French switch (cnt_code) { 762138c8a9a5SSteve French case FSCTL_DFS_GET_REFERRALS: 762238c8a9a5SSteve French case FSCTL_DFS_GET_REFERRALS_EX: 762338c8a9a5SSteve French /* Not support DFS yet */ 762438c8a9a5SSteve French rsp->hdr.Status = STATUS_FS_DRIVER_REQUIRED; 762538c8a9a5SSteve French goto out; 762638c8a9a5SSteve French case FSCTL_CREATE_OR_GET_OBJECT_ID: 762738c8a9a5SSteve French { 762838c8a9a5SSteve French struct file_object_buf_type1_ioctl_rsp *obj_buf; 762938c8a9a5SSteve French 763038c8a9a5SSteve French nbytes = sizeof(struct file_object_buf_type1_ioctl_rsp); 763138c8a9a5SSteve French obj_buf = (struct file_object_buf_type1_ioctl_rsp *) 763238c8a9a5SSteve French &rsp->Buffer[0]; 763338c8a9a5SSteve French 763438c8a9a5SSteve French /* 763538c8a9a5SSteve French * TODO: This is dummy implementation to pass smbtorture 763638c8a9a5SSteve French * Need to check correct response later 763738c8a9a5SSteve French */ 763838c8a9a5SSteve French memset(obj_buf->ObjectId, 0x0, 16); 763938c8a9a5SSteve French memset(obj_buf->BirthVolumeId, 0x0, 16); 764038c8a9a5SSteve French memset(obj_buf->BirthObjectId, 0x0, 16); 764138c8a9a5SSteve French memset(obj_buf->DomainId, 0x0, 16); 764238c8a9a5SSteve French 764338c8a9a5SSteve French break; 764438c8a9a5SSteve French } 764538c8a9a5SSteve French case FSCTL_PIPE_TRANSCEIVE: 764638c8a9a5SSteve French out_buf_len = min_t(u32, KSMBD_IPC_MAX_PAYLOAD, out_buf_len); 764738c8a9a5SSteve French nbytes = fsctl_pipe_transceive(work, id, out_buf_len, req, rsp); 764838c8a9a5SSteve French break; 764938c8a9a5SSteve French case FSCTL_VALIDATE_NEGOTIATE_INFO: 765038c8a9a5SSteve French if (conn->dialect < SMB30_PROT_ID) { 765138c8a9a5SSteve French ret = -EOPNOTSUPP; 765238c8a9a5SSteve French goto out; 765338c8a9a5SSteve French } 765438c8a9a5SSteve French 765538c8a9a5SSteve French if (in_buf_len < offsetof(struct validate_negotiate_info_req, 765638c8a9a5SSteve French Dialects)) { 765738c8a9a5SSteve French ret = -EINVAL; 765838c8a9a5SSteve French goto out; 765938c8a9a5SSteve French } 766038c8a9a5SSteve French 766138c8a9a5SSteve French if (out_buf_len < sizeof(struct validate_negotiate_info_rsp)) { 766238c8a9a5SSteve French ret = -EINVAL; 766338c8a9a5SSteve French goto out; 766438c8a9a5SSteve French } 766538c8a9a5SSteve French 766638c8a9a5SSteve French ret = fsctl_validate_negotiate_info(conn, 766738c8a9a5SSteve French (struct validate_negotiate_info_req *)&req->Buffer[0], 766838c8a9a5SSteve French (struct validate_negotiate_info_rsp *)&rsp->Buffer[0], 766938c8a9a5SSteve French in_buf_len); 767038c8a9a5SSteve French if (ret < 0) 767138c8a9a5SSteve French goto out; 767238c8a9a5SSteve French 767338c8a9a5SSteve French nbytes = sizeof(struct validate_negotiate_info_rsp); 767438c8a9a5SSteve French rsp->PersistentFileId = SMB2_NO_FID; 767538c8a9a5SSteve French rsp->VolatileFileId = SMB2_NO_FID; 767638c8a9a5SSteve French break; 767738c8a9a5SSteve French case FSCTL_QUERY_NETWORK_INTERFACE_INFO: 767838c8a9a5SSteve French ret = fsctl_query_iface_info_ioctl(conn, rsp, out_buf_len); 767938c8a9a5SSteve French if (ret < 0) 768038c8a9a5SSteve French goto out; 768138c8a9a5SSteve French nbytes = ret; 768238c8a9a5SSteve French break; 768338c8a9a5SSteve French case FSCTL_REQUEST_RESUME_KEY: 768438c8a9a5SSteve French if (out_buf_len < sizeof(struct resume_key_ioctl_rsp)) { 768538c8a9a5SSteve French ret = -EINVAL; 768638c8a9a5SSteve French goto out; 768738c8a9a5SSteve French } 768838c8a9a5SSteve French 768938c8a9a5SSteve French ret = fsctl_request_resume_key(work, req, 769038c8a9a5SSteve French (struct resume_key_ioctl_rsp *)&rsp->Buffer[0]); 769138c8a9a5SSteve French if (ret < 0) 769238c8a9a5SSteve French goto out; 769338c8a9a5SSteve French rsp->PersistentFileId = req->PersistentFileId; 769438c8a9a5SSteve French rsp->VolatileFileId = req->VolatileFileId; 769538c8a9a5SSteve French nbytes = sizeof(struct resume_key_ioctl_rsp); 769638c8a9a5SSteve French break; 769738c8a9a5SSteve French case FSCTL_COPYCHUNK: 769838c8a9a5SSteve French case FSCTL_COPYCHUNK_WRITE: 769938c8a9a5SSteve French if (!test_tree_conn_flag(work->tcon, KSMBD_TREE_CONN_FLAG_WRITABLE)) { 770038c8a9a5SSteve French ksmbd_debug(SMB, 770138c8a9a5SSteve French "User does not have write permission\n"); 770238c8a9a5SSteve French ret = -EACCES; 770338c8a9a5SSteve French goto out; 770438c8a9a5SSteve French } 770538c8a9a5SSteve French 770638c8a9a5SSteve French if (in_buf_len < sizeof(struct copychunk_ioctl_req)) { 770738c8a9a5SSteve French ret = -EINVAL; 770838c8a9a5SSteve French goto out; 770938c8a9a5SSteve French } 771038c8a9a5SSteve French 771138c8a9a5SSteve French if (out_buf_len < sizeof(struct copychunk_ioctl_rsp)) { 771238c8a9a5SSteve French ret = -EINVAL; 771338c8a9a5SSteve French goto out; 771438c8a9a5SSteve French } 771538c8a9a5SSteve French 771638c8a9a5SSteve French nbytes = sizeof(struct copychunk_ioctl_rsp); 771738c8a9a5SSteve French rsp->VolatileFileId = req->VolatileFileId; 771838c8a9a5SSteve French rsp->PersistentFileId = req->PersistentFileId; 771938c8a9a5SSteve French fsctl_copychunk(work, 772038c8a9a5SSteve French (struct copychunk_ioctl_req *)&req->Buffer[0], 772138c8a9a5SSteve French le32_to_cpu(req->CtlCode), 772238c8a9a5SSteve French le32_to_cpu(req->InputCount), 772338c8a9a5SSteve French req->VolatileFileId, 772438c8a9a5SSteve French req->PersistentFileId, 772538c8a9a5SSteve French rsp); 772638c8a9a5SSteve French break; 772738c8a9a5SSteve French case FSCTL_SET_SPARSE: 772838c8a9a5SSteve French if (in_buf_len < sizeof(struct file_sparse)) { 772938c8a9a5SSteve French ret = -EINVAL; 773038c8a9a5SSteve French goto out; 773138c8a9a5SSteve French } 773238c8a9a5SSteve French 773338c8a9a5SSteve French ret = fsctl_set_sparse(work, id, 773438c8a9a5SSteve French (struct file_sparse *)&req->Buffer[0]); 773538c8a9a5SSteve French if (ret < 0) 773638c8a9a5SSteve French goto out; 773738c8a9a5SSteve French break; 773838c8a9a5SSteve French case FSCTL_SET_ZERO_DATA: 773938c8a9a5SSteve French { 774038c8a9a5SSteve French struct file_zero_data_information *zero_data; 774138c8a9a5SSteve French struct ksmbd_file *fp; 774238c8a9a5SSteve French loff_t off, len, bfz; 774338c8a9a5SSteve French 774438c8a9a5SSteve French if (!test_tree_conn_flag(work->tcon, KSMBD_TREE_CONN_FLAG_WRITABLE)) { 774538c8a9a5SSteve French ksmbd_debug(SMB, 774638c8a9a5SSteve French "User does not have write permission\n"); 774738c8a9a5SSteve French ret = -EACCES; 774838c8a9a5SSteve French goto out; 774938c8a9a5SSteve French } 775038c8a9a5SSteve French 775138c8a9a5SSteve French if (in_buf_len < sizeof(struct file_zero_data_information)) { 775238c8a9a5SSteve French ret = -EINVAL; 775338c8a9a5SSteve French goto out; 775438c8a9a5SSteve French } 775538c8a9a5SSteve French 775638c8a9a5SSteve French zero_data = 775738c8a9a5SSteve French (struct file_zero_data_information *)&req->Buffer[0]; 775838c8a9a5SSteve French 775938c8a9a5SSteve French off = le64_to_cpu(zero_data->FileOffset); 776038c8a9a5SSteve French bfz = le64_to_cpu(zero_data->BeyondFinalZero); 776138c8a9a5SSteve French if (off < 0 || bfz < 0 || off > bfz) { 776238c8a9a5SSteve French ret = -EINVAL; 776338c8a9a5SSteve French goto out; 776438c8a9a5SSteve French } 776538c8a9a5SSteve French 776638c8a9a5SSteve French len = bfz - off; 776738c8a9a5SSteve French if (len) { 776838c8a9a5SSteve French fp = ksmbd_lookup_fd_fast(work, id); 776938c8a9a5SSteve French if (!fp) { 777038c8a9a5SSteve French ret = -ENOENT; 777138c8a9a5SSteve French goto out; 777238c8a9a5SSteve French } 777338c8a9a5SSteve French 777438c8a9a5SSteve French ret = ksmbd_vfs_zero_data(work, fp, off, len); 777538c8a9a5SSteve French ksmbd_fd_put(work, fp); 777638c8a9a5SSteve French if (ret < 0) 777738c8a9a5SSteve French goto out; 777838c8a9a5SSteve French } 777938c8a9a5SSteve French break; 778038c8a9a5SSteve French } 778138c8a9a5SSteve French case FSCTL_QUERY_ALLOCATED_RANGES: 778238c8a9a5SSteve French if (in_buf_len < sizeof(struct file_allocated_range_buffer)) { 778338c8a9a5SSteve French ret = -EINVAL; 778438c8a9a5SSteve French goto out; 778538c8a9a5SSteve French } 778638c8a9a5SSteve French 778738c8a9a5SSteve French ret = fsctl_query_allocated_ranges(work, id, 778838c8a9a5SSteve French (struct file_allocated_range_buffer *)&req->Buffer[0], 778938c8a9a5SSteve French (struct file_allocated_range_buffer *)&rsp->Buffer[0], 779038c8a9a5SSteve French out_buf_len / 779138c8a9a5SSteve French sizeof(struct file_allocated_range_buffer), &nbytes); 779238c8a9a5SSteve French if (ret == -E2BIG) { 779338c8a9a5SSteve French rsp->hdr.Status = STATUS_BUFFER_OVERFLOW; 779438c8a9a5SSteve French } else if (ret < 0) { 779538c8a9a5SSteve French nbytes = 0; 779638c8a9a5SSteve French goto out; 779738c8a9a5SSteve French } 779838c8a9a5SSteve French 779938c8a9a5SSteve French nbytes *= sizeof(struct file_allocated_range_buffer); 780038c8a9a5SSteve French break; 780138c8a9a5SSteve French case FSCTL_GET_REPARSE_POINT: 780238c8a9a5SSteve French { 780338c8a9a5SSteve French struct reparse_data_buffer *reparse_ptr; 780438c8a9a5SSteve French struct ksmbd_file *fp; 780538c8a9a5SSteve French 780638c8a9a5SSteve French reparse_ptr = (struct reparse_data_buffer *)&rsp->Buffer[0]; 780738c8a9a5SSteve French fp = ksmbd_lookup_fd_fast(work, id); 780838c8a9a5SSteve French if (!fp) { 780938c8a9a5SSteve French pr_err("not found fp!!\n"); 781038c8a9a5SSteve French ret = -ENOENT; 781138c8a9a5SSteve French goto out; 781238c8a9a5SSteve French } 781338c8a9a5SSteve French 781438c8a9a5SSteve French reparse_ptr->ReparseTag = 781538c8a9a5SSteve French smb2_get_reparse_tag_special_file(file_inode(fp->filp)->i_mode); 781638c8a9a5SSteve French reparse_ptr->ReparseDataLength = 0; 781738c8a9a5SSteve French ksmbd_fd_put(work, fp); 781838c8a9a5SSteve French nbytes = sizeof(struct reparse_data_buffer); 781938c8a9a5SSteve French break; 782038c8a9a5SSteve French } 782138c8a9a5SSteve French case FSCTL_DUPLICATE_EXTENTS_TO_FILE: 782238c8a9a5SSteve French { 782338c8a9a5SSteve French struct ksmbd_file *fp_in, *fp_out = NULL; 782438c8a9a5SSteve French struct duplicate_extents_to_file *dup_ext; 782538c8a9a5SSteve French loff_t src_off, dst_off, length, cloned; 782638c8a9a5SSteve French 782738c8a9a5SSteve French if (in_buf_len < sizeof(struct duplicate_extents_to_file)) { 782838c8a9a5SSteve French ret = -EINVAL; 782938c8a9a5SSteve French goto out; 783038c8a9a5SSteve French } 783138c8a9a5SSteve French 783238c8a9a5SSteve French dup_ext = (struct duplicate_extents_to_file *)&req->Buffer[0]; 783338c8a9a5SSteve French 783438c8a9a5SSteve French fp_in = ksmbd_lookup_fd_slow(work, dup_ext->VolatileFileHandle, 783538c8a9a5SSteve French dup_ext->PersistentFileHandle); 783638c8a9a5SSteve French if (!fp_in) { 783738c8a9a5SSteve French pr_err("not found file handle in duplicate extent to file\n"); 783838c8a9a5SSteve French ret = -ENOENT; 783938c8a9a5SSteve French goto out; 784038c8a9a5SSteve French } 784138c8a9a5SSteve French 784238c8a9a5SSteve French fp_out = ksmbd_lookup_fd_fast(work, id); 784338c8a9a5SSteve French if (!fp_out) { 784438c8a9a5SSteve French pr_err("not found fp\n"); 784538c8a9a5SSteve French ret = -ENOENT; 784638c8a9a5SSteve French goto dup_ext_out; 784738c8a9a5SSteve French } 784838c8a9a5SSteve French 784938c8a9a5SSteve French src_off = le64_to_cpu(dup_ext->SourceFileOffset); 785038c8a9a5SSteve French dst_off = le64_to_cpu(dup_ext->TargetFileOffset); 785138c8a9a5SSteve French length = le64_to_cpu(dup_ext->ByteCount); 785238c8a9a5SSteve French /* 785338c8a9a5SSteve French * XXX: It is not clear if FSCTL_DUPLICATE_EXTENTS_TO_FILE 785438c8a9a5SSteve French * should fall back to vfs_copy_file_range(). This could be 785538c8a9a5SSteve French * beneficial when re-exporting nfs/smb mount, but note that 785638c8a9a5SSteve French * this can result in partial copy that returns an error status. 785738c8a9a5SSteve French * If/when FSCTL_DUPLICATE_EXTENTS_TO_FILE_EX is implemented, 785838c8a9a5SSteve French * fall back to vfs_copy_file_range(), should be avoided when 785938c8a9a5SSteve French * the flag DUPLICATE_EXTENTS_DATA_EX_SOURCE_ATOMIC is set. 786038c8a9a5SSteve French */ 786138c8a9a5SSteve French cloned = vfs_clone_file_range(fp_in->filp, src_off, 786238c8a9a5SSteve French fp_out->filp, dst_off, length, 0); 786338c8a9a5SSteve French if (cloned == -EXDEV || cloned == -EOPNOTSUPP) { 786438c8a9a5SSteve French ret = -EOPNOTSUPP; 786538c8a9a5SSteve French goto dup_ext_out; 786638c8a9a5SSteve French } else if (cloned != length) { 786738c8a9a5SSteve French cloned = vfs_copy_file_range(fp_in->filp, src_off, 786838c8a9a5SSteve French fp_out->filp, dst_off, 786938c8a9a5SSteve French length, 0); 787038c8a9a5SSteve French if (cloned != length) { 787138c8a9a5SSteve French if (cloned < 0) 787238c8a9a5SSteve French ret = cloned; 787338c8a9a5SSteve French else 787438c8a9a5SSteve French ret = -EINVAL; 787538c8a9a5SSteve French } 787638c8a9a5SSteve French } 787738c8a9a5SSteve French 787838c8a9a5SSteve French dup_ext_out: 787938c8a9a5SSteve French ksmbd_fd_put(work, fp_in); 788038c8a9a5SSteve French ksmbd_fd_put(work, fp_out); 788138c8a9a5SSteve French if (ret < 0) 788238c8a9a5SSteve French goto out; 788338c8a9a5SSteve French break; 788438c8a9a5SSteve French } 788538c8a9a5SSteve French default: 788638c8a9a5SSteve French ksmbd_debug(SMB, "not implemented yet ioctl command 0x%x\n", 788738c8a9a5SSteve French cnt_code); 788838c8a9a5SSteve French ret = -EOPNOTSUPP; 788938c8a9a5SSteve French goto out; 789038c8a9a5SSteve French } 789138c8a9a5SSteve French 789238c8a9a5SSteve French rsp->CtlCode = cpu_to_le32(cnt_code); 789338c8a9a5SSteve French rsp->InputCount = cpu_to_le32(0); 789438c8a9a5SSteve French rsp->InputOffset = cpu_to_le32(112); 789538c8a9a5SSteve French rsp->OutputOffset = cpu_to_le32(112); 789638c8a9a5SSteve French rsp->OutputCount = cpu_to_le32(nbytes); 789738c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(49); 789838c8a9a5SSteve French rsp->Reserved = cpu_to_le16(0); 789938c8a9a5SSteve French rsp->Flags = cpu_to_le32(0); 790038c8a9a5SSteve French rsp->Reserved2 = cpu_to_le32(0); 790138c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 48 + nbytes); 790238c8a9a5SSteve French 790338c8a9a5SSteve French return 0; 790438c8a9a5SSteve French 790538c8a9a5SSteve French out: 790638c8a9a5SSteve French if (ret == -EACCES) 790738c8a9a5SSteve French rsp->hdr.Status = STATUS_ACCESS_DENIED; 790838c8a9a5SSteve French else if (ret == -ENOENT) 790938c8a9a5SSteve French rsp->hdr.Status = STATUS_OBJECT_NAME_NOT_FOUND; 791038c8a9a5SSteve French else if (ret == -EOPNOTSUPP) 791138c8a9a5SSteve French rsp->hdr.Status = STATUS_NOT_SUPPORTED; 791238c8a9a5SSteve French else if (ret == -ENOSPC) 791338c8a9a5SSteve French rsp->hdr.Status = STATUS_BUFFER_TOO_SMALL; 791438c8a9a5SSteve French else if (ret < 0 || rsp->hdr.Status == 0) 791538c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 791638c8a9a5SSteve French smb2_set_err_rsp(work); 791738c8a9a5SSteve French return 0; 791838c8a9a5SSteve French } 791938c8a9a5SSteve French 792038c8a9a5SSteve French /** 792138c8a9a5SSteve French * smb20_oplock_break_ack() - handler for smb2.0 oplock break command 792238c8a9a5SSteve French * @work: smb work containing oplock break command buffer 792338c8a9a5SSteve French * 792438c8a9a5SSteve French * Return: 0 792538c8a9a5SSteve French */ 792638c8a9a5SSteve French static void smb20_oplock_break_ack(struct ksmbd_work *work) 792738c8a9a5SSteve French { 79287b7d709eSNamjae Jeon struct smb2_oplock_break *req; 79297b7d709eSNamjae Jeon struct smb2_oplock_break *rsp; 793038c8a9a5SSteve French struct ksmbd_file *fp; 793138c8a9a5SSteve French struct oplock_info *opinfo = NULL; 793238c8a9a5SSteve French __le32 err = 0; 793338c8a9a5SSteve French int ret = 0; 793438c8a9a5SSteve French u64 volatile_id, persistent_id; 793538c8a9a5SSteve French char req_oplevel = 0, rsp_oplevel = 0; 793638c8a9a5SSteve French unsigned int oplock_change_type; 793738c8a9a5SSteve French 79387b7d709eSNamjae Jeon WORK_BUFFERS(work, req, rsp); 79397b7d709eSNamjae Jeon 794038c8a9a5SSteve French volatile_id = req->VolatileFid; 794138c8a9a5SSteve French persistent_id = req->PersistentFid; 794238c8a9a5SSteve French req_oplevel = req->OplockLevel; 794338c8a9a5SSteve French ksmbd_debug(OPLOCK, "v_id %llu, p_id %llu request oplock level %d\n", 794438c8a9a5SSteve French volatile_id, persistent_id, req_oplevel); 794538c8a9a5SSteve French 794638c8a9a5SSteve French fp = ksmbd_lookup_fd_slow(work, volatile_id, persistent_id); 794738c8a9a5SSteve French if (!fp) { 794838c8a9a5SSteve French rsp->hdr.Status = STATUS_FILE_CLOSED; 794938c8a9a5SSteve French smb2_set_err_rsp(work); 795038c8a9a5SSteve French return; 795138c8a9a5SSteve French } 795238c8a9a5SSteve French 795338c8a9a5SSteve French opinfo = opinfo_get(fp); 795438c8a9a5SSteve French if (!opinfo) { 795538c8a9a5SSteve French pr_err("unexpected null oplock_info\n"); 795638c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_OPLOCK_PROTOCOL; 795738c8a9a5SSteve French smb2_set_err_rsp(work); 795838c8a9a5SSteve French ksmbd_fd_put(work, fp); 795938c8a9a5SSteve French return; 796038c8a9a5SSteve French } 796138c8a9a5SSteve French 796238c8a9a5SSteve French if (opinfo->level == SMB2_OPLOCK_LEVEL_NONE) { 796338c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_OPLOCK_PROTOCOL; 796438c8a9a5SSteve French goto err_out; 796538c8a9a5SSteve French } 796638c8a9a5SSteve French 796738c8a9a5SSteve French if (opinfo->op_state == OPLOCK_STATE_NONE) { 796838c8a9a5SSteve French ksmbd_debug(SMB, "unexpected oplock state 0x%x\n", opinfo->op_state); 796938c8a9a5SSteve French rsp->hdr.Status = STATUS_UNSUCCESSFUL; 797038c8a9a5SSteve French goto err_out; 797138c8a9a5SSteve French } 797238c8a9a5SSteve French 797338c8a9a5SSteve French if ((opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE || 797438c8a9a5SSteve French opinfo->level == SMB2_OPLOCK_LEVEL_BATCH) && 797538c8a9a5SSteve French (req_oplevel != SMB2_OPLOCK_LEVEL_II && 797638c8a9a5SSteve French req_oplevel != SMB2_OPLOCK_LEVEL_NONE)) { 797738c8a9a5SSteve French err = STATUS_INVALID_OPLOCK_PROTOCOL; 797838c8a9a5SSteve French oplock_change_type = OPLOCK_WRITE_TO_NONE; 797938c8a9a5SSteve French } else if (opinfo->level == SMB2_OPLOCK_LEVEL_II && 798038c8a9a5SSteve French req_oplevel != SMB2_OPLOCK_LEVEL_NONE) { 798138c8a9a5SSteve French err = STATUS_INVALID_OPLOCK_PROTOCOL; 798238c8a9a5SSteve French oplock_change_type = OPLOCK_READ_TO_NONE; 798338c8a9a5SSteve French } else if (req_oplevel == SMB2_OPLOCK_LEVEL_II || 798438c8a9a5SSteve French req_oplevel == SMB2_OPLOCK_LEVEL_NONE) { 798538c8a9a5SSteve French err = STATUS_INVALID_DEVICE_STATE; 798638c8a9a5SSteve French if ((opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE || 798738c8a9a5SSteve French opinfo->level == SMB2_OPLOCK_LEVEL_BATCH) && 798838c8a9a5SSteve French req_oplevel == SMB2_OPLOCK_LEVEL_II) { 798938c8a9a5SSteve French oplock_change_type = OPLOCK_WRITE_TO_READ; 799038c8a9a5SSteve French } else if ((opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE || 799138c8a9a5SSteve French opinfo->level == SMB2_OPLOCK_LEVEL_BATCH) && 799238c8a9a5SSteve French req_oplevel == SMB2_OPLOCK_LEVEL_NONE) { 799338c8a9a5SSteve French oplock_change_type = OPLOCK_WRITE_TO_NONE; 799438c8a9a5SSteve French } else if (opinfo->level == SMB2_OPLOCK_LEVEL_II && 799538c8a9a5SSteve French req_oplevel == SMB2_OPLOCK_LEVEL_NONE) { 799638c8a9a5SSteve French oplock_change_type = OPLOCK_READ_TO_NONE; 799738c8a9a5SSteve French } else { 799838c8a9a5SSteve French oplock_change_type = 0; 799938c8a9a5SSteve French } 800038c8a9a5SSteve French } else { 800138c8a9a5SSteve French oplock_change_type = 0; 800238c8a9a5SSteve French } 800338c8a9a5SSteve French 800438c8a9a5SSteve French switch (oplock_change_type) { 800538c8a9a5SSteve French case OPLOCK_WRITE_TO_READ: 800638c8a9a5SSteve French ret = opinfo_write_to_read(opinfo); 800738c8a9a5SSteve French rsp_oplevel = SMB2_OPLOCK_LEVEL_II; 800838c8a9a5SSteve French break; 800938c8a9a5SSteve French case OPLOCK_WRITE_TO_NONE: 801038c8a9a5SSteve French ret = opinfo_write_to_none(opinfo); 801138c8a9a5SSteve French rsp_oplevel = SMB2_OPLOCK_LEVEL_NONE; 801238c8a9a5SSteve French break; 801338c8a9a5SSteve French case OPLOCK_READ_TO_NONE: 801438c8a9a5SSteve French ret = opinfo_read_to_none(opinfo); 801538c8a9a5SSteve French rsp_oplevel = SMB2_OPLOCK_LEVEL_NONE; 801638c8a9a5SSteve French break; 801738c8a9a5SSteve French default: 801838c8a9a5SSteve French pr_err("unknown oplock change 0x%x -> 0x%x\n", 801938c8a9a5SSteve French opinfo->level, rsp_oplevel); 802038c8a9a5SSteve French } 802138c8a9a5SSteve French 802238c8a9a5SSteve French if (ret < 0) { 802338c8a9a5SSteve French rsp->hdr.Status = err; 802438c8a9a5SSteve French goto err_out; 802538c8a9a5SSteve French } 802638c8a9a5SSteve French 802738c8a9a5SSteve French opinfo_put(opinfo); 802838c8a9a5SSteve French ksmbd_fd_put(work, fp); 802938c8a9a5SSteve French opinfo->op_state = OPLOCK_STATE_NONE; 803038c8a9a5SSteve French wake_up_interruptible_all(&opinfo->oplock_q); 803138c8a9a5SSteve French 803238c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(24); 803338c8a9a5SSteve French rsp->OplockLevel = rsp_oplevel; 803438c8a9a5SSteve French rsp->Reserved = 0; 803538c8a9a5SSteve French rsp->Reserved2 = 0; 803638c8a9a5SSteve French rsp->VolatileFid = volatile_id; 803738c8a9a5SSteve French rsp->PersistentFid = persistent_id; 803838c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 24); 803938c8a9a5SSteve French return; 804038c8a9a5SSteve French 804138c8a9a5SSteve French err_out: 804238c8a9a5SSteve French opinfo->op_state = OPLOCK_STATE_NONE; 804338c8a9a5SSteve French wake_up_interruptible_all(&opinfo->oplock_q); 804438c8a9a5SSteve French 804538c8a9a5SSteve French opinfo_put(opinfo); 804638c8a9a5SSteve French ksmbd_fd_put(work, fp); 804738c8a9a5SSteve French smb2_set_err_rsp(work); 804838c8a9a5SSteve French } 804938c8a9a5SSteve French 805038c8a9a5SSteve French static int check_lease_state(struct lease *lease, __le32 req_state) 805138c8a9a5SSteve French { 805238c8a9a5SSteve French if ((lease->new_state == 805338c8a9a5SSteve French (SMB2_LEASE_READ_CACHING_LE | SMB2_LEASE_HANDLE_CACHING_LE)) && 805438c8a9a5SSteve French !(req_state & SMB2_LEASE_WRITE_CACHING_LE)) { 805538c8a9a5SSteve French lease->new_state = req_state; 805638c8a9a5SSteve French return 0; 805738c8a9a5SSteve French } 805838c8a9a5SSteve French 805938c8a9a5SSteve French if (lease->new_state == req_state) 806038c8a9a5SSteve French return 0; 806138c8a9a5SSteve French 806238c8a9a5SSteve French return 1; 806338c8a9a5SSteve French } 806438c8a9a5SSteve French 806538c8a9a5SSteve French /** 806638c8a9a5SSteve French * smb21_lease_break_ack() - handler for smb2.1 lease break command 806738c8a9a5SSteve French * @work: smb work containing lease break command buffer 806838c8a9a5SSteve French * 806938c8a9a5SSteve French * Return: 0 807038c8a9a5SSteve French */ 807138c8a9a5SSteve French static void smb21_lease_break_ack(struct ksmbd_work *work) 807238c8a9a5SSteve French { 807338c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 80747b7d709eSNamjae Jeon struct smb2_lease_ack *req; 80757b7d709eSNamjae Jeon struct smb2_lease_ack *rsp; 807638c8a9a5SSteve French struct oplock_info *opinfo; 807738c8a9a5SSteve French __le32 err = 0; 807838c8a9a5SSteve French int ret = 0; 807938c8a9a5SSteve French unsigned int lease_change_type; 808038c8a9a5SSteve French __le32 lease_state; 808138c8a9a5SSteve French struct lease *lease; 808238c8a9a5SSteve French 80837b7d709eSNamjae Jeon WORK_BUFFERS(work, req, rsp); 80847b7d709eSNamjae Jeon 808538c8a9a5SSteve French ksmbd_debug(OPLOCK, "smb21 lease break, lease state(0x%x)\n", 808638c8a9a5SSteve French le32_to_cpu(req->LeaseState)); 808738c8a9a5SSteve French opinfo = lookup_lease_in_table(conn, req->LeaseKey); 808838c8a9a5SSteve French if (!opinfo) { 808938c8a9a5SSteve French ksmbd_debug(OPLOCK, "file not opened\n"); 809038c8a9a5SSteve French smb2_set_err_rsp(work); 809138c8a9a5SSteve French rsp->hdr.Status = STATUS_UNSUCCESSFUL; 809238c8a9a5SSteve French return; 809338c8a9a5SSteve French } 809438c8a9a5SSteve French lease = opinfo->o_lease; 809538c8a9a5SSteve French 809638c8a9a5SSteve French if (opinfo->op_state == OPLOCK_STATE_NONE) { 809738c8a9a5SSteve French pr_err("unexpected lease break state 0x%x\n", 809838c8a9a5SSteve French opinfo->op_state); 809938c8a9a5SSteve French rsp->hdr.Status = STATUS_UNSUCCESSFUL; 810038c8a9a5SSteve French goto err_out; 810138c8a9a5SSteve French } 810238c8a9a5SSteve French 810338c8a9a5SSteve French if (check_lease_state(lease, req->LeaseState)) { 810438c8a9a5SSteve French rsp->hdr.Status = STATUS_REQUEST_NOT_ACCEPTED; 810538c8a9a5SSteve French ksmbd_debug(OPLOCK, 810638c8a9a5SSteve French "req lease state: 0x%x, expected state: 0x%x\n", 810738c8a9a5SSteve French req->LeaseState, lease->new_state); 810838c8a9a5SSteve French goto err_out; 810938c8a9a5SSteve French } 811038c8a9a5SSteve French 811138c8a9a5SSteve French if (!atomic_read(&opinfo->breaking_cnt)) { 811238c8a9a5SSteve French rsp->hdr.Status = STATUS_UNSUCCESSFUL; 811338c8a9a5SSteve French goto err_out; 811438c8a9a5SSteve French } 811538c8a9a5SSteve French 811638c8a9a5SSteve French /* check for bad lease state */ 811738c8a9a5SSteve French if (req->LeaseState & 811838c8a9a5SSteve French (~(SMB2_LEASE_READ_CACHING_LE | SMB2_LEASE_HANDLE_CACHING_LE))) { 811938c8a9a5SSteve French err = STATUS_INVALID_OPLOCK_PROTOCOL; 812038c8a9a5SSteve French if (lease->state & SMB2_LEASE_WRITE_CACHING_LE) 812138c8a9a5SSteve French lease_change_type = OPLOCK_WRITE_TO_NONE; 812238c8a9a5SSteve French else 812338c8a9a5SSteve French lease_change_type = OPLOCK_READ_TO_NONE; 812438c8a9a5SSteve French ksmbd_debug(OPLOCK, "handle bad lease state 0x%x -> 0x%x\n", 812538c8a9a5SSteve French le32_to_cpu(lease->state), 812638c8a9a5SSteve French le32_to_cpu(req->LeaseState)); 812738c8a9a5SSteve French } else if (lease->state == SMB2_LEASE_READ_CACHING_LE && 812838c8a9a5SSteve French req->LeaseState != SMB2_LEASE_NONE_LE) { 812938c8a9a5SSteve French err = STATUS_INVALID_OPLOCK_PROTOCOL; 813038c8a9a5SSteve French lease_change_type = OPLOCK_READ_TO_NONE; 813138c8a9a5SSteve French ksmbd_debug(OPLOCK, "handle bad lease state 0x%x -> 0x%x\n", 813238c8a9a5SSteve French le32_to_cpu(lease->state), 813338c8a9a5SSteve French le32_to_cpu(req->LeaseState)); 813438c8a9a5SSteve French } else { 813538c8a9a5SSteve French /* valid lease state changes */ 813638c8a9a5SSteve French err = STATUS_INVALID_DEVICE_STATE; 813738c8a9a5SSteve French if (req->LeaseState == SMB2_LEASE_NONE_LE) { 813838c8a9a5SSteve French if (lease->state & SMB2_LEASE_WRITE_CACHING_LE) 813938c8a9a5SSteve French lease_change_type = OPLOCK_WRITE_TO_NONE; 814038c8a9a5SSteve French else 814138c8a9a5SSteve French lease_change_type = OPLOCK_READ_TO_NONE; 814238c8a9a5SSteve French } else if (req->LeaseState & SMB2_LEASE_READ_CACHING_LE) { 814338c8a9a5SSteve French if (lease->state & SMB2_LEASE_WRITE_CACHING_LE) 814438c8a9a5SSteve French lease_change_type = OPLOCK_WRITE_TO_READ; 814538c8a9a5SSteve French else 814638c8a9a5SSteve French lease_change_type = OPLOCK_READ_HANDLE_TO_READ; 814738c8a9a5SSteve French } else { 814838c8a9a5SSteve French lease_change_type = 0; 814938c8a9a5SSteve French } 815038c8a9a5SSteve French } 815138c8a9a5SSteve French 815238c8a9a5SSteve French switch (lease_change_type) { 815338c8a9a5SSteve French case OPLOCK_WRITE_TO_READ: 815438c8a9a5SSteve French ret = opinfo_write_to_read(opinfo); 815538c8a9a5SSteve French break; 815638c8a9a5SSteve French case OPLOCK_READ_HANDLE_TO_READ: 815738c8a9a5SSteve French ret = opinfo_read_handle_to_read(opinfo); 815838c8a9a5SSteve French break; 815938c8a9a5SSteve French case OPLOCK_WRITE_TO_NONE: 816038c8a9a5SSteve French ret = opinfo_write_to_none(opinfo); 816138c8a9a5SSteve French break; 816238c8a9a5SSteve French case OPLOCK_READ_TO_NONE: 816338c8a9a5SSteve French ret = opinfo_read_to_none(opinfo); 816438c8a9a5SSteve French break; 816538c8a9a5SSteve French default: 816638c8a9a5SSteve French ksmbd_debug(OPLOCK, "unknown lease change 0x%x -> 0x%x\n", 816738c8a9a5SSteve French le32_to_cpu(lease->state), 816838c8a9a5SSteve French le32_to_cpu(req->LeaseState)); 816938c8a9a5SSteve French } 817038c8a9a5SSteve French 817138c8a9a5SSteve French lease_state = lease->state; 817238c8a9a5SSteve French opinfo->op_state = OPLOCK_STATE_NONE; 817338c8a9a5SSteve French wake_up_interruptible_all(&opinfo->oplock_q); 817438c8a9a5SSteve French atomic_dec(&opinfo->breaking_cnt); 817538c8a9a5SSteve French wake_up_interruptible_all(&opinfo->oplock_brk); 817638c8a9a5SSteve French opinfo_put(opinfo); 817738c8a9a5SSteve French 817838c8a9a5SSteve French if (ret < 0) { 817938c8a9a5SSteve French rsp->hdr.Status = err; 818038c8a9a5SSteve French goto err_out; 818138c8a9a5SSteve French } 818238c8a9a5SSteve French 818338c8a9a5SSteve French rsp->StructureSize = cpu_to_le16(36); 818438c8a9a5SSteve French rsp->Reserved = 0; 818538c8a9a5SSteve French rsp->Flags = 0; 818638c8a9a5SSteve French memcpy(rsp->LeaseKey, req->LeaseKey, 16); 818738c8a9a5SSteve French rsp->LeaseState = lease_state; 818838c8a9a5SSteve French rsp->LeaseDuration = 0; 818938c8a9a5SSteve French inc_rfc1001_len(work->response_buf, 36); 819038c8a9a5SSteve French return; 819138c8a9a5SSteve French 819238c8a9a5SSteve French err_out: 819338c8a9a5SSteve French opinfo->op_state = OPLOCK_STATE_NONE; 819438c8a9a5SSteve French wake_up_interruptible_all(&opinfo->oplock_q); 819538c8a9a5SSteve French atomic_dec(&opinfo->breaking_cnt); 819638c8a9a5SSteve French wake_up_interruptible_all(&opinfo->oplock_brk); 819738c8a9a5SSteve French 819838c8a9a5SSteve French opinfo_put(opinfo); 819938c8a9a5SSteve French smb2_set_err_rsp(work); 820038c8a9a5SSteve French } 820138c8a9a5SSteve French 820238c8a9a5SSteve French /** 820338c8a9a5SSteve French * smb2_oplock_break() - dispatcher for smb2.0 and 2.1 oplock/lease break 820438c8a9a5SSteve French * @work: smb work containing oplock/lease break command buffer 820538c8a9a5SSteve French * 820638c8a9a5SSteve French * Return: 0 820738c8a9a5SSteve French */ 820838c8a9a5SSteve French int smb2_oplock_break(struct ksmbd_work *work) 820938c8a9a5SSteve French { 82107b7d709eSNamjae Jeon struct smb2_oplock_break *req; 82117b7d709eSNamjae Jeon struct smb2_oplock_break *rsp; 82127b7d709eSNamjae Jeon 82137b7d709eSNamjae Jeon WORK_BUFFERS(work, req, rsp); 821438c8a9a5SSteve French 821538c8a9a5SSteve French switch (le16_to_cpu(req->StructureSize)) { 821638c8a9a5SSteve French case OP_BREAK_STRUCT_SIZE_20: 821738c8a9a5SSteve French smb20_oplock_break_ack(work); 821838c8a9a5SSteve French break; 821938c8a9a5SSteve French case OP_BREAK_STRUCT_SIZE_21: 822038c8a9a5SSteve French smb21_lease_break_ack(work); 822138c8a9a5SSteve French break; 822238c8a9a5SSteve French default: 822338c8a9a5SSteve French ksmbd_debug(OPLOCK, "invalid break cmd %d\n", 822438c8a9a5SSteve French le16_to_cpu(req->StructureSize)); 822538c8a9a5SSteve French rsp->hdr.Status = STATUS_INVALID_PARAMETER; 822638c8a9a5SSteve French smb2_set_err_rsp(work); 822738c8a9a5SSteve French } 822838c8a9a5SSteve French 822938c8a9a5SSteve French return 0; 823038c8a9a5SSteve French } 823138c8a9a5SSteve French 823238c8a9a5SSteve French /** 823338c8a9a5SSteve French * smb2_notify() - handler for smb2 notify request 823438c8a9a5SSteve French * @work: smb work containing notify command buffer 823538c8a9a5SSteve French * 823638c8a9a5SSteve French * Return: 0 823738c8a9a5SSteve French */ 823838c8a9a5SSteve French int smb2_notify(struct ksmbd_work *work) 823938c8a9a5SSteve French { 824038c8a9a5SSteve French struct smb2_change_notify_req *req; 824138c8a9a5SSteve French struct smb2_change_notify_rsp *rsp; 824238c8a9a5SSteve French 824338c8a9a5SSteve French WORK_BUFFERS(work, req, rsp); 824438c8a9a5SSteve French 824538c8a9a5SSteve French if (work->next_smb2_rcv_hdr_off && req->hdr.NextCommand) { 824638c8a9a5SSteve French rsp->hdr.Status = STATUS_INTERNAL_ERROR; 824738c8a9a5SSteve French smb2_set_err_rsp(work); 824838c8a9a5SSteve French return 0; 824938c8a9a5SSteve French } 825038c8a9a5SSteve French 825138c8a9a5SSteve French smb2_set_err_rsp(work); 825238c8a9a5SSteve French rsp->hdr.Status = STATUS_NOT_IMPLEMENTED; 825338c8a9a5SSteve French return 0; 825438c8a9a5SSteve French } 825538c8a9a5SSteve French 825638c8a9a5SSteve French /** 825738c8a9a5SSteve French * smb2_is_sign_req() - handler for checking packet signing status 825838c8a9a5SSteve French * @work: smb work containing notify command buffer 825938c8a9a5SSteve French * @command: SMB2 command id 826038c8a9a5SSteve French * 826138c8a9a5SSteve French * Return: true if packed is signed, false otherwise 826238c8a9a5SSteve French */ 826338c8a9a5SSteve French bool smb2_is_sign_req(struct ksmbd_work *work, unsigned int command) 826438c8a9a5SSteve French { 826538c8a9a5SSteve French struct smb2_hdr *rcv_hdr2 = smb2_get_msg(work->request_buf); 826638c8a9a5SSteve French 826738c8a9a5SSteve French if ((rcv_hdr2->Flags & SMB2_FLAGS_SIGNED) && 826838c8a9a5SSteve French command != SMB2_NEGOTIATE_HE && 826938c8a9a5SSteve French command != SMB2_SESSION_SETUP_HE && 827038c8a9a5SSteve French command != SMB2_OPLOCK_BREAK_HE) 827138c8a9a5SSteve French return true; 827238c8a9a5SSteve French 827338c8a9a5SSteve French return false; 827438c8a9a5SSteve French } 827538c8a9a5SSteve French 827638c8a9a5SSteve French /** 827738c8a9a5SSteve French * smb2_check_sign_req() - handler for req packet sign processing 827838c8a9a5SSteve French * @work: smb work containing notify command buffer 827938c8a9a5SSteve French * 828038c8a9a5SSteve French * Return: 1 on success, 0 otherwise 828138c8a9a5SSteve French */ 828238c8a9a5SSteve French int smb2_check_sign_req(struct ksmbd_work *work) 828338c8a9a5SSteve French { 828438c8a9a5SSteve French struct smb2_hdr *hdr; 828538c8a9a5SSteve French char signature_req[SMB2_SIGNATURE_SIZE]; 828638c8a9a5SSteve French char signature[SMB2_HMACSHA256_SIZE]; 828738c8a9a5SSteve French struct kvec iov[1]; 828838c8a9a5SSteve French size_t len; 828938c8a9a5SSteve French 829038c8a9a5SSteve French hdr = smb2_get_msg(work->request_buf); 829138c8a9a5SSteve French if (work->next_smb2_rcv_hdr_off) 829238c8a9a5SSteve French hdr = ksmbd_req_buf_next(work); 829338c8a9a5SSteve French 829438c8a9a5SSteve French if (!hdr->NextCommand && !work->next_smb2_rcv_hdr_off) 829538c8a9a5SSteve French len = get_rfc1002_len(work->request_buf); 829638c8a9a5SSteve French else if (hdr->NextCommand) 829738c8a9a5SSteve French len = le32_to_cpu(hdr->NextCommand); 829838c8a9a5SSteve French else 829938c8a9a5SSteve French len = get_rfc1002_len(work->request_buf) - 830038c8a9a5SSteve French work->next_smb2_rcv_hdr_off; 830138c8a9a5SSteve French 830238c8a9a5SSteve French memcpy(signature_req, hdr->Signature, SMB2_SIGNATURE_SIZE); 830338c8a9a5SSteve French memset(hdr->Signature, 0, SMB2_SIGNATURE_SIZE); 830438c8a9a5SSteve French 830538c8a9a5SSteve French iov[0].iov_base = (char *)&hdr->ProtocolId; 830638c8a9a5SSteve French iov[0].iov_len = len; 830738c8a9a5SSteve French 830838c8a9a5SSteve French if (ksmbd_sign_smb2_pdu(work->conn, work->sess->sess_key, iov, 1, 830938c8a9a5SSteve French signature)) 831038c8a9a5SSteve French return 0; 831138c8a9a5SSteve French 831238c8a9a5SSteve French if (memcmp(signature, signature_req, SMB2_SIGNATURE_SIZE)) { 831338c8a9a5SSteve French pr_err("bad smb2 signature\n"); 831438c8a9a5SSteve French return 0; 831538c8a9a5SSteve French } 831638c8a9a5SSteve French 831738c8a9a5SSteve French return 1; 831838c8a9a5SSteve French } 831938c8a9a5SSteve French 832038c8a9a5SSteve French /** 832138c8a9a5SSteve French * smb2_set_sign_rsp() - handler for rsp packet sign processing 832238c8a9a5SSteve French * @work: smb work containing notify command buffer 832338c8a9a5SSteve French * 832438c8a9a5SSteve French */ 832538c8a9a5SSteve French void smb2_set_sign_rsp(struct ksmbd_work *work) 832638c8a9a5SSteve French { 832738c8a9a5SSteve French struct smb2_hdr *hdr; 832838c8a9a5SSteve French struct smb2_hdr *req_hdr; 832938c8a9a5SSteve French char signature[SMB2_HMACSHA256_SIZE]; 833038c8a9a5SSteve French struct kvec iov[2]; 833138c8a9a5SSteve French size_t len; 833238c8a9a5SSteve French int n_vec = 1; 833338c8a9a5SSteve French 833438c8a9a5SSteve French hdr = smb2_get_msg(work->response_buf); 833538c8a9a5SSteve French if (work->next_smb2_rsp_hdr_off) 833638c8a9a5SSteve French hdr = ksmbd_resp_buf_next(work); 833738c8a9a5SSteve French 833838c8a9a5SSteve French req_hdr = ksmbd_req_buf_next(work); 833938c8a9a5SSteve French 834038c8a9a5SSteve French if (!work->next_smb2_rsp_hdr_off) { 834138c8a9a5SSteve French len = get_rfc1002_len(work->response_buf); 834238c8a9a5SSteve French if (req_hdr->NextCommand) 834338c8a9a5SSteve French len = ALIGN(len, 8); 834438c8a9a5SSteve French } else { 834538c8a9a5SSteve French len = get_rfc1002_len(work->response_buf) - 834638c8a9a5SSteve French work->next_smb2_rsp_hdr_off; 834738c8a9a5SSteve French len = ALIGN(len, 8); 834838c8a9a5SSteve French } 834938c8a9a5SSteve French 835038c8a9a5SSteve French if (req_hdr->NextCommand) 835138c8a9a5SSteve French hdr->NextCommand = cpu_to_le32(len); 835238c8a9a5SSteve French 835338c8a9a5SSteve French hdr->Flags |= SMB2_FLAGS_SIGNED; 835438c8a9a5SSteve French memset(hdr->Signature, 0, SMB2_SIGNATURE_SIZE); 835538c8a9a5SSteve French 835638c8a9a5SSteve French iov[0].iov_base = (char *)&hdr->ProtocolId; 835738c8a9a5SSteve French iov[0].iov_len = len; 835838c8a9a5SSteve French 835938c8a9a5SSteve French if (work->aux_payload_sz) { 836038c8a9a5SSteve French iov[0].iov_len -= work->aux_payload_sz; 836138c8a9a5SSteve French 836238c8a9a5SSteve French iov[1].iov_base = work->aux_payload_buf; 836338c8a9a5SSteve French iov[1].iov_len = work->aux_payload_sz; 836438c8a9a5SSteve French n_vec++; 836538c8a9a5SSteve French } 836638c8a9a5SSteve French 836738c8a9a5SSteve French if (!ksmbd_sign_smb2_pdu(work->conn, work->sess->sess_key, iov, n_vec, 836838c8a9a5SSteve French signature)) 836938c8a9a5SSteve French memcpy(hdr->Signature, signature, SMB2_SIGNATURE_SIZE); 837038c8a9a5SSteve French } 837138c8a9a5SSteve French 837238c8a9a5SSteve French /** 837338c8a9a5SSteve French * smb3_check_sign_req() - handler for req packet sign processing 837438c8a9a5SSteve French * @work: smb work containing notify command buffer 837538c8a9a5SSteve French * 837638c8a9a5SSteve French * Return: 1 on success, 0 otherwise 837738c8a9a5SSteve French */ 837838c8a9a5SSteve French int smb3_check_sign_req(struct ksmbd_work *work) 837938c8a9a5SSteve French { 838038c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 838138c8a9a5SSteve French char *signing_key; 838238c8a9a5SSteve French struct smb2_hdr *hdr; 838338c8a9a5SSteve French struct channel *chann; 838438c8a9a5SSteve French char signature_req[SMB2_SIGNATURE_SIZE]; 838538c8a9a5SSteve French char signature[SMB2_CMACAES_SIZE]; 838638c8a9a5SSteve French struct kvec iov[1]; 838738c8a9a5SSteve French size_t len; 838838c8a9a5SSteve French 838938c8a9a5SSteve French hdr = smb2_get_msg(work->request_buf); 839038c8a9a5SSteve French if (work->next_smb2_rcv_hdr_off) 839138c8a9a5SSteve French hdr = ksmbd_req_buf_next(work); 839238c8a9a5SSteve French 839338c8a9a5SSteve French if (!hdr->NextCommand && !work->next_smb2_rcv_hdr_off) 839438c8a9a5SSteve French len = get_rfc1002_len(work->request_buf); 839538c8a9a5SSteve French else if (hdr->NextCommand) 839638c8a9a5SSteve French len = le32_to_cpu(hdr->NextCommand); 839738c8a9a5SSteve French else 839838c8a9a5SSteve French len = get_rfc1002_len(work->request_buf) - 839938c8a9a5SSteve French work->next_smb2_rcv_hdr_off; 840038c8a9a5SSteve French 840138c8a9a5SSteve French if (le16_to_cpu(hdr->Command) == SMB2_SESSION_SETUP_HE) { 840238c8a9a5SSteve French signing_key = work->sess->smb3signingkey; 840338c8a9a5SSteve French } else { 840438c8a9a5SSteve French chann = lookup_chann_list(work->sess, conn); 840538c8a9a5SSteve French if (!chann) { 840638c8a9a5SSteve French return 0; 840738c8a9a5SSteve French } 840838c8a9a5SSteve French signing_key = chann->smb3signingkey; 840938c8a9a5SSteve French } 841038c8a9a5SSteve French 841138c8a9a5SSteve French if (!signing_key) { 841238c8a9a5SSteve French pr_err("SMB3 signing key is not generated\n"); 841338c8a9a5SSteve French return 0; 841438c8a9a5SSteve French } 841538c8a9a5SSteve French 841638c8a9a5SSteve French memcpy(signature_req, hdr->Signature, SMB2_SIGNATURE_SIZE); 841738c8a9a5SSteve French memset(hdr->Signature, 0, SMB2_SIGNATURE_SIZE); 841838c8a9a5SSteve French iov[0].iov_base = (char *)&hdr->ProtocolId; 841938c8a9a5SSteve French iov[0].iov_len = len; 842038c8a9a5SSteve French 842138c8a9a5SSteve French if (ksmbd_sign_smb3_pdu(conn, signing_key, iov, 1, signature)) 842238c8a9a5SSteve French return 0; 842338c8a9a5SSteve French 842438c8a9a5SSteve French if (memcmp(signature, signature_req, SMB2_SIGNATURE_SIZE)) { 842538c8a9a5SSteve French pr_err("bad smb2 signature\n"); 842638c8a9a5SSteve French return 0; 842738c8a9a5SSteve French } 842838c8a9a5SSteve French 842938c8a9a5SSteve French return 1; 843038c8a9a5SSteve French } 843138c8a9a5SSteve French 843238c8a9a5SSteve French /** 843338c8a9a5SSteve French * smb3_set_sign_rsp() - handler for rsp packet sign processing 843438c8a9a5SSteve French * @work: smb work containing notify command buffer 843538c8a9a5SSteve French * 843638c8a9a5SSteve French */ 843738c8a9a5SSteve French void smb3_set_sign_rsp(struct ksmbd_work *work) 843838c8a9a5SSteve French { 843938c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 844038c8a9a5SSteve French struct smb2_hdr *req_hdr, *hdr; 844138c8a9a5SSteve French struct channel *chann; 844238c8a9a5SSteve French char signature[SMB2_CMACAES_SIZE]; 844338c8a9a5SSteve French struct kvec iov[2]; 844438c8a9a5SSteve French int n_vec = 1; 844538c8a9a5SSteve French size_t len; 844638c8a9a5SSteve French char *signing_key; 844738c8a9a5SSteve French 844838c8a9a5SSteve French hdr = smb2_get_msg(work->response_buf); 844938c8a9a5SSteve French if (work->next_smb2_rsp_hdr_off) 845038c8a9a5SSteve French hdr = ksmbd_resp_buf_next(work); 845138c8a9a5SSteve French 845238c8a9a5SSteve French req_hdr = ksmbd_req_buf_next(work); 845338c8a9a5SSteve French 845438c8a9a5SSteve French if (!work->next_smb2_rsp_hdr_off) { 845538c8a9a5SSteve French len = get_rfc1002_len(work->response_buf); 845638c8a9a5SSteve French if (req_hdr->NextCommand) 845738c8a9a5SSteve French len = ALIGN(len, 8); 845838c8a9a5SSteve French } else { 845938c8a9a5SSteve French len = get_rfc1002_len(work->response_buf) - 846038c8a9a5SSteve French work->next_smb2_rsp_hdr_off; 846138c8a9a5SSteve French len = ALIGN(len, 8); 846238c8a9a5SSteve French } 846338c8a9a5SSteve French 846438c8a9a5SSteve French if (conn->binding == false && 846538c8a9a5SSteve French le16_to_cpu(hdr->Command) == SMB2_SESSION_SETUP_HE) { 846638c8a9a5SSteve French signing_key = work->sess->smb3signingkey; 846738c8a9a5SSteve French } else { 846838c8a9a5SSteve French chann = lookup_chann_list(work->sess, work->conn); 846938c8a9a5SSteve French if (!chann) { 847038c8a9a5SSteve French return; 847138c8a9a5SSteve French } 847238c8a9a5SSteve French signing_key = chann->smb3signingkey; 847338c8a9a5SSteve French } 847438c8a9a5SSteve French 847538c8a9a5SSteve French if (!signing_key) 847638c8a9a5SSteve French return; 847738c8a9a5SSteve French 847838c8a9a5SSteve French if (req_hdr->NextCommand) 847938c8a9a5SSteve French hdr->NextCommand = cpu_to_le32(len); 848038c8a9a5SSteve French 848138c8a9a5SSteve French hdr->Flags |= SMB2_FLAGS_SIGNED; 848238c8a9a5SSteve French memset(hdr->Signature, 0, SMB2_SIGNATURE_SIZE); 848338c8a9a5SSteve French iov[0].iov_base = (char *)&hdr->ProtocolId; 848438c8a9a5SSteve French iov[0].iov_len = len; 848538c8a9a5SSteve French if (work->aux_payload_sz) { 848638c8a9a5SSteve French iov[0].iov_len -= work->aux_payload_sz; 848738c8a9a5SSteve French iov[1].iov_base = work->aux_payload_buf; 848838c8a9a5SSteve French iov[1].iov_len = work->aux_payload_sz; 848938c8a9a5SSteve French n_vec++; 849038c8a9a5SSteve French } 849138c8a9a5SSteve French 849238c8a9a5SSteve French if (!ksmbd_sign_smb3_pdu(conn, signing_key, iov, n_vec, signature)) 849338c8a9a5SSteve French memcpy(hdr->Signature, signature, SMB2_SIGNATURE_SIZE); 849438c8a9a5SSteve French } 849538c8a9a5SSteve French 849638c8a9a5SSteve French /** 849738c8a9a5SSteve French * smb3_preauth_hash_rsp() - handler for computing preauth hash on response 849838c8a9a5SSteve French * @work: smb work containing response buffer 849938c8a9a5SSteve French * 850038c8a9a5SSteve French */ 850138c8a9a5SSteve French void smb3_preauth_hash_rsp(struct ksmbd_work *work) 850238c8a9a5SSteve French { 850338c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 850438c8a9a5SSteve French struct ksmbd_session *sess = work->sess; 850538c8a9a5SSteve French struct smb2_hdr *req, *rsp; 850638c8a9a5SSteve French 850738c8a9a5SSteve French if (conn->dialect != SMB311_PROT_ID) 850838c8a9a5SSteve French return; 850938c8a9a5SSteve French 851038c8a9a5SSteve French WORK_BUFFERS(work, req, rsp); 851138c8a9a5SSteve French 851238c8a9a5SSteve French if (le16_to_cpu(req->Command) == SMB2_NEGOTIATE_HE && 851338c8a9a5SSteve French conn->preauth_info) 851438c8a9a5SSteve French ksmbd_gen_preauth_integrity_hash(conn, work->response_buf, 851538c8a9a5SSteve French conn->preauth_info->Preauth_HashValue); 851638c8a9a5SSteve French 851738c8a9a5SSteve French if (le16_to_cpu(rsp->Command) == SMB2_SESSION_SETUP_HE && sess) { 851838c8a9a5SSteve French __u8 *hash_value; 851938c8a9a5SSteve French 852038c8a9a5SSteve French if (conn->binding) { 852138c8a9a5SSteve French struct preauth_session *preauth_sess; 852238c8a9a5SSteve French 852338c8a9a5SSteve French preauth_sess = ksmbd_preauth_session_lookup(conn, sess->id); 852438c8a9a5SSteve French if (!preauth_sess) 852538c8a9a5SSteve French return; 852638c8a9a5SSteve French hash_value = preauth_sess->Preauth_HashValue; 852738c8a9a5SSteve French } else { 852838c8a9a5SSteve French hash_value = sess->Preauth_HashValue; 852938c8a9a5SSteve French if (!hash_value) 853038c8a9a5SSteve French return; 853138c8a9a5SSteve French } 853238c8a9a5SSteve French ksmbd_gen_preauth_integrity_hash(conn, work->response_buf, 853338c8a9a5SSteve French hash_value); 853438c8a9a5SSteve French } 853538c8a9a5SSteve French } 853638c8a9a5SSteve French 853738c8a9a5SSteve French static void fill_transform_hdr(void *tr_buf, char *old_buf, __le16 cipher_type) 853838c8a9a5SSteve French { 853938c8a9a5SSteve French struct smb2_transform_hdr *tr_hdr = tr_buf + 4; 854038c8a9a5SSteve French struct smb2_hdr *hdr = smb2_get_msg(old_buf); 854138c8a9a5SSteve French unsigned int orig_len = get_rfc1002_len(old_buf); 854238c8a9a5SSteve French 854338c8a9a5SSteve French /* tr_buf must be cleared by the caller */ 854438c8a9a5SSteve French tr_hdr->ProtocolId = SMB2_TRANSFORM_PROTO_NUM; 854538c8a9a5SSteve French tr_hdr->OriginalMessageSize = cpu_to_le32(orig_len); 854638c8a9a5SSteve French tr_hdr->Flags = cpu_to_le16(TRANSFORM_FLAG_ENCRYPTED); 854738c8a9a5SSteve French if (cipher_type == SMB2_ENCRYPTION_AES128_GCM || 854838c8a9a5SSteve French cipher_type == SMB2_ENCRYPTION_AES256_GCM) 854938c8a9a5SSteve French get_random_bytes(&tr_hdr->Nonce, SMB3_AES_GCM_NONCE); 855038c8a9a5SSteve French else 855138c8a9a5SSteve French get_random_bytes(&tr_hdr->Nonce, SMB3_AES_CCM_NONCE); 855238c8a9a5SSteve French memcpy(&tr_hdr->SessionId, &hdr->SessionId, 8); 855338c8a9a5SSteve French inc_rfc1001_len(tr_buf, sizeof(struct smb2_transform_hdr)); 855438c8a9a5SSteve French inc_rfc1001_len(tr_buf, orig_len); 855538c8a9a5SSteve French } 855638c8a9a5SSteve French 855738c8a9a5SSteve French int smb3_encrypt_resp(struct ksmbd_work *work) 855838c8a9a5SSteve French { 855938c8a9a5SSteve French char *buf = work->response_buf; 856038c8a9a5SSteve French struct kvec iov[3]; 856138c8a9a5SSteve French int rc = -ENOMEM; 856238c8a9a5SSteve French int buf_size = 0, rq_nvec = 2 + (work->aux_payload_sz ? 1 : 0); 856338c8a9a5SSteve French 856438c8a9a5SSteve French if (ARRAY_SIZE(iov) < rq_nvec) 856538c8a9a5SSteve French return -ENOMEM; 856638c8a9a5SSteve French 856738c8a9a5SSteve French work->tr_buf = kzalloc(sizeof(struct smb2_transform_hdr) + 4, GFP_KERNEL); 856838c8a9a5SSteve French if (!work->tr_buf) 856938c8a9a5SSteve French return rc; 857038c8a9a5SSteve French 857138c8a9a5SSteve French /* fill transform header */ 857238c8a9a5SSteve French fill_transform_hdr(work->tr_buf, buf, work->conn->cipher_type); 857338c8a9a5SSteve French 857438c8a9a5SSteve French iov[0].iov_base = work->tr_buf; 857538c8a9a5SSteve French iov[0].iov_len = sizeof(struct smb2_transform_hdr) + 4; 857638c8a9a5SSteve French buf_size += iov[0].iov_len - 4; 857738c8a9a5SSteve French 857838c8a9a5SSteve French iov[1].iov_base = buf + 4; 857938c8a9a5SSteve French iov[1].iov_len = get_rfc1002_len(buf); 858038c8a9a5SSteve French if (work->aux_payload_sz) { 858138c8a9a5SSteve French iov[1].iov_len = work->resp_hdr_sz - 4; 858238c8a9a5SSteve French 858338c8a9a5SSteve French iov[2].iov_base = work->aux_payload_buf; 858438c8a9a5SSteve French iov[2].iov_len = work->aux_payload_sz; 858538c8a9a5SSteve French buf_size += iov[2].iov_len; 858638c8a9a5SSteve French } 858738c8a9a5SSteve French buf_size += iov[1].iov_len; 858838c8a9a5SSteve French work->resp_hdr_sz = iov[1].iov_len; 858938c8a9a5SSteve French 859038c8a9a5SSteve French rc = ksmbd_crypt_message(work, iov, rq_nvec, 1); 859138c8a9a5SSteve French if (rc) 859238c8a9a5SSteve French return rc; 859338c8a9a5SSteve French 859438c8a9a5SSteve French memmove(buf, iov[1].iov_base, iov[1].iov_len); 859538c8a9a5SSteve French *(__be32 *)work->tr_buf = cpu_to_be32(buf_size); 859638c8a9a5SSteve French 859738c8a9a5SSteve French return rc; 859838c8a9a5SSteve French } 859938c8a9a5SSteve French 860038c8a9a5SSteve French bool smb3_is_transform_hdr(void *buf) 860138c8a9a5SSteve French { 860238c8a9a5SSteve French struct smb2_transform_hdr *trhdr = smb2_get_msg(buf); 860338c8a9a5SSteve French 860438c8a9a5SSteve French return trhdr->ProtocolId == SMB2_TRANSFORM_PROTO_NUM; 860538c8a9a5SSteve French } 860638c8a9a5SSteve French 860738c8a9a5SSteve French int smb3_decrypt_req(struct ksmbd_work *work) 860838c8a9a5SSteve French { 860938c8a9a5SSteve French struct ksmbd_session *sess; 861038c8a9a5SSteve French char *buf = work->request_buf; 861138c8a9a5SSteve French unsigned int pdu_length = get_rfc1002_len(buf); 861238c8a9a5SSteve French struct kvec iov[2]; 861338c8a9a5SSteve French int buf_data_size = pdu_length - sizeof(struct smb2_transform_hdr); 861438c8a9a5SSteve French struct smb2_transform_hdr *tr_hdr = smb2_get_msg(buf); 861538c8a9a5SSteve French int rc = 0; 861638c8a9a5SSteve French 861738c8a9a5SSteve French if (buf_data_size < sizeof(struct smb2_hdr)) { 861838c8a9a5SSteve French pr_err("Transform message is too small (%u)\n", 861938c8a9a5SSteve French pdu_length); 862038c8a9a5SSteve French return -ECONNABORTED; 862138c8a9a5SSteve French } 862238c8a9a5SSteve French 862338c8a9a5SSteve French if (buf_data_size < le32_to_cpu(tr_hdr->OriginalMessageSize)) { 862438c8a9a5SSteve French pr_err("Transform message is broken\n"); 862538c8a9a5SSteve French return -ECONNABORTED; 862638c8a9a5SSteve French } 862738c8a9a5SSteve French 862838c8a9a5SSteve French sess = ksmbd_session_lookup_all(work->conn, le64_to_cpu(tr_hdr->SessionId)); 862938c8a9a5SSteve French if (!sess) { 863038c8a9a5SSteve French pr_err("invalid session id(%llx) in transform header\n", 863138c8a9a5SSteve French le64_to_cpu(tr_hdr->SessionId)); 863238c8a9a5SSteve French return -ECONNABORTED; 863338c8a9a5SSteve French } 863438c8a9a5SSteve French 863538c8a9a5SSteve French iov[0].iov_base = buf; 863638c8a9a5SSteve French iov[0].iov_len = sizeof(struct smb2_transform_hdr) + 4; 863738c8a9a5SSteve French iov[1].iov_base = buf + sizeof(struct smb2_transform_hdr) + 4; 863838c8a9a5SSteve French iov[1].iov_len = buf_data_size; 863938c8a9a5SSteve French rc = ksmbd_crypt_message(work, iov, 2, 0); 864038c8a9a5SSteve French if (rc) 864138c8a9a5SSteve French return rc; 864238c8a9a5SSteve French 864338c8a9a5SSteve French memmove(buf + 4, iov[1].iov_base, buf_data_size); 864438c8a9a5SSteve French *(__be32 *)buf = cpu_to_be32(buf_data_size); 864538c8a9a5SSteve French 864638c8a9a5SSteve French return rc; 864738c8a9a5SSteve French } 864838c8a9a5SSteve French 864938c8a9a5SSteve French bool smb3_11_final_sess_setup_resp(struct ksmbd_work *work) 865038c8a9a5SSteve French { 865138c8a9a5SSteve French struct ksmbd_conn *conn = work->conn; 865238c8a9a5SSteve French struct ksmbd_session *sess = work->sess; 865338c8a9a5SSteve French struct smb2_hdr *rsp = smb2_get_msg(work->response_buf); 865438c8a9a5SSteve French 865538c8a9a5SSteve French if (conn->dialect < SMB30_PROT_ID) 865638c8a9a5SSteve French return false; 865738c8a9a5SSteve French 865838c8a9a5SSteve French if (work->next_smb2_rcv_hdr_off) 865938c8a9a5SSteve French rsp = ksmbd_resp_buf_next(work); 866038c8a9a5SSteve French 866138c8a9a5SSteve French if (le16_to_cpu(rsp->Command) == SMB2_SESSION_SETUP_HE && 866238c8a9a5SSteve French sess->user && !user_guest(sess->user) && 866338c8a9a5SSteve French rsp->Status == STATUS_SUCCESS) 866438c8a9a5SSteve French return true; 866538c8a9a5SSteve French return false; 866638c8a9a5SSteve French } 8667