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