Commit | Line | Data |
---|---|---|
929be906 | 1 | // SPDX-License-Identifier: LGPL-2.1 |
093b2bda | 2 | /* |
093b2bda PS |
3 | * |
4 | * Copyright (C) International Business Machines Corp., 2002,2011 | |
5 | * Etersoft, 2012 | |
6 | * Author(s): Steve French (sfrench@us.ibm.com) | |
7 | * Pavel Shilovsky (pshilovsky@samba.org) 2012 | |
8 | * | |
093b2bda PS |
9 | */ |
10 | #include <linux/ctype.h> | |
093b2bda PS |
11 | #include "cifsglob.h" |
12 | #include "cifsproto.h" | |
13 | #include "smb2proto.h" | |
14 | #include "cifs_debug.h" | |
15 | #include "cifs_unicode.h" | |
16 | #include "smb2status.h" | |
31473fc4 | 17 | #include "smb2glob.h" |
d70e9fa5 | 18 | #include "nterr.h" |
05b98fd2 | 19 | #include "cached_dir.h" |
093b2bda PS |
20 | |
21 | static int | |
0d35e382 | 22 | check_smb2_hdr(struct smb2_hdr *shdr, __u64 mid) |
093b2bda | 23 | { |
31473fc4 | 24 | __u64 wire_mid = le64_to_cpu(shdr->MessageId); |
9235d098 | 25 | |
093b2bda PS |
26 | /* |
27 | * Make sure that this really is an SMB, that it is a response, | |
28 | * and that the message ids match. | |
29 | */ | |
31473fc4 | 30 | if ((shdr->ProtocolId == SMB2_PROTO_NUMBER) && |
9235d098 | 31 | (mid == wire_mid)) { |
31473fc4 | 32 | if (shdr->Flags & SMB2_FLAGS_SERVER_TO_REDIR) |
093b2bda PS |
33 | return 0; |
34 | else { | |
35 | /* only one valid case where server sends us request */ | |
31473fc4 | 36 | if (shdr->Command == SMB2_OPLOCK_BREAK) |
093b2bda PS |
37 | return 0; |
38 | else | |
f96637be | 39 | cifs_dbg(VFS, "Received Request not response\n"); |
093b2bda PS |
40 | } |
41 | } else { /* bad signature or mid */ | |
31473fc4 | 42 | if (shdr->ProtocolId != SMB2_PROTO_NUMBER) |
f96637be | 43 | cifs_dbg(VFS, "Bad protocol string signature header %x\n", |
31473fc4 | 44 | le32_to_cpu(shdr->ProtocolId)); |
9235d098 | 45 | if (mid != wire_mid) |
f96637be | 46 | cifs_dbg(VFS, "Mids do not match: %llu and %llu\n", |
9235d098 | 47 | mid, wire_mid); |
093b2bda | 48 | } |
9235d098 | 49 | cifs_dbg(VFS, "Bad SMB detected. The Mid=%llu\n", wire_mid); |
093b2bda PS |
50 | return 1; |
51 | } | |
52 | ||
53 | /* | |
54 | * The following table defines the expected "StructureSize" of SMB2 responses | |
55 | * in order by SMB2 command. This is similar to "wct" in SMB/CIFS responses. | |
56 | * | |
57 | * Note that commands are defined in smb2pdu.h in le16 but the array below is | |
58 | * indexed by command in host byte order | |
59 | */ | |
60 | static const __le16 smb2_rsp_struct_sizes[NUMBER_OF_SMB2_COMMANDS] = { | |
bc09d141 FF |
61 | /* SMB2_NEGOTIATE */ cpu_to_le16(65), |
62 | /* SMB2_SESSION_SETUP */ cpu_to_le16(9), | |
63 | /* SMB2_LOGOFF */ cpu_to_le16(4), | |
64 | /* SMB2_TREE_CONNECT */ cpu_to_le16(16), | |
65 | /* SMB2_TREE_DISCONNECT */ cpu_to_le16(4), | |
66 | /* SMB2_CREATE */ cpu_to_le16(89), | |
67 | /* SMB2_CLOSE */ cpu_to_le16(60), | |
68 | /* SMB2_FLUSH */ cpu_to_le16(4), | |
69 | /* SMB2_READ */ cpu_to_le16(17), | |
70 | /* SMB2_WRITE */ cpu_to_le16(17), | |
71 | /* SMB2_LOCK */ cpu_to_le16(4), | |
72 | /* SMB2_IOCTL */ cpu_to_le16(49), | |
093b2bda | 73 | /* BB CHECK this ... not listed in documentation */ |
bc09d141 FF |
74 | /* SMB2_CANCEL */ cpu_to_le16(0), |
75 | /* SMB2_ECHO */ cpu_to_le16(4), | |
76 | /* SMB2_QUERY_DIRECTORY */ cpu_to_le16(9), | |
77 | /* SMB2_CHANGE_NOTIFY */ cpu_to_le16(9), | |
78 | /* SMB2_QUERY_INFO */ cpu_to_le16(9), | |
79 | /* SMB2_SET_INFO */ cpu_to_le16(2), | |
093b2bda | 80 | /* BB FIXME can also be 44 for lease break */ |
bc09d141 | 81 | /* SMB2_OPLOCK_BREAK */ cpu_to_le16(24) |
093b2bda PS |
82 | }; |
83 | ||
0d35e382 | 84 | #define SMB311_NEGPROT_BASE_SIZE (sizeof(struct smb2_hdr) + sizeof(struct smb2_negotiate_rsp)) |
bc7c4129 | 85 | |
0d35e382 | 86 | static __u32 get_neg_ctxt_len(struct smb2_hdr *hdr, __u32 len, |
1fc6ad2f | 87 | __u32 non_ctxlen) |
136ff1b4 SF |
88 | { |
89 | __u16 neg_count; | |
90 | __u32 nc_offset, size_of_pad_before_neg_ctxts; | |
91 | struct smb2_negotiate_rsp *pneg_rsp = (struct smb2_negotiate_rsp *)hdr; | |
92 | ||
93 | /* Negotiate contexts are only valid for latest dialect SMB3.11 */ | |
94 | neg_count = le16_to_cpu(pneg_rsp->NegotiateContextCount); | |
95 | if ((neg_count == 0) || | |
96 | (pneg_rsp->DialectRevision != cpu_to_le16(SMB311_PROT_ID))) | |
97 | return 0; | |
98 | ||
145024e3 SF |
99 | /* |
100 | * if SPNEGO blob present (ie the RFC2478 GSS info which indicates | |
101 | * which security mechanisms the server supports) make sure that | |
102 | * the negotiate contexts start after it | |
103 | */ | |
136ff1b4 | 104 | nc_offset = le32_to_cpu(pneg_rsp->NegotiateContextOffset); |
145024e3 SF |
105 | /* |
106 | * non_ctxlen is at least shdr->StructureSize + pdu->StructureSize2 | |
107 | * and the latter is 1 byte bigger than the fix-sized area of the | |
108 | * NEGOTIATE response | |
109 | */ | |
bc7c4129 SF |
110 | if (nc_offset + 1 < non_ctxlen) { |
111 | pr_warn_once("Invalid negotiate context offset %d\n", nc_offset); | |
136ff1b4 | 112 | return 0; |
bc7c4129 SF |
113 | } else if (nc_offset + 1 == non_ctxlen) { |
114 | cifs_dbg(FYI, "no SPNEGO security blob in negprot rsp\n"); | |
115 | size_of_pad_before_neg_ctxts = 0; | |
eb3e28c1 | 116 | } else if (non_ctxlen == SMB311_NEGPROT_BASE_SIZE + 1) |
bc7c4129 SF |
117 | /* has padding, but no SPNEGO blob */ |
118 | size_of_pad_before_neg_ctxts = nc_offset - non_ctxlen + 1; | |
119 | else | |
120 | size_of_pad_before_neg_ctxts = nc_offset - non_ctxlen; | |
136ff1b4 SF |
121 | |
122 | /* Verify that at least minimal negotiate contexts fit within frame */ | |
123 | if (len < nc_offset + (neg_count * sizeof(struct smb2_neg_context))) { | |
a0a3036b | 124 | pr_warn_once("negotiate context goes beyond end\n"); |
136ff1b4 SF |
125 | return 0; |
126 | } | |
127 | ||
128 | cifs_dbg(FYI, "length of negcontexts %d pad %d\n", | |
129 | len - nc_offset, size_of_pad_before_neg_ctxts); | |
130 | ||
131 | /* length of negcontexts including pad from end of sec blob to them */ | |
132 | return (len - nc_offset) + size_of_pad_before_neg_ctxts; | |
133 | } | |
136ff1b4 | 134 | |
093b2bda | 135 | int |
da384789 | 136 | smb2_check_message(char *buf, unsigned int len, struct TCP_Server_Info *server) |
093b2bda | 137 | { |
8abcaeae | 138 | struct TCP_Server_Info *pserver; |
0d35e382 RS |
139 | struct smb2_hdr *shdr = (struct smb2_hdr *)buf; |
140 | struct smb2_pdu *pdu = (struct smb2_pdu *)shdr; | |
0d35e382 | 141 | int hdr_size = sizeof(struct smb2_hdr); |
da384789 EM |
142 | int pdu_size = sizeof(struct smb2_pdu); |
143 | int command; | |
144 | __u32 calc_len; /* calculated length */ | |
145 | __u64 mid; | |
093b2bda | 146 | |
8abcaeae SP |
147 | /* If server is a channel, select the primary channel */ |
148 | pserver = CIFS_SERVER_IS_CHAN(server) ? server->primary_server : server; | |
149 | ||
093b2bda PS |
150 | /* |
151 | * Add function to do table lookup of StructureSize by command | |
152 | * ie Validate the wct via smb2_struct_sizes table above | |
153 | */ | |
31473fc4 | 154 | if (shdr->ProtocolId == SMB2_TRANSFORM_PROTO_NUM) { |
373512ec SF |
155 | struct smb2_transform_hdr *thdr = |
156 | (struct smb2_transform_hdr *)buf; | |
157 | struct cifs_ses *ses = NULL; | |
00c796ee | 158 | struct cifs_ses *iter; |
373512ec SF |
159 | |
160 | /* decrypt frame now that it is completely read in */ | |
161 | spin_lock(&cifs_tcp_ses_lock); | |
8abcaeae | 162 | list_for_each_entry(iter, &pserver->smb_ses_list, smb_ses_list) { |
00c796ee JK |
163 | if (iter->Suid == le64_to_cpu(thdr->SessionId)) { |
164 | ses = iter; | |
373512ec | 165 | break; |
00c796ee | 166 | } |
373512ec SF |
167 | } |
168 | spin_unlock(&cifs_tcp_ses_lock); | |
00c796ee | 169 | if (!ses) { |
373512ec SF |
170 | cifs_dbg(VFS, "no decryption - session id not found\n"); |
171 | return 1; | |
172 | } | |
173 | } | |
174 | ||
31473fc4 | 175 | mid = le64_to_cpu(shdr->MessageId); |
98170fb5 RS |
176 | if (len < pdu_size) { |
177 | if ((len >= hdr_size) | |
31473fc4 | 178 | && (shdr->Status != 0)) { |
093b2bda PS |
179 | pdu->StructureSize2 = 0; |
180 | /* | |
181 | * As with SMB/CIFS, on some error cases servers may | |
182 | * not return wct properly | |
183 | */ | |
184 | return 0; | |
185 | } else { | |
f96637be | 186 | cifs_dbg(VFS, "Length less than SMB header size\n"); |
093b2bda PS |
187 | } |
188 | return 1; | |
189 | } | |
1fc6ad2f | 190 | if (len > CIFSMaxBufSize + MAX_SMB2_HDR_SIZE) { |
f96637be JP |
191 | cifs_dbg(VFS, "SMB length greater than maximum, mid=%llu\n", |
192 | mid); | |
093b2bda PS |
193 | return 1; |
194 | } | |
195 | ||
31473fc4 | 196 | if (check_smb2_hdr(shdr, mid)) |
093b2bda PS |
197 | return 1; |
198 | ||
31473fc4 | 199 | if (shdr->StructureSize != SMB2_HEADER_STRUCTURE_SIZE) { |
a0a3036b | 200 | cifs_dbg(VFS, "Invalid structure size %u\n", |
31473fc4 | 201 | le16_to_cpu(shdr->StructureSize)); |
093b2bda PS |
202 | return 1; |
203 | } | |
204 | ||
31473fc4 | 205 | command = le16_to_cpu(shdr->Command); |
093b2bda | 206 | if (command >= NUMBER_OF_SMB2_COMMANDS) { |
a0a3036b | 207 | cifs_dbg(VFS, "Invalid SMB2 command %d\n", command); |
093b2bda PS |
208 | return 1; |
209 | } | |
210 | ||
211 | if (smb2_rsp_struct_sizes[command] != pdu->StructureSize2) { | |
31473fc4 | 212 | if (command != SMB2_OPLOCK_BREAK_HE && (shdr->Status == 0 || |
113be37d | 213 | pdu->StructureSize2 != SMB2_ERROR_STRUCTURE_SIZE2_LE)) { |
093b2bda | 214 | /* error packets have 9 byte structure size */ |
a0a3036b | 215 | cifs_dbg(VFS, "Invalid response size %u for command %d\n", |
f96637be | 216 | le16_to_cpu(pdu->StructureSize2), command); |
093b2bda | 217 | return 1; |
31473fc4 PS |
218 | } else if (command == SMB2_OPLOCK_BREAK_HE |
219 | && (shdr->Status == 0) | |
0822f514 PS |
220 | && (le16_to_cpu(pdu->StructureSize2) != 44) |
221 | && (le16_to_cpu(pdu->StructureSize2) != 36)) { | |
222 | /* special case for SMB2.1 lease break message */ | |
a0a3036b | 223 | cifs_dbg(VFS, "Invalid response size %d for oplock break\n", |
f96637be | 224 | le16_to_cpu(pdu->StructureSize2)); |
0822f514 | 225 | return 1; |
093b2bda PS |
226 | } |
227 | } | |
228 | ||
68ed1449 | 229 | calc_len = smb2_calc_size(buf); |
da384789 EM |
230 | |
231 | /* For SMB2_IOCTL, OutputOffset and OutputLength are optional, so might | |
232 | * be 0, and not a real miscalculation */ | |
233 | if (command == SMB2_IOCTL_HE && calc_len == 0) | |
234 | return 0; | |
093b2bda | 235 | |
da384789 EM |
236 | if (command == SMB2_NEGOTIATE_HE) |
237 | calc_len += get_neg_ctxt_len(shdr, len, calc_len); | |
0fdfef9a | 238 | |
da384789 | 239 | if (len != calc_len) { |
b42bf888 PS |
240 | /* create failed on symlink */ |
241 | if (command == SMB2_CREATE_HE && | |
31473fc4 | 242 | shdr->Status == STATUS_STOPPED_ON_SYMLINK) |
b42bf888 | 243 | return 0; |
983c88a4 | 244 | /* Windows 7 server returns 24 bytes more */ |
da384789 | 245 | if (calc_len + 24 == len && command == SMB2_OPLOCK_BREAK_HE) |
983c88a4 | 246 | return 0; |
754789a1 | 247 | /* server can return one byte more due to implied bcc[0] */ |
da384789 | 248 | if (calc_len == len + 1) |
74112860 | 249 | return 0; |
754789a1 | 250 | |
e6c47dd0 RS |
251 | /* |
252 | * Some windows servers (win2016) will pad also the final | |
253 | * PDU in a compound to 8 bytes. | |
254 | */ | |
d7173623 | 255 | if (ALIGN(calc_len, 8) == len) |
e6c47dd0 RS |
256 | return 0; |
257 | ||
754789a1 SF |
258 | /* |
259 | * MacOS server pads after SMB2.1 write response with 3 bytes | |
260 | * of junk. Other servers match RFC1001 len to actual | |
261 | * SMB2/SMB3 frame length (header + smb2 response specific data) | |
25f25735 | 262 | * Some windows servers also pad up to 8 bytes when compounding. |
754789a1 | 263 | */ |
da384789 | 264 | if (calc_len < len) |
754789a1 | 265 | return 0; |
037d0507 | 266 | |
da384789 EM |
267 | /* Only log a message if len was really miscalculated */ |
268 | if (unlikely(cifsFYI)) | |
269 | cifs_dbg(FYI, "Server response too short: calculated " | |
270 | "length %u doesn't match read length %u (cmd=%d, mid=%llu)\n", | |
271 | calc_len, len, command, mid); | |
272 | else | |
273 | pr_warn("Server response too short: calculated length " | |
274 | "%u doesn't match read length %u (cmd=%d, mid=%llu)\n", | |
275 | calc_len, len, command, mid); | |
754789a1 | 276 | |
093b2bda PS |
277 | return 1; |
278 | } | |
279 | return 0; | |
280 | } | |
281 | ||
282 | /* | |
283 | * The size of the variable area depends on the offset and length fields | |
284 | * located in different fields for various SMB2 responses. SMB2 responses | |
285 | * with no variable length info, show an offset of zero for the offset field. | |
286 | */ | |
287 | static const bool has_smb2_data_area[NUMBER_OF_SMB2_COMMANDS] = { | |
288 | /* SMB2_NEGOTIATE */ true, | |
289 | /* SMB2_SESSION_SETUP */ true, | |
290 | /* SMB2_LOGOFF */ false, | |
291 | /* SMB2_TREE_CONNECT */ false, | |
292 | /* SMB2_TREE_DISCONNECT */ false, | |
293 | /* SMB2_CREATE */ true, | |
294 | /* SMB2_CLOSE */ false, | |
295 | /* SMB2_FLUSH */ false, | |
296 | /* SMB2_READ */ true, | |
297 | /* SMB2_WRITE */ false, | |
298 | /* SMB2_LOCK */ false, | |
299 | /* SMB2_IOCTL */ true, | |
300 | /* SMB2_CANCEL */ false, /* BB CHECK this not listed in documentation */ | |
301 | /* SMB2_ECHO */ false, | |
302 | /* SMB2_QUERY_DIRECTORY */ true, | |
303 | /* SMB2_CHANGE_NOTIFY */ true, | |
304 | /* SMB2_QUERY_INFO */ true, | |
305 | /* SMB2_SET_INFO */ false, | |
306 | /* SMB2_OPLOCK_BREAK */ false | |
307 | }; | |
308 | ||
309 | /* | |
310 | * Returns the pointer to the beginning of the data area. Length of the data | |
311 | * area and the offset to it (from the beginning of the smb are also returned. | |
312 | */ | |
ec2e4523 | 313 | char * |
0d35e382 | 314 | smb2_get_data_area_len(int *off, int *len, struct smb2_hdr *shdr) |
093b2bda PS |
315 | { |
316 | *off = 0; | |
317 | *len = 0; | |
318 | ||
319 | /* error responses do not have data area */ | |
31473fc4 | 320 | if (shdr->Status && shdr->Status != STATUS_MORE_PROCESSING_REQUIRED && |
e4dc31fe | 321 | (((struct smb2_err_rsp *)shdr)->StructureSize) == |
113be37d | 322 | SMB2_ERROR_STRUCTURE_SIZE2_LE) |
093b2bda PS |
323 | return NULL; |
324 | ||
325 | /* | |
326 | * Following commands have data areas so we have to get the location | |
327 | * of the data buffer offset and data buffer length for the particular | |
328 | * command. | |
329 | */ | |
31473fc4 | 330 | switch (shdr->Command) { |
093b2bda | 331 | case SMB2_NEGOTIATE: |
ec2e4523 | 332 | *off = le16_to_cpu( |
e4dc31fe | 333 | ((struct smb2_negotiate_rsp *)shdr)->SecurityBufferOffset); |
ec2e4523 | 334 | *len = le16_to_cpu( |
e4dc31fe | 335 | ((struct smb2_negotiate_rsp *)shdr)->SecurityBufferLength); |
ec2e4523 | 336 | break; |
093b2bda | 337 | case SMB2_SESSION_SETUP: |
5478f9ba | 338 | *off = le16_to_cpu( |
e4dc31fe | 339 | ((struct smb2_sess_setup_rsp *)shdr)->SecurityBufferOffset); |
5478f9ba | 340 | *len = le16_to_cpu( |
e4dc31fe | 341 | ((struct smb2_sess_setup_rsp *)shdr)->SecurityBufferLength); |
5478f9ba | 342 | break; |
093b2bda | 343 | case SMB2_CREATE: |
2503a0db | 344 | *off = le32_to_cpu( |
e4dc31fe | 345 | ((struct smb2_create_rsp *)shdr)->CreateContextsOffset); |
2503a0db | 346 | *len = le32_to_cpu( |
e4dc31fe | 347 | ((struct smb2_create_rsp *)shdr)->CreateContextsLength); |
2503a0db | 348 | break; |
093b2bda | 349 | case SMB2_QUERY_INFO: |
be4cb9e3 | 350 | *off = le16_to_cpu( |
e4dc31fe | 351 | ((struct smb2_query_info_rsp *)shdr)->OutputBufferOffset); |
be4cb9e3 | 352 | *len = le32_to_cpu( |
e4dc31fe | 353 | ((struct smb2_query_info_rsp *)shdr)->OutputBufferLength); |
be4cb9e3 PS |
354 | break; |
355 | case SMB2_READ: | |
e4dc31fe RS |
356 | /* TODO: is this a bug ? */ |
357 | *off = ((struct smb2_read_rsp *)shdr)->DataOffset; | |
358 | *len = le32_to_cpu(((struct smb2_read_rsp *)shdr)->DataLength); | |
09a4707e | 359 | break; |
093b2bda | 360 | case SMB2_QUERY_DIRECTORY: |
d324f08d | 361 | *off = le16_to_cpu( |
e4dc31fe | 362 | ((struct smb2_query_directory_rsp *)shdr)->OutputBufferOffset); |
d324f08d | 363 | *len = le32_to_cpu( |
e4dc31fe | 364 | ((struct smb2_query_directory_rsp *)shdr)->OutputBufferLength); |
d324f08d | 365 | break; |
093b2bda | 366 | case SMB2_IOCTL: |
4a72dafa | 367 | *off = le32_to_cpu( |
e4dc31fe RS |
368 | ((struct smb2_ioctl_rsp *)shdr)->OutputOffset); |
369 | *len = le32_to_cpu( | |
370 | ((struct smb2_ioctl_rsp *)shdr)->OutputCount); | |
4a72dafa | 371 | break; |
093b2bda | 372 | case SMB2_CHANGE_NOTIFY: |
8668115c SF |
373 | *off = le16_to_cpu( |
374 | ((struct smb2_change_notify_rsp *)shdr)->OutputBufferOffset); | |
375 | *len = le32_to_cpu( | |
376 | ((struct smb2_change_notify_rsp *)shdr)->OutputBufferLength); | |
377 | break; | |
093b2bda | 378 | default: |
8668115c | 379 | cifs_dbg(VFS, "no length check for command %d\n", le16_to_cpu(shdr->Command)); |
093b2bda PS |
380 | break; |
381 | } | |
382 | ||
383 | /* | |
384 | * Invalid length or offset probably means data area is invalid, but | |
385 | * we have little choice but to ignore the data area in this case. | |
386 | */ | |
387 | if (*off > 4096) { | |
f96637be | 388 | cifs_dbg(VFS, "offset %d too large, data area ignored\n", *off); |
093b2bda PS |
389 | *len = 0; |
390 | *off = 0; | |
391 | } else if (*off < 0) { | |
f96637be JP |
392 | cifs_dbg(VFS, "negative offset %d to data invalid ignore data area\n", |
393 | *off); | |
093b2bda PS |
394 | *off = 0; |
395 | *len = 0; | |
396 | } else if (*len < 0) { | |
f96637be JP |
397 | cifs_dbg(VFS, "negative data length %d invalid, data area ignored\n", |
398 | *len); | |
093b2bda PS |
399 | *len = 0; |
400 | } else if (*len > 128 * 1024) { | |
f96637be | 401 | cifs_dbg(VFS, "data area larger than 128K: %d\n", *len); |
093b2bda PS |
402 | *len = 0; |
403 | } | |
404 | ||
405 | /* return pointer to beginning of data area, ie offset from SMB start */ | |
406 | if ((*off != 0) && (*len != 0)) | |
31473fc4 | 407 | return (char *)shdr + *off; |
093b2bda PS |
408 | else |
409 | return NULL; | |
410 | } | |
411 | ||
412 | /* | |
413 | * Calculate the size of the SMB message based on the fixed header | |
414 | * portion, the number of word parameters and the data portion of the message. | |
415 | */ | |
416 | unsigned int | |
68ed1449 | 417 | smb2_calc_size(void *buf) |
093b2bda | 418 | { |
0f46608a | 419 | struct smb2_pdu *pdu = buf; |
0d35e382 | 420 | struct smb2_hdr *shdr = &pdu->hdr; |
093b2bda PS |
421 | int offset; /* the offset from the beginning of SMB to data area */ |
422 | int data_length; /* the length of the variable length data area */ | |
423 | /* Structure Size has already been checked to make sure it is 64 */ | |
1fc6ad2f | 424 | int len = le16_to_cpu(shdr->StructureSize); |
093b2bda PS |
425 | |
426 | /* | |
427 | * StructureSize2, ie length of fixed parameter area has already | |
428 | * been checked to make sure it is the correct length. | |
429 | */ | |
430 | len += le16_to_cpu(pdu->StructureSize2); | |
431 | ||
31473fc4 | 432 | if (has_smb2_data_area[le16_to_cpu(shdr->Command)] == false) |
093b2bda PS |
433 | goto calc_size_exit; |
434 | ||
e4dc31fe | 435 | smb2_get_data_area_len(&offset, &data_length, shdr); |
f96637be | 436 | cifs_dbg(FYI, "SMB2 data length %d offset %d\n", data_length, offset); |
093b2bda PS |
437 | |
438 | if (data_length > 0) { | |
439 | /* | |
440 | * Check to make sure that data area begins after fixed area, | |
441 | * Note that last byte of the fixed area is part of data area | |
442 | * for some commands, typically those with odd StructureSize, | |
84f0cbfb | 443 | * so we must add one to the calculation. |
093b2bda | 444 | */ |
1fc6ad2f RS |
445 | if (offset + 1 < len) { |
446 | cifs_dbg(VFS, "data area offset %d overlaps SMB2 header %d\n", | |
447 | offset + 1, len); | |
093b2bda PS |
448 | data_length = 0; |
449 | } else { | |
1fc6ad2f | 450 | len = offset + data_length; |
093b2bda PS |
451 | } |
452 | } | |
453 | calc_size_exit: | |
f96637be | 454 | cifs_dbg(FYI, "SMB2 len %d\n", len); |
093b2bda PS |
455 | return len; |
456 | } | |
2503a0db PS |
457 | |
458 | /* Note: caller must free return buffer */ | |
459 | __le16 * | |
460 | cifs_convert_path_to_utf16(const char *from, struct cifs_sb_info *cifs_sb) | |
461 | { | |
462 | int len; | |
463 | const char *start_of_path; | |
464 | __le16 *to; | |
a4153cb1 SF |
465 | int map_type; |
466 | ||
467 | if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR) | |
468 | map_type = SFM_MAP_UNI_RSVD; | |
469 | else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR) | |
470 | map_type = SFU_MAP_UNI_RSVD; | |
471 | else | |
472 | map_type = NO_MAP_UNI_RSVD; | |
2503a0db PS |
473 | |
474 | /* Windows doesn't allow paths beginning with \ */ | |
475 | if (from[0] == '\\') | |
476 | start_of_path = from + 1; | |
0fdfef9a | 477 | |
ce558b0e | 478 | /* SMB311 POSIX extensions paths do not include leading slash */ |
8ddecf5f | 479 | else if (cifs_sb_master_tlink(cifs_sb) && |
d819d298 SF |
480 | cifs_sb_master_tcon(cifs_sb)->posix_extensions && |
481 | (from[0] == '/')) { | |
ce558b0e | 482 | start_of_path = from + 1; |
0fdfef9a | 483 | } else |
2503a0db | 484 | start_of_path = from; |
ce558b0e | 485 | |
2503a0db | 486 | to = cifs_strndup_to_utf16(start_of_path, PATH_MAX, &len, |
a4153cb1 | 487 | cifs_sb->local_nls, map_type); |
2503a0db PS |
488 | return to; |
489 | } | |
983c88a4 | 490 | |
0822f514 PS |
491 | __le32 |
492 | smb2_get_lease_state(struct cifsInodeInfo *cinode) | |
493 | { | |
53ef1016 | 494 | __le32 lease = 0; |
0822f514 | 495 | |
53ef1016 | 496 | if (CIFS_CACHE_WRITE(cinode)) |
113be37d | 497 | lease |= SMB2_LEASE_WRITE_CACHING_LE; |
53ef1016 | 498 | if (CIFS_CACHE_HANDLE(cinode)) |
113be37d | 499 | lease |= SMB2_LEASE_HANDLE_CACHING_LE; |
53ef1016 | 500 | if (CIFS_CACHE_READ(cinode)) |
113be37d | 501 | lease |= SMB2_LEASE_READ_CACHING_LE; |
53ef1016 | 502 | return lease; |
0822f514 PS |
503 | } |
504 | ||
233839b1 PS |
505 | struct smb2_lease_break_work { |
506 | struct work_struct lease_break; | |
507 | struct tcon_link *tlink; | |
508 | __u8 lease_key[16]; | |
509 | __le32 lease_state; | |
510 | }; | |
511 | ||
512 | static void | |
513 | cifs_ses_oplock_break(struct work_struct *work) | |
514 | { | |
515 | struct smb2_lease_break_work *lw = container_of(work, | |
516 | struct smb2_lease_break_work, lease_break); | |
a93864d9 | 517 | int rc = 0; |
233839b1 PS |
518 | |
519 | rc = SMB2_lease_break(0, tlink_tcon(lw->tlink), lw->lease_key, | |
520 | lw->lease_state); | |
a93864d9 | 521 | |
f96637be | 522 | cifs_dbg(FYI, "Lease release rc %d\n", rc); |
233839b1 PS |
523 | cifs_put_tlink(lw->tlink); |
524 | kfree(lw); | |
525 | } | |
526 | ||
baf57b56 PA |
527 | static void |
528 | smb2_queue_pending_open_break(struct tcon_link *tlink, __u8 *lease_key, | |
529 | __le32 new_lease_state) | |
530 | { | |
531 | struct smb2_lease_break_work *lw; | |
532 | ||
533 | lw = kmalloc(sizeof(struct smb2_lease_break_work), GFP_KERNEL); | |
534 | if (!lw) { | |
535 | cifs_put_tlink(tlink); | |
536 | return; | |
537 | } | |
538 | ||
539 | INIT_WORK(&lw->lease_break, cifs_ses_oplock_break); | |
540 | lw->tlink = tlink; | |
541 | lw->lease_state = new_lease_state; | |
542 | memcpy(lw->lease_key, lease_key, SMB2_LEASE_KEY_SIZE); | |
543 | queue_work(cifsiod_wq, &lw->lease_break); | |
544 | } | |
545 | ||
0822f514 | 546 | static bool |
baf57b56 | 547 | smb2_tcon_has_lease(struct cifs_tcon *tcon, struct smb2_lease_break *rsp) |
933d4b36 | 548 | { |
933d4b36 | 549 | __u8 lease_state; |
933d4b36 | 550 | struct cifsFileInfo *cfile; |
933d4b36 PS |
551 | struct cifsInodeInfo *cinode; |
552 | int ack_req = le32_to_cpu(rsp->Flags & | |
553 | SMB2_NOTIFY_BREAK_LEASE_FLAG_ACK_REQUIRED); | |
554 | ||
53ef1016 | 555 | lease_state = le32_to_cpu(rsp->NewLeaseState); |
933d4b36 | 556 | |
647f5927 | 557 | list_for_each_entry(cfile, &tcon->openFileList, tlist) { |
2b0143b5 | 558 | cinode = CIFS_I(d_inode(cfile->dentry)); |
933d4b36 PS |
559 | |
560 | if (memcmp(cinode->lease_key, rsp->LeaseKey, | |
561 | SMB2_LEASE_KEY_SIZE)) | |
562 | continue; | |
563 | ||
564 | cifs_dbg(FYI, "found in the open list\n"); | |
59b04c5d | 565 | cifs_dbg(FYI, "lease key match, lease break 0x%x\n", |
9bd45408 | 566 | lease_state); |
933d4b36 | 567 | |
933d4b36 PS |
568 | if (ack_req) |
569 | cfile->oplock_break_cancelled = false; | |
570 | else | |
571 | cfile->oplock_break_cancelled = true; | |
572 | ||
7b9b9edb PS |
573 | set_bit(CIFS_INODE_PENDING_OPLOCK_BREAK, &cinode->flags); |
574 | ||
9bd45408 PS |
575 | cfile->oplock_epoch = le16_to_cpu(rsp->Epoch); |
576 | cfile->oplock_level = lease_state; | |
7b9b9edb | 577 | |
b98749ca | 578 | cifs_queue_oplock_break(cfile); |
933d4b36 PS |
579 | return true; |
580 | } | |
581 | ||
baf57b56 PA |
582 | return false; |
583 | } | |
584 | ||
585 | static struct cifs_pending_open * | |
586 | smb2_tcon_find_pending_open_lease(struct cifs_tcon *tcon, | |
587 | struct smb2_lease_break *rsp) | |
588 | { | |
589 | __u8 lease_state = le32_to_cpu(rsp->NewLeaseState); | |
590 | int ack_req = le32_to_cpu(rsp->Flags & | |
591 | SMB2_NOTIFY_BREAK_LEASE_FLAG_ACK_REQUIRED); | |
592 | struct cifs_pending_open *open; | |
593 | struct cifs_pending_open *found = NULL; | |
594 | ||
933d4b36 PS |
595 | list_for_each_entry(open, &tcon->pending_opens, olist) { |
596 | if (memcmp(open->lease_key, rsp->LeaseKey, | |
597 | SMB2_LEASE_KEY_SIZE)) | |
598 | continue; | |
599 | ||
600 | if (!found && ack_req) { | |
baf57b56 | 601 | found = open; |
933d4b36 PS |
602 | } |
603 | ||
604 | cifs_dbg(FYI, "found in the pending open list\n"); | |
59b04c5d | 605 | cifs_dbg(FYI, "lease key match, lease break 0x%x\n", |
9bd45408 | 606 | lease_state); |
933d4b36 PS |
607 | |
608 | open->oplock = lease_state; | |
609 | } | |
a93864d9 | 610 | |
933d4b36 PS |
611 | return found; |
612 | } | |
613 | ||
614 | static bool | |
23d9b9b7 | 615 | smb2_is_valid_lease_break(char *buffer, struct TCP_Server_Info *server) |
0822f514 PS |
616 | { |
617 | struct smb2_lease_break *rsp = (struct smb2_lease_break *)buffer; | |
23d9b9b7 | 618 | struct TCP_Server_Info *pserver; |
0822f514 PS |
619 | struct cifs_ses *ses; |
620 | struct cifs_tcon *tcon; | |
baf57b56 | 621 | struct cifs_pending_open *open; |
0822f514 | 622 | |
f96637be | 623 | cifs_dbg(FYI, "Checking for lease break\n"); |
0822f514 | 624 | |
23d9b9b7 SP |
625 | /* If server is a channel, select the primary channel */ |
626 | pserver = CIFS_SERVER_IS_CHAN(server) ? server->primary_server : server; | |
627 | ||
0822f514 PS |
628 | /* look up tcon based on tid & uid */ |
629 | spin_lock(&cifs_tcp_ses_lock); | |
23d9b9b7 SP |
630 | list_for_each_entry(ses, &pserver->smb_ses_list, smb_ses_list) { |
631 | list_for_each_entry(tcon, &ses->tcon_list, tcon_list) { | |
632 | spin_lock(&tcon->open_file_lock); | |
633 | cifs_stats_inc( | |
634 | &tcon->stats.cifs_stats.num_oplock_brks); | |
635 | if (smb2_tcon_has_lease(tcon, rsp)) { | |
3afca265 | 636 | spin_unlock(&tcon->open_file_lock); |
23d9b9b7 SP |
637 | spin_unlock(&cifs_tcp_ses_lock); |
638 | return true; | |
639 | } | |
640 | open = smb2_tcon_find_pending_open_lease(tcon, | |
641 | rsp); | |
642 | if (open) { | |
643 | __u8 lease_key[SMB2_LEASE_KEY_SIZE]; | |
644 | struct tcon_link *tlink; | |
645 | ||
646 | tlink = cifs_get_tlink(open->tlink); | |
647 | memcpy(lease_key, open->lease_key, | |
648 | SMB2_LEASE_KEY_SIZE); | |
649 | spin_unlock(&tcon->open_file_lock); | |
650 | spin_unlock(&cifs_tcp_ses_lock); | |
651 | smb2_queue_pending_open_break(tlink, | |
652 | lease_key, | |
653 | rsp->NewLeaseState); | |
654 | return true; | |
655 | } | |
656 | spin_unlock(&tcon->open_file_lock); | |
a93864d9 | 657 | |
23d9b9b7 SP |
658 | if (cached_dir_lease_break(tcon, rsp->LeaseKey)) { |
659 | spin_unlock(&cifs_tcp_ses_lock); | |
660 | return true; | |
233839b1 | 661 | } |
0822f514 PS |
662 | } |
663 | } | |
664 | spin_unlock(&cifs_tcp_ses_lock); | |
f96637be | 665 | cifs_dbg(FYI, "Can not process lease break - no lease matched\n"); |
fb253d5b SF |
666 | trace_smb3_lease_not_found(le32_to_cpu(rsp->CurrentLeaseState), |
667 | le32_to_cpu(rsp->hdr.Id.SyncId.TreeId), | |
668 | le64_to_cpu(rsp->hdr.SessionId), | |
669 | *((u64 *)rsp->LeaseKey), | |
670 | *((u64 *)&rsp->LeaseKey[8])); | |
671 | ||
0822f514 PS |
672 | return false; |
673 | } | |
674 | ||
983c88a4 PS |
675 | bool |
676 | smb2_is_valid_oplock_break(char *buffer, struct TCP_Server_Info *server) | |
677 | { | |
0d5a288d | 678 | struct smb2_oplock_break *rsp = (struct smb2_oplock_break *)buffer; |
8abcaeae | 679 | struct TCP_Server_Info *pserver; |
983c88a4 PS |
680 | struct cifs_ses *ses; |
681 | struct cifs_tcon *tcon; | |
682 | struct cifsInodeInfo *cinode; | |
683 | struct cifsFileInfo *cfile; | |
684 | ||
f96637be | 685 | cifs_dbg(FYI, "Checking for oplock break\n"); |
983c88a4 | 686 | |
0d35e382 | 687 | if (rsp->hdr.Command != SMB2_OPLOCK_BREAK) |
983c88a4 PS |
688 | return false; |
689 | ||
12e8a208 | 690 | if (rsp->StructureSize != |
983c88a4 | 691 | smb2_rsp_struct_sizes[SMB2_OPLOCK_BREAK_HE]) { |
0822f514 | 692 | if (le16_to_cpu(rsp->StructureSize) == 44) |
23d9b9b7 | 693 | return smb2_is_valid_lease_break(buffer, server); |
0822f514 PS |
694 | else |
695 | return false; | |
983c88a4 PS |
696 | } |
697 | ||
59b04c5d | 698 | cifs_dbg(FYI, "oplock level 0x%x\n", rsp->OplockLevel); |
983c88a4 | 699 | |
8abcaeae SP |
700 | /* If server is a channel, select the primary channel */ |
701 | pserver = CIFS_SERVER_IS_CHAN(server) ? server->primary_server : server; | |
702 | ||
983c88a4 PS |
703 | /* look up tcon based on tid & uid */ |
704 | spin_lock(&cifs_tcp_ses_lock); | |
8abcaeae | 705 | list_for_each_entry(ses, &pserver->smb_ses_list, smb_ses_list) { |
647f5927 | 706 | list_for_each_entry(tcon, &ses->tcon_list, tcon_list) { |
983c88a4 | 707 | |
3afca265 | 708 | spin_lock(&tcon->open_file_lock); |
647f5927 | 709 | list_for_each_entry(cfile, &tcon->openFileList, tlist) { |
983c88a4 PS |
710 | if (rsp->PersistentFid != |
711 | cfile->fid.persistent_fid || | |
712 | rsp->VolatileFid != | |
713 | cfile->fid.volatile_fid) | |
714 | continue; | |
715 | ||
f96637be | 716 | cifs_dbg(FYI, "file id match, oplock break\n"); |
fa9c2362 PS |
717 | cifs_stats_inc( |
718 | &tcon->stats.cifs_stats.num_oplock_brks); | |
2b0143b5 | 719 | cinode = CIFS_I(d_inode(cfile->dentry)); |
3afca265 | 720 | spin_lock(&cfile->file_info_lock); |
18cceb6a | 721 | if (!CIFS_CACHE_WRITE(cinode) && |
983c88a4 PS |
722 | rsp->OplockLevel == SMB2_OPLOCK_LEVEL_NONE) |
723 | cfile->oplock_break_cancelled = true; | |
724 | else | |
725 | cfile->oplock_break_cancelled = false; | |
726 | ||
c11f1df5 SP |
727 | set_bit(CIFS_INODE_PENDING_OPLOCK_BREAK, |
728 | &cinode->flags); | |
729 | ||
9bd45408 PS |
730 | cfile->oplock_epoch = 0; |
731 | cfile->oplock_level = rsp->OplockLevel; | |
732 | ||
3afca265 | 733 | spin_unlock(&cfile->file_info_lock); |
b98749ca AA |
734 | |
735 | cifs_queue_oplock_break(cfile); | |
983c88a4 | 736 | |
3afca265 | 737 | spin_unlock(&tcon->open_file_lock); |
983c88a4 PS |
738 | spin_unlock(&cifs_tcp_ses_lock); |
739 | return true; | |
740 | } | |
3afca265 | 741 | spin_unlock(&tcon->open_file_lock); |
983c88a4 PS |
742 | } |
743 | } | |
744 | spin_unlock(&cifs_tcp_ses_lock); | |
219481a8 | 745 | cifs_dbg(FYI, "No file id matched, oplock break ignored\n"); |
35a2b533 SF |
746 | trace_smb3_oplock_not_found(0 /* no xid */, rsp->PersistentFid, |
747 | le32_to_cpu(rsp->hdr.Id.SyncId.TreeId), | |
748 | le64_to_cpu(rsp->hdr.SessionId)); | |
749 | ||
219481a8 | 750 | return true; |
983c88a4 | 751 | } |
38bd4906 SP |
752 | |
753 | void | |
754 | smb2_cancelled_close_fid(struct work_struct *work) | |
755 | { | |
756 | struct close_cancelled_open *cancelled = container_of(work, | |
757 | struct close_cancelled_open, work); | |
87bc2376 RS |
758 | struct cifs_tcon *tcon = cancelled->tcon; |
759 | int rc; | |
760 | ||
761 | if (cancelled->mid) | |
bf1bc694 | 762 | cifs_tcon_dbg(VFS, "Close unmatched open for MID:%llu\n", |
87bc2376 RS |
763 | cancelled->mid); |
764 | else | |
765 | cifs_tcon_dbg(VFS, "Close interrupted close\n"); | |
38bd4906 | 766 | |
87bc2376 RS |
767 | rc = SMB2_close(0, tcon, cancelled->fid.persistent_fid, |
768 | cancelled->fid.volatile_fid); | |
769 | if (rc) | |
770 | cifs_tcon_dbg(VFS, "Close cancelled mid failed rc:%d\n", rc); | |
38bd4906 | 771 | |
87bc2376 | 772 | cifs_put_tcon(tcon); |
38bd4906 SP |
773 | kfree(cancelled); |
774 | } | |
775 | ||
87bc2376 RS |
776 | /* |
777 | * Caller should already has an extra reference to @tcon | |
778 | * This function is used to queue work to close a handle to prevent leaks | |
779 | * on the server. | |
780 | * We handle two cases. If an open was interrupted after we sent the | |
781 | * SMB2_CREATE to the server but before we processed the reply, and second | |
782 | * if a close was interrupted before we sent the SMB2_CLOSE to the server. | |
783 | */ | |
9150c3ad | 784 | static int |
87bc2376 RS |
785 | __smb2_handle_cancelled_cmd(struct cifs_tcon *tcon, __u16 cmd, __u64 mid, |
786 | __u64 persistent_fid, __u64 volatile_fid) | |
9150c3ad PS |
787 | { |
788 | struct close_cancelled_open *cancelled; | |
789 | ||
0a5a9886 | 790 | cancelled = kzalloc(sizeof(*cancelled), GFP_ATOMIC); |
9150c3ad PS |
791 | if (!cancelled) |
792 | return -ENOMEM; | |
793 | ||
794 | cancelled->fid.persistent_fid = persistent_fid; | |
795 | cancelled->fid.volatile_fid = volatile_fid; | |
796 | cancelled->tcon = tcon; | |
87bc2376 RS |
797 | cancelled->cmd = cmd; |
798 | cancelled->mid = mid; | |
9150c3ad PS |
799 | INIT_WORK(&cancelled->work, smb2_cancelled_close_fid); |
800 | WARN_ON(queue_work(cifsiod_wq, &cancelled->work) == false); | |
801 | ||
802 | return 0; | |
803 | } | |
804 | ||
805 | int | |
806 | smb2_handle_cancelled_close(struct cifs_tcon *tcon, __u64 persistent_fid, | |
807 | __u64 volatile_fid) | |
808 | { | |
809 | int rc; | |
810 | ||
811 | cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count); | |
812 | spin_lock(&cifs_tcp_ses_lock); | |
e79b0332 AA |
813 | if (tcon->tc_count <= 0) { |
814 | struct TCP_Server_Info *server = NULL; | |
815 | ||
816 | WARN_ONCE(tcon->tc_count < 0, "tcon refcount is negative"); | |
817 | spin_unlock(&cifs_tcp_ses_lock); | |
818 | ||
819 | if (tcon->ses) | |
820 | server = tcon->ses->server; | |
821 | ||
71081e7a | 822 | cifs_server_dbg(FYI, "tid=0x%x: tcon is closing, skipping async close retry of fid %llu %llu\n", |
e79b0332 AA |
823 | tcon->tid, persistent_fid, volatile_fid); |
824 | ||
825 | return 0; | |
826 | } | |
9150c3ad PS |
827 | tcon->tc_count++; |
828 | spin_unlock(&cifs_tcp_ses_lock); | |
829 | ||
87bc2376 RS |
830 | rc = __smb2_handle_cancelled_cmd(tcon, SMB2_CLOSE_HE, 0, |
831 | persistent_fid, volatile_fid); | |
9150c3ad PS |
832 | if (rc) |
833 | cifs_put_tcon(tcon); | |
834 | ||
835 | return rc; | |
836 | } | |
837 | ||
38bd4906 | 838 | int |
04ad69c3 | 839 | smb2_handle_cancelled_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server) |
38bd4906 | 840 | { |
0d35e382 | 841 | struct smb2_hdr *hdr = mid->resp_buf; |
04ad69c3 | 842 | struct smb2_create_rsp *rsp = mid->resp_buf; |
38bd4906 | 843 | struct cifs_tcon *tcon; |
9150c3ad | 844 | int rc; |
38bd4906 | 845 | |
0d35e382 RS |
846 | if ((mid->optype & CIFS_CP_CREATE_CLOSE_OP) || hdr->Command != SMB2_CREATE || |
847 | hdr->Status != STATUS_SUCCESS) | |
38bd4906 SP |
848 | return 0; |
849 | ||
0d35e382 RS |
850 | tcon = smb2_find_smb_tcon(server, le64_to_cpu(hdr->SessionId), |
851 | le32_to_cpu(hdr->Id.SyncId.TreeId)); | |
9150c3ad | 852 | if (!tcon) |
38bd4906 | 853 | return -ENOENT; |
38bd4906 | 854 | |
87bc2376 | 855 | rc = __smb2_handle_cancelled_cmd(tcon, |
0d35e382 RS |
856 | le16_to_cpu(hdr->Command), |
857 | le64_to_cpu(hdr->MessageId), | |
351a59da PA |
858 | rsp->PersistentFileId, |
859 | rsp->VolatileFileId); | |
9150c3ad PS |
860 | if (rc) |
861 | cifs_put_tcon(tcon); | |
38bd4906 | 862 | |
9150c3ad | 863 | return rc; |
38bd4906 | 864 | } |
8bd68c6e | 865 | |
8bd68c6e AA |
866 | /** |
867 | * smb311_update_preauth_hash - update @ses hash with the packet data in @iov | |
868 | * | |
869 | * Assumes @iov does not contain the rfc1002 length and iov[0] has the | |
870 | * SMB2 header. | |
607dfc79 SF |
871 | * |
872 | * @ses: server session structure | |
3ac5f2f2 | 873 | * @server: pointer to server info |
607dfc79 SF |
874 | * @iov: array containing the SMB request we will send to the server |
875 | * @nvec: number of array entries for the iov | |
8bd68c6e AA |
876 | */ |
877 | int | |
f486ef8e SP |
878 | smb311_update_preauth_hash(struct cifs_ses *ses, struct TCP_Server_Info *server, |
879 | struct kvec *iov, int nvec) | |
8bd68c6e AA |
880 | { |
881 | int i, rc; | |
0d35e382 | 882 | struct smb2_hdr *hdr; |
1f3d5477 | 883 | struct shash_desc *sha512 = NULL; |
8bd68c6e | 884 | |
0d35e382 | 885 | hdr = (struct smb2_hdr *)iov[0].iov_base; |
d70e9fa5 AA |
886 | /* neg prot are always taken */ |
887 | if (hdr->Command == SMB2_NEGOTIATE) | |
888 | goto ok; | |
8bd68c6e | 889 | |
d70e9fa5 AA |
890 | /* |
891 | * If we process a command which wasn't a negprot it means the | |
892 | * neg prot was already done, so the server dialect was set | |
893 | * and we can test it. Preauth requires 3.1.1 for now. | |
894 | */ | |
895 | if (server->dialect != SMB311_PROT_ID) | |
896 | return 0; | |
897 | ||
898 | if (hdr->Command != SMB2_SESSION_SETUP) | |
899 | return 0; | |
900 | ||
901 | /* skip last sess setup response */ | |
902 | if ((hdr->Flags & SMB2_FLAGS_SERVER_TO_REDIR) | |
903 | && (hdr->Status == NT_STATUS_OK | |
904 | || (hdr->Status != | |
905 | cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED)))) | |
906 | return 0; | |
8bd68c6e | 907 | |
d70e9fa5 AA |
908 | ok: |
909 | rc = smb311_crypto_shash_allocate(server); | |
8bd68c6e AA |
910 | if (rc) |
911 | return rc; | |
912 | ||
1f3d5477 EM |
913 | sha512 = server->secmech.sha512; |
914 | rc = crypto_shash_init(sha512); | |
8bd68c6e | 915 | if (rc) { |
a0a3036b | 916 | cifs_dbg(VFS, "%s: Could not init sha512 shash\n", __func__); |
8bd68c6e AA |
917 | return rc; |
918 | } | |
919 | ||
1f3d5477 | 920 | rc = crypto_shash_update(sha512, ses->preauth_sha_hash, |
8bd68c6e AA |
921 | SMB2_PREAUTH_HASH_SIZE); |
922 | if (rc) { | |
a0a3036b | 923 | cifs_dbg(VFS, "%s: Could not update sha512 shash\n", __func__); |
8bd68c6e AA |
924 | return rc; |
925 | } | |
926 | ||
927 | for (i = 0; i < nvec; i++) { | |
1f3d5477 | 928 | rc = crypto_shash_update(sha512, iov[i].iov_base, iov[i].iov_len); |
8bd68c6e | 929 | if (rc) { |
a0a3036b | 930 | cifs_dbg(VFS, "%s: Could not update sha512 shash\n", |
8bd68c6e AA |
931 | __func__); |
932 | return rc; | |
933 | } | |
934 | } | |
935 | ||
1f3d5477 | 936 | rc = crypto_shash_final(sha512, ses->preauth_sha_hash); |
8bd68c6e | 937 | if (rc) { |
a0a3036b | 938 | cifs_dbg(VFS, "%s: Could not finalize sha512 shash\n", |
8bd68c6e AA |
939 | __func__); |
940 | return rc; | |
941 | } | |
942 | ||
943 | return 0; | |
944 | } |