1 // SPDX-License-Identifier: LGPL-2.1
2 /*
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2008
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 * Jeremy Allison (jra@samba.org) 2006.
7 *
8 */
9
10 #include <linux/fs.h>
11 #include <linux/list.h>
12 #include <linux/gfp.h>
13 #include <linux/wait.h>
14 #include <linux/net.h>
15 #include <linux/delay.h>
16 #include <linux/freezer.h>
17 #include <linux/tcp.h>
18 #include <linux/bvec.h>
19 #include <linux/highmem.h>
20 #include <linux/uaccess.h>
21 #include <linux/processor.h>
22 #include <linux/mempool.h>
23 #include <linux/sched/signal.h>
24 #include <linux/task_io_accounting_ops.h>
25 #include "cifspdu.h"
26 #include "cifsglob.h"
27 #include "cifsproto.h"
28 #include "cifs_debug.h"
29 #include "smb2proto.h"
30 #include "smbdirect.h"
31 #include "compress.h"
32
33 /* Max number of iovectors we can use off the stack when sending requests. */
34 #define CIFS_MAX_IOV_SIZE 8
35
36 static struct mid_q_entry *
alloc_mid(const struct smb_hdr * smb_buffer,struct TCP_Server_Info * server)37 alloc_mid(const struct smb_hdr *smb_buffer, struct TCP_Server_Info *server)
38 {
39 struct mid_q_entry *temp;
40
41 if (server == NULL) {
42 cifs_dbg(VFS, "%s: null TCP session\n", __func__);
43 return NULL;
44 }
45
46 temp = mempool_alloc(&cifs_mid_pool, GFP_NOFS);
47 memset(temp, 0, sizeof(struct mid_q_entry));
48 refcount_set(&temp->refcount, 1);
49 spin_lock_init(&temp->mid_lock);
50 temp->mid = get_mid(smb_buffer);
51 temp->pid = current->pid;
52 temp->command = cpu_to_le16(smb_buffer->Command);
53 cifs_dbg(FYI, "For smb_command %d\n", smb_buffer->Command);
54 /* easier to use jiffies */
55 /* when mid allocated can be before when sent */
56 temp->when_alloc = jiffies;
57
58 /*
59 * The default is for the mid to be synchronous, so the
60 * default callback just wakes up the current task.
61 */
62 get_task_struct(current);
63 temp->creator = current;
64 temp->callback = cifs_wake_up_task;
65 temp->callback_data = current;
66
67 atomic_inc(&mid_count);
68 temp->mid_state = MID_REQUEST_ALLOCATED;
69 return temp;
70 }
71
allocate_mid(struct cifs_ses * ses,struct smb_hdr * in_buf,struct mid_q_entry ** ppmidQ)72 static int allocate_mid(struct cifs_ses *ses, struct smb_hdr *in_buf,
73 struct mid_q_entry **ppmidQ)
74 {
75 spin_lock(&ses->ses_lock);
76 if (ses->ses_status == SES_NEW) {
77 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
78 (in_buf->Command != SMB_COM_NEGOTIATE)) {
79 spin_unlock(&ses->ses_lock);
80 return -EAGAIN;
81 }
82 /* else ok - we are setting up session */
83 }
84
85 if (ses->ses_status == SES_EXITING) {
86 /* check if SMB session is bad because we are setting it up */
87 if (in_buf->Command != SMB_COM_LOGOFF_ANDX) {
88 spin_unlock(&ses->ses_lock);
89 return -EAGAIN;
90 }
91 /* else ok - we are shutting down session */
92 }
93 spin_unlock(&ses->ses_lock);
94
95 *ppmidQ = alloc_mid(in_buf, ses->server);
96 if (*ppmidQ == NULL)
97 return -ENOMEM;
98 spin_lock(&ses->server->mid_queue_lock);
99 list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q);
100 spin_unlock(&ses->server->mid_queue_lock);
101 return 0;
102 }
103
104 struct mid_q_entry *
cifs_setup_async_request(struct TCP_Server_Info * server,struct smb_rqst * rqst)105 cifs_setup_async_request(struct TCP_Server_Info *server, struct smb_rqst *rqst)
106 {
107 int rc;
108 struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
109 struct mid_q_entry *mid;
110
111 /* enable signing if server requires it */
112 if (server->sign)
113 hdr->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
114
115 mid = alloc_mid(hdr, server);
116 if (mid == NULL)
117 return ERR_PTR(-ENOMEM);
118
119 rc = cifs_sign_rqst(rqst, server, &mid->sequence_number);
120 if (rc) {
121 release_mid(server, mid);
122 return ERR_PTR(rc);
123 }
124
125 return mid;
126 }
127
128 /*
129 *
130 * Send an SMB Request. No response info (other than return code)
131 * needs to be parsed.
132 *
133 * flags indicate the type of request buffer and how long to wait
134 * and whether to log NT STATUS code (error) before mapping it to POSIX error
135 *
136 */
137 int
SendReceiveNoRsp(const unsigned int xid,struct cifs_ses * ses,char * in_buf,unsigned int in_len,int flags)138 SendReceiveNoRsp(const unsigned int xid, struct cifs_ses *ses,
139 char *in_buf, unsigned int in_len, int flags)
140 {
141 int rc;
142 struct kvec iov[1];
143 struct kvec rsp_iov;
144 int resp_buf_type;
145
146 iov[0].iov_base = in_buf;
147 iov[0].iov_len = in_len;
148 flags |= CIFS_NO_RSP_BUF;
149 rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags, &rsp_iov);
150 cifs_dbg(NOISY, "SendRcvNoRsp flags %d rc %d\n", flags, rc);
151
152 return rc;
153 }
154
155 int
cifs_check_receive(struct mid_q_entry * mid,struct TCP_Server_Info * server,bool log_error)156 cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
157 bool log_error)
158 {
159 unsigned int len = mid->response_pdu_len;
160
161 dump_smb(mid->resp_buf, min_t(u32, 92, len));
162
163 /* convert the length into a more usable form */
164 if (server->sign) {
165 struct kvec iov[1];
166 int rc = 0;
167 struct smb_rqst rqst = { .rq_iov = iov,
168 .rq_nvec = ARRAY_SIZE(iov) };
169
170 iov[0].iov_base = mid->resp_buf;
171 iov[0].iov_len = len;
172 /* FIXME: add code to kill session */
173 rc = cifs_verify_signature(&rqst, server,
174 mid->sequence_number);
175 if (rc)
176 cifs_server_dbg(VFS, "SMB signature verification returned error = %d\n",
177 rc);
178 }
179
180 /* BB special case reconnect tid and uid here? */
181 return map_and_check_smb_error(server, mid, log_error);
182 }
183
184 struct mid_q_entry *
cifs_setup_request(struct cifs_ses * ses,struct TCP_Server_Info * server,struct smb_rqst * rqst)185 cifs_setup_request(struct cifs_ses *ses, struct TCP_Server_Info *server,
186 struct smb_rqst *rqst)
187 {
188 int rc;
189 struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
190 struct mid_q_entry *mid;
191
192 rc = allocate_mid(ses, hdr, &mid);
193 if (rc)
194 return ERR_PTR(rc);
195 rc = cifs_sign_rqst(rqst, server, &mid->sequence_number);
196 if (rc) {
197 delete_mid(server, mid);
198 return ERR_PTR(rc);
199 }
200 return mid;
201 }
202
203 int
SendReceive2(const unsigned int xid,struct cifs_ses * ses,struct kvec * iov,int n_vec,int * resp_buf_type,const int flags,struct kvec * resp_iov)204 SendReceive2(const unsigned int xid, struct cifs_ses *ses,
205 struct kvec *iov, int n_vec, int *resp_buf_type /* ret */,
206 const int flags, struct kvec *resp_iov)
207 {
208 struct smb_rqst rqst = {
209 .rq_iov = iov,
210 .rq_nvec = n_vec,
211 };
212
213 return cifs_send_recv(xid, ses, ses->server,
214 &rqst, resp_buf_type, flags, resp_iov);
215 }
216
217 int
SendReceive(const unsigned int xid,struct cifs_ses * ses,struct smb_hdr * in_buf,unsigned int in_len,struct smb_hdr * out_buf,int * pbytes_returned,const int flags)218 SendReceive(const unsigned int xid, struct cifs_ses *ses,
219 struct smb_hdr *in_buf, unsigned int in_len,
220 struct smb_hdr *out_buf, int *pbytes_returned, const int flags)
221 {
222 struct TCP_Server_Info *server;
223 struct kvec resp_iov = {};
224 struct kvec iov = { .iov_base = in_buf, .iov_len = in_len };
225 struct smb_rqst rqst = { .rq_iov = &iov, .rq_nvec = 1 };
226 int resp_buf_type;
227 int rc = 0;
228
229 if (WARN_ON_ONCE(in_len > 0xffffff))
230 return smb_EIO1(smb_eio_trace_tx_too_long, in_len);
231 if (ses == NULL) {
232 cifs_dbg(VFS, "Null smb session\n");
233 return smb_EIO(smb_eio_trace_null_pointers);
234 }
235 server = ses->server;
236 if (server == NULL) {
237 cifs_dbg(VFS, "Null tcp session\n");
238 return smb_EIO(smb_eio_trace_null_pointers);
239 }
240
241 /* Ensure that we do not send more than 50 overlapping requests
242 to the same server. We may make this configurable later or
243 use ses->maxReq */
244
245 if (in_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
246 cifs_server_dbg(VFS, "Invalid length, greater than maximum frame, %d\n",
247 in_len);
248 return smb_EIO1(smb_eio_trace_tx_too_long, in_len);
249 }
250
251 rc = cifs_send_recv(xid, ses, ses->server,
252 &rqst, &resp_buf_type, flags, &resp_iov);
253 if (rc < 0)
254 return rc;
255
256 if (out_buf) {
257 *pbytes_returned = resp_iov.iov_len;
258 if (resp_iov.iov_len)
259 memcpy(out_buf, resp_iov.iov_base, resp_iov.iov_len);
260 }
261 free_rsp_buf(resp_buf_type, resp_iov.iov_base);
262 return rc;
263 }
264