]>
Commit | Line | Data |
---|---|---|
093b2bda PS |
1 | /* |
2 | * fs/cifs/smb2misc.c | |
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 | * | |
9 | * This library is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU Lesser General Public License as published | |
11 | * by the Free Software Foundation; either version 2.1 of the License, or | |
12 | * (at your option) any later version. | |
13 | * | |
14 | * This library is distributed in the hope that it will be useful, | |
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See | |
17 | * the GNU Lesser General Public License for more details. | |
18 | * | |
19 | * You should have received a copy of the GNU Lesser General Public License | |
20 | * along with this library; if not, write to the Free Software | |
21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
22 | */ | |
23 | #include <linux/ctype.h> | |
24 | #include "smb2pdu.h" | |
25 | #include "cifsglob.h" | |
26 | #include "cifsproto.h" | |
27 | #include "smb2proto.h" | |
28 | #include "cifs_debug.h" | |
29 | #include "cifs_unicode.h" | |
30 | #include "smb2status.h" | |
31473fc4 | 31 | #include "smb2glob.h" |
093b2bda PS |
32 | |
33 | static int | |
31473fc4 | 34 | check_smb2_hdr(struct smb2_sync_hdr *shdr, __u64 mid) |
093b2bda | 35 | { |
31473fc4 | 36 | __u64 wire_mid = le64_to_cpu(shdr->MessageId); |
9235d098 | 37 | |
093b2bda PS |
38 | /* |
39 | * Make sure that this really is an SMB, that it is a response, | |
40 | * and that the message ids match. | |
41 | */ | |
31473fc4 | 42 | if ((shdr->ProtocolId == SMB2_PROTO_NUMBER) && |
9235d098 | 43 | (mid == wire_mid)) { |
31473fc4 | 44 | if (shdr->Flags & SMB2_FLAGS_SERVER_TO_REDIR) |
093b2bda PS |
45 | return 0; |
46 | else { | |
47 | /* only one valid case where server sends us request */ | |
31473fc4 | 48 | if (shdr->Command == SMB2_OPLOCK_BREAK) |
093b2bda PS |
49 | return 0; |
50 | else | |
f96637be | 51 | cifs_dbg(VFS, "Received Request not response\n"); |
093b2bda PS |
52 | } |
53 | } else { /* bad signature or mid */ | |
31473fc4 | 54 | if (shdr->ProtocolId != SMB2_PROTO_NUMBER) |
f96637be | 55 | cifs_dbg(VFS, "Bad protocol string signature header %x\n", |
31473fc4 | 56 | le32_to_cpu(shdr->ProtocolId)); |
9235d098 | 57 | if (mid != wire_mid) |
f96637be | 58 | cifs_dbg(VFS, "Mids do not match: %llu and %llu\n", |
9235d098 | 59 | mid, wire_mid); |
093b2bda | 60 | } |
9235d098 | 61 | cifs_dbg(VFS, "Bad SMB detected. The Mid=%llu\n", wire_mid); |
093b2bda PS |
62 | return 1; |
63 | } | |
64 | ||
65 | /* | |
66 | * The following table defines the expected "StructureSize" of SMB2 responses | |
67 | * in order by SMB2 command. This is similar to "wct" in SMB/CIFS responses. | |
68 | * | |
69 | * Note that commands are defined in smb2pdu.h in le16 but the array below is | |
70 | * indexed by command in host byte order | |
71 | */ | |
72 | static const __le16 smb2_rsp_struct_sizes[NUMBER_OF_SMB2_COMMANDS] = { | |
bc09d141 FF |
73 | /* SMB2_NEGOTIATE */ cpu_to_le16(65), |
74 | /* SMB2_SESSION_SETUP */ cpu_to_le16(9), | |
75 | /* SMB2_LOGOFF */ cpu_to_le16(4), | |
76 | /* SMB2_TREE_CONNECT */ cpu_to_le16(16), | |
77 | /* SMB2_TREE_DISCONNECT */ cpu_to_le16(4), | |
78 | /* SMB2_CREATE */ cpu_to_le16(89), | |
79 | /* SMB2_CLOSE */ cpu_to_le16(60), | |
80 | /* SMB2_FLUSH */ cpu_to_le16(4), | |
81 | /* SMB2_READ */ cpu_to_le16(17), | |
82 | /* SMB2_WRITE */ cpu_to_le16(17), | |
83 | /* SMB2_LOCK */ cpu_to_le16(4), | |
84 | /* SMB2_IOCTL */ cpu_to_le16(49), | |
093b2bda | 85 | /* BB CHECK this ... not listed in documentation */ |
bc09d141 FF |
86 | /* SMB2_CANCEL */ cpu_to_le16(0), |
87 | /* SMB2_ECHO */ cpu_to_le16(4), | |
88 | /* SMB2_QUERY_DIRECTORY */ cpu_to_le16(9), | |
89 | /* SMB2_CHANGE_NOTIFY */ cpu_to_le16(9), | |
90 | /* SMB2_QUERY_INFO */ cpu_to_le16(9), | |
91 | /* SMB2_SET_INFO */ cpu_to_le16(2), | |
093b2bda | 92 | /* BB FIXME can also be 44 for lease break */ |
bc09d141 | 93 | /* SMB2_OPLOCK_BREAK */ cpu_to_le16(24) |
093b2bda PS |
94 | }; |
95 | ||
96 | int | |
373512ec | 97 | smb2_check_message(char *buf, unsigned int length, struct TCP_Server_Info *srvr) |
093b2bda | 98 | { |
31473fc4 PS |
99 | struct smb2_pdu *pdu = (struct smb2_pdu *)buf; |
100 | struct smb2_hdr *hdr = &pdu->hdr; | |
101 | struct smb2_sync_hdr *shdr = get_sync_hdr(buf); | |
373512ec | 102 | __u64 mid; |
093b2bda PS |
103 | __u32 len = get_rfc1002_length(buf); |
104 | __u32 clc_len; /* calculated length */ | |
105 | int command; | |
106 | ||
107 | /* BB disable following printk later */ | |
f96637be JP |
108 | cifs_dbg(FYI, "%s length: 0x%x, smb_buf_length: 0x%x\n", |
109 | __func__, length, len); | |
093b2bda PS |
110 | |
111 | /* | |
112 | * Add function to do table lookup of StructureSize by command | |
113 | * ie Validate the wct via smb2_struct_sizes table above | |
114 | */ | |
115 | ||
31473fc4 | 116 | if (shdr->ProtocolId == SMB2_TRANSFORM_PROTO_NUM) { |
373512ec SF |
117 | struct smb2_transform_hdr *thdr = |
118 | (struct smb2_transform_hdr *)buf; | |
119 | struct cifs_ses *ses = NULL; | |
120 | struct list_head *tmp; | |
121 | ||
122 | /* decrypt frame now that it is completely read in */ | |
123 | spin_lock(&cifs_tcp_ses_lock); | |
124 | list_for_each(tmp, &srvr->smb_ses_list) { | |
125 | ses = list_entry(tmp, struct cifs_ses, smb_ses_list); | |
126 | if (ses->Suid == thdr->SessionId) | |
127 | break; | |
128 | ||
129 | ses = NULL; | |
130 | } | |
131 | spin_unlock(&cifs_tcp_ses_lock); | |
132 | if (ses == NULL) { | |
133 | cifs_dbg(VFS, "no decryption - session id not found\n"); | |
134 | return 1; | |
135 | } | |
136 | } | |
137 | ||
31473fc4 | 138 | mid = le64_to_cpu(shdr->MessageId); |
74112860 | 139 | if (length < sizeof(struct smb2_pdu)) { |
31473fc4 PS |
140 | if ((length >= sizeof(struct smb2_hdr)) |
141 | && (shdr->Status != 0)) { | |
093b2bda PS |
142 | pdu->StructureSize2 = 0; |
143 | /* | |
144 | * As with SMB/CIFS, on some error cases servers may | |
145 | * not return wct properly | |
146 | */ | |
147 | return 0; | |
148 | } else { | |
f96637be | 149 | cifs_dbg(VFS, "Length less than SMB header size\n"); |
093b2bda PS |
150 | } |
151 | return 1; | |
152 | } | |
93012bf9 RS |
153 | if (len > CIFSMaxBufSize + MAX_SMB2_HDR_SIZE - |
154 | srvr->vals->header_preamble_size) { | |
f96637be JP |
155 | cifs_dbg(VFS, "SMB length greater than maximum, mid=%llu\n", |
156 | mid); | |
093b2bda PS |
157 | return 1; |
158 | } | |
159 | ||
31473fc4 | 160 | if (check_smb2_hdr(shdr, mid)) |
093b2bda PS |
161 | return 1; |
162 | ||
31473fc4 | 163 | if (shdr->StructureSize != SMB2_HEADER_STRUCTURE_SIZE) { |
f96637be | 164 | cifs_dbg(VFS, "Illegal structure size %u\n", |
31473fc4 | 165 | le16_to_cpu(shdr->StructureSize)); |
093b2bda PS |
166 | return 1; |
167 | } | |
168 | ||
31473fc4 | 169 | command = le16_to_cpu(shdr->Command); |
093b2bda | 170 | if (command >= NUMBER_OF_SMB2_COMMANDS) { |
f96637be | 171 | cifs_dbg(VFS, "Illegal SMB2 command %d\n", command); |
093b2bda PS |
172 | return 1; |
173 | } | |
174 | ||
175 | if (smb2_rsp_struct_sizes[command] != pdu->StructureSize2) { | |
31473fc4 | 176 | if (command != SMB2_OPLOCK_BREAK_HE && (shdr->Status == 0 || |
983c88a4 | 177 | pdu->StructureSize2 != SMB2_ERROR_STRUCTURE_SIZE2)) { |
093b2bda | 178 | /* error packets have 9 byte structure size */ |
f96637be JP |
179 | cifs_dbg(VFS, "Illegal response size %u for command %d\n", |
180 | le16_to_cpu(pdu->StructureSize2), command); | |
093b2bda | 181 | return 1; |
31473fc4 PS |
182 | } else if (command == SMB2_OPLOCK_BREAK_HE |
183 | && (shdr->Status == 0) | |
0822f514 PS |
184 | && (le16_to_cpu(pdu->StructureSize2) != 44) |
185 | && (le16_to_cpu(pdu->StructureSize2) != 36)) { | |
186 | /* special case for SMB2.1 lease break message */ | |
f96637be JP |
187 | cifs_dbg(VFS, "Illegal response size %d for oplock break\n", |
188 | le16_to_cpu(pdu->StructureSize2)); | |
0822f514 | 189 | return 1; |
093b2bda PS |
190 | } |
191 | } | |
192 | ||
93012bf9 | 193 | if (srvr->vals->header_preamble_size + len != length) { |
6c4ba311 | 194 | cifs_dbg(VFS, "Total length %u RFC1002 length %zu mismatch mid %llu\n", |
93012bf9 | 195 | length, srvr->vals->header_preamble_size + len, mid); |
093b2bda PS |
196 | return 1; |
197 | } | |
198 | ||
199 | clc_len = smb2_calc_size(hdr); | |
200 | ||
93012bf9 | 201 | if (srvr->vals->header_preamble_size + len != clc_len) { |
6c4ba311 | 202 | cifs_dbg(FYI, "Calculated size %u length %zu mismatch mid %llu\n", |
93012bf9 | 203 | clc_len, srvr->vals->header_preamble_size + len, mid); |
b42bf888 PS |
204 | /* create failed on symlink */ |
205 | if (command == SMB2_CREATE_HE && | |
31473fc4 | 206 | shdr->Status == STATUS_STOPPED_ON_SYMLINK) |
b42bf888 | 207 | return 0; |
983c88a4 | 208 | /* Windows 7 server returns 24 bytes more */ |
93012bf9 | 209 | if (clc_len + 24 - srvr->vals->header_preamble_size == len && command == SMB2_OPLOCK_BREAK_HE) |
983c88a4 | 210 | return 0; |
754789a1 | 211 | /* server can return one byte more due to implied bcc[0] */ |
93012bf9 | 212 | if (clc_len == srvr->vals->header_preamble_size + len + 1) |
74112860 | 213 | return 0; |
754789a1 SF |
214 | |
215 | /* | |
216 | * MacOS server pads after SMB2.1 write response with 3 bytes | |
217 | * of junk. Other servers match RFC1001 len to actual | |
218 | * SMB2/SMB3 frame length (header + smb2 response specific data) | |
219 | * Log the server error (once), but allow it and continue | |
220 | * since the frame is parseable. | |
221 | */ | |
93012bf9 | 222 | if (clc_len < srvr->vals->header_preamble_size /* RFC1001 header size */ + len) { |
754789a1 | 223 | printk_once(KERN_WARNING |
6c4ba311 | 224 | "SMB2 server sent bad RFC1001 len %d not %zu\n", |
93012bf9 | 225 | len, clc_len - srvr->vals->header_preamble_size); |
754789a1 SF |
226 | return 0; |
227 | } | |
228 | ||
093b2bda PS |
229 | return 1; |
230 | } | |
231 | return 0; | |
232 | } | |
233 | ||
234 | /* | |
235 | * The size of the variable area depends on the offset and length fields | |
236 | * located in different fields for various SMB2 responses. SMB2 responses | |
237 | * with no variable length info, show an offset of zero for the offset field. | |
238 | */ | |
239 | static const bool has_smb2_data_area[NUMBER_OF_SMB2_COMMANDS] = { | |
240 | /* SMB2_NEGOTIATE */ true, | |
241 | /* SMB2_SESSION_SETUP */ true, | |
242 | /* SMB2_LOGOFF */ false, | |
243 | /* SMB2_TREE_CONNECT */ false, | |
244 | /* SMB2_TREE_DISCONNECT */ false, | |
245 | /* SMB2_CREATE */ true, | |
246 | /* SMB2_CLOSE */ false, | |
247 | /* SMB2_FLUSH */ false, | |
248 | /* SMB2_READ */ true, | |
249 | /* SMB2_WRITE */ false, | |
250 | /* SMB2_LOCK */ false, | |
251 | /* SMB2_IOCTL */ true, | |
252 | /* SMB2_CANCEL */ false, /* BB CHECK this not listed in documentation */ | |
253 | /* SMB2_ECHO */ false, | |
254 | /* SMB2_QUERY_DIRECTORY */ true, | |
255 | /* SMB2_CHANGE_NOTIFY */ true, | |
256 | /* SMB2_QUERY_INFO */ true, | |
257 | /* SMB2_SET_INFO */ false, | |
258 | /* SMB2_OPLOCK_BREAK */ false | |
259 | }; | |
260 | ||
261 | /* | |
262 | * Returns the pointer to the beginning of the data area. Length of the data | |
263 | * area and the offset to it (from the beginning of the smb are also returned. | |
264 | */ | |
ec2e4523 | 265 | char * |
093b2bda PS |
266 | smb2_get_data_area_len(int *off, int *len, struct smb2_hdr *hdr) |
267 | { | |
31473fc4 | 268 | struct smb2_sync_hdr *shdr = get_sync_hdr(hdr); |
093b2bda PS |
269 | *off = 0; |
270 | *len = 0; | |
271 | ||
272 | /* error responses do not have data area */ | |
31473fc4 | 273 | if (shdr->Status && shdr->Status != STATUS_MORE_PROCESSING_REQUIRED && |
093b2bda PS |
274 | (((struct smb2_err_rsp *)hdr)->StructureSize) == |
275 | SMB2_ERROR_STRUCTURE_SIZE2) | |
276 | return NULL; | |
277 | ||
278 | /* | |
279 | * Following commands have data areas so we have to get the location | |
280 | * of the data buffer offset and data buffer length for the particular | |
281 | * command. | |
282 | */ | |
31473fc4 | 283 | switch (shdr->Command) { |
093b2bda | 284 | case SMB2_NEGOTIATE: |
ec2e4523 PS |
285 | *off = le16_to_cpu( |
286 | ((struct smb2_negotiate_rsp *)hdr)->SecurityBufferOffset); | |
287 | *len = le16_to_cpu( | |
288 | ((struct smb2_negotiate_rsp *)hdr)->SecurityBufferLength); | |
289 | break; | |
093b2bda | 290 | case SMB2_SESSION_SETUP: |
5478f9ba PS |
291 | *off = le16_to_cpu( |
292 | ((struct smb2_sess_setup_rsp *)hdr)->SecurityBufferOffset); | |
293 | *len = le16_to_cpu( | |
294 | ((struct smb2_sess_setup_rsp *)hdr)->SecurityBufferLength); | |
295 | break; | |
093b2bda | 296 | case SMB2_CREATE: |
2503a0db PS |
297 | *off = le32_to_cpu( |
298 | ((struct smb2_create_rsp *)hdr)->CreateContextsOffset); | |
299 | *len = le32_to_cpu( | |
300 | ((struct smb2_create_rsp *)hdr)->CreateContextsLength); | |
301 | break; | |
093b2bda | 302 | case SMB2_QUERY_INFO: |
be4cb9e3 PS |
303 | *off = le16_to_cpu( |
304 | ((struct smb2_query_info_rsp *)hdr)->OutputBufferOffset); | |
305 | *len = le32_to_cpu( | |
306 | ((struct smb2_query_info_rsp *)hdr)->OutputBufferLength); | |
307 | break; | |
308 | case SMB2_READ: | |
09a4707e PS |
309 | *off = ((struct smb2_read_rsp *)hdr)->DataOffset; |
310 | *len = le32_to_cpu(((struct smb2_read_rsp *)hdr)->DataLength); | |
311 | break; | |
093b2bda | 312 | case SMB2_QUERY_DIRECTORY: |
d324f08d PS |
313 | *off = le16_to_cpu( |
314 | ((struct smb2_query_directory_rsp *)hdr)->OutputBufferOffset); | |
315 | *len = le32_to_cpu( | |
316 | ((struct smb2_query_directory_rsp *)hdr)->OutputBufferLength); | |
317 | break; | |
093b2bda | 318 | case SMB2_IOCTL: |
4a72dafa SF |
319 | *off = le32_to_cpu( |
320 | ((struct smb2_ioctl_rsp *)hdr)->OutputOffset); | |
321 | *len = le32_to_cpu(((struct smb2_ioctl_rsp *)hdr)->OutputCount); | |
322 | break; | |
093b2bda PS |
323 | case SMB2_CHANGE_NOTIFY: |
324 | default: | |
325 | /* BB FIXME for unimplemented cases above */ | |
f96637be | 326 | cifs_dbg(VFS, "no length check for command\n"); |
093b2bda PS |
327 | break; |
328 | } | |
329 | ||
330 | /* | |
331 | * Invalid length or offset probably means data area is invalid, but | |
332 | * we have little choice but to ignore the data area in this case. | |
333 | */ | |
334 | if (*off > 4096) { | |
f96637be | 335 | cifs_dbg(VFS, "offset %d too large, data area ignored\n", *off); |
093b2bda PS |
336 | *len = 0; |
337 | *off = 0; | |
338 | } else if (*off < 0) { | |
f96637be JP |
339 | cifs_dbg(VFS, "negative offset %d to data invalid ignore data area\n", |
340 | *off); | |
093b2bda PS |
341 | *off = 0; |
342 | *len = 0; | |
343 | } else if (*len < 0) { | |
f96637be JP |
344 | cifs_dbg(VFS, "negative data length %d invalid, data area ignored\n", |
345 | *len); | |
093b2bda PS |
346 | *len = 0; |
347 | } else if (*len > 128 * 1024) { | |
f96637be | 348 | cifs_dbg(VFS, "data area larger than 128K: %d\n", *len); |
093b2bda PS |
349 | *len = 0; |
350 | } | |
351 | ||
352 | /* return pointer to beginning of data area, ie offset from SMB start */ | |
353 | if ((*off != 0) && (*len != 0)) | |
31473fc4 | 354 | return (char *)shdr + *off; |
093b2bda PS |
355 | else |
356 | return NULL; | |
357 | } | |
358 | ||
359 | /* | |
360 | * Calculate the size of the SMB message based on the fixed header | |
361 | * portion, the number of word parameters and the data portion of the message. | |
362 | */ | |
363 | unsigned int | |
d324f08d | 364 | smb2_calc_size(void *buf) |
093b2bda | 365 | { |
31473fc4 PS |
366 | struct smb2_pdu *pdu = (struct smb2_pdu *)buf; |
367 | struct smb2_hdr *hdr = &pdu->hdr; | |
368 | struct smb2_sync_hdr *shdr = get_sync_hdr(hdr); | |
093b2bda PS |
369 | int offset; /* the offset from the beginning of SMB to data area */ |
370 | int data_length; /* the length of the variable length data area */ | |
371 | /* Structure Size has already been checked to make sure it is 64 */ | |
31473fc4 | 372 | int len = 4 + le16_to_cpu(shdr->StructureSize); |
093b2bda PS |
373 | |
374 | /* | |
375 | * StructureSize2, ie length of fixed parameter area has already | |
376 | * been checked to make sure it is the correct length. | |
377 | */ | |
378 | len += le16_to_cpu(pdu->StructureSize2); | |
379 | ||
31473fc4 | 380 | if (has_smb2_data_area[le16_to_cpu(shdr->Command)] == false) |
093b2bda PS |
381 | goto calc_size_exit; |
382 | ||
383 | smb2_get_data_area_len(&offset, &data_length, hdr); | |
f96637be | 384 | cifs_dbg(FYI, "SMB2 data length %d offset %d\n", data_length, offset); |
093b2bda PS |
385 | |
386 | if (data_length > 0) { | |
387 | /* | |
388 | * Check to make sure that data area begins after fixed area, | |
389 | * Note that last byte of the fixed area is part of data area | |
390 | * for some commands, typically those with odd StructureSize, | |
391 | * so we must add one to the calculation (and 4 to account for | |
392 | * the size of the RFC1001 hdr. | |
393 | */ | |
394 | if (offset + 4 + 1 < len) { | |
f96637be JP |
395 | cifs_dbg(VFS, "data area offset %d overlaps SMB2 header %d\n", |
396 | offset + 4 + 1, len); | |
093b2bda PS |
397 | data_length = 0; |
398 | } else { | |
399 | len = 4 + offset + data_length; | |
400 | } | |
401 | } | |
402 | calc_size_exit: | |
f96637be | 403 | cifs_dbg(FYI, "SMB2 len %d\n", len); |
093b2bda PS |
404 | return len; |
405 | } | |
2503a0db PS |
406 | |
407 | /* Note: caller must free return buffer */ | |
408 | __le16 * | |
409 | cifs_convert_path_to_utf16(const char *from, struct cifs_sb_info *cifs_sb) | |
410 | { | |
411 | int len; | |
412 | const char *start_of_path; | |
413 | __le16 *to; | |
a4153cb1 SF |
414 | int map_type; |
415 | ||
416 | if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR) | |
417 | map_type = SFM_MAP_UNI_RSVD; | |
418 | else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR) | |
419 | map_type = SFU_MAP_UNI_RSVD; | |
420 | else | |
421 | map_type = NO_MAP_UNI_RSVD; | |
2503a0db PS |
422 | |
423 | /* Windows doesn't allow paths beginning with \ */ | |
424 | if (from[0] == '\\') | |
425 | start_of_path = from + 1; | |
426 | else | |
427 | start_of_path = from; | |
428 | to = cifs_strndup_to_utf16(start_of_path, PATH_MAX, &len, | |
a4153cb1 | 429 | cifs_sb->local_nls, map_type); |
2503a0db PS |
430 | return to; |
431 | } | |
983c88a4 | 432 | |
0822f514 PS |
433 | __le32 |
434 | smb2_get_lease_state(struct cifsInodeInfo *cinode) | |
435 | { | |
53ef1016 | 436 | __le32 lease = 0; |
0822f514 | 437 | |
53ef1016 PS |
438 | if (CIFS_CACHE_WRITE(cinode)) |
439 | lease |= SMB2_LEASE_WRITE_CACHING; | |
440 | if (CIFS_CACHE_HANDLE(cinode)) | |
441 | lease |= SMB2_LEASE_HANDLE_CACHING; | |
442 | if (CIFS_CACHE_READ(cinode)) | |
443 | lease |= SMB2_LEASE_READ_CACHING; | |
444 | return lease; | |
0822f514 PS |
445 | } |
446 | ||
233839b1 PS |
447 | struct smb2_lease_break_work { |
448 | struct work_struct lease_break; | |
449 | struct tcon_link *tlink; | |
450 | __u8 lease_key[16]; | |
451 | __le32 lease_state; | |
452 | }; | |
453 | ||
454 | static void | |
455 | cifs_ses_oplock_break(struct work_struct *work) | |
456 | { | |
457 | struct smb2_lease_break_work *lw = container_of(work, | |
458 | struct smb2_lease_break_work, lease_break); | |
459 | int rc; | |
460 | ||
461 | rc = SMB2_lease_break(0, tlink_tcon(lw->tlink), lw->lease_key, | |
462 | lw->lease_state); | |
f96637be | 463 | cifs_dbg(FYI, "Lease release rc %d\n", rc); |
233839b1 PS |
464 | cifs_put_tlink(lw->tlink); |
465 | kfree(lw); | |
466 | } | |
467 | ||
0822f514 | 468 | static bool |
933d4b36 PS |
469 | smb2_tcon_has_lease(struct cifs_tcon *tcon, struct smb2_lease_break *rsp, |
470 | struct smb2_lease_break_work *lw) | |
471 | { | |
472 | bool found; | |
473 | __u8 lease_state; | |
474 | struct list_head *tmp; | |
475 | struct cifsFileInfo *cfile; | |
42873b0a | 476 | struct TCP_Server_Info *server = tcon->ses->server; |
933d4b36 PS |
477 | struct cifs_pending_open *open; |
478 | struct cifsInodeInfo *cinode; | |
479 | int ack_req = le32_to_cpu(rsp->Flags & | |
480 | SMB2_NOTIFY_BREAK_LEASE_FLAG_ACK_REQUIRED); | |
481 | ||
53ef1016 | 482 | lease_state = le32_to_cpu(rsp->NewLeaseState); |
933d4b36 PS |
483 | |
484 | list_for_each(tmp, &tcon->openFileList) { | |
485 | cfile = list_entry(tmp, struct cifsFileInfo, tlist); | |
2b0143b5 | 486 | cinode = CIFS_I(d_inode(cfile->dentry)); |
933d4b36 PS |
487 | |
488 | if (memcmp(cinode->lease_key, rsp->LeaseKey, | |
489 | SMB2_LEASE_KEY_SIZE)) | |
490 | continue; | |
491 | ||
492 | cifs_dbg(FYI, "found in the open list\n"); | |
59b04c5d | 493 | cifs_dbg(FYI, "lease key match, lease break 0x%x\n", |
933d4b36 PS |
494 | le32_to_cpu(rsp->NewLeaseState)); |
495 | ||
42873b0a | 496 | server->ops->set_oplock_level(cinode, lease_state, 0, NULL); |
933d4b36 PS |
497 | |
498 | if (ack_req) | |
499 | cfile->oplock_break_cancelled = false; | |
500 | else | |
501 | cfile->oplock_break_cancelled = true; | |
502 | ||
3998e6b8 | 503 | queue_work(cifsoplockd_wq, &cfile->oplock_break); |
933d4b36 PS |
504 | kfree(lw); |
505 | return true; | |
506 | } | |
507 | ||
508 | found = false; | |
509 | list_for_each_entry(open, &tcon->pending_opens, olist) { | |
510 | if (memcmp(open->lease_key, rsp->LeaseKey, | |
511 | SMB2_LEASE_KEY_SIZE)) | |
512 | continue; | |
513 | ||
514 | if (!found && ack_req) { | |
515 | found = true; | |
516 | memcpy(lw->lease_key, open->lease_key, | |
517 | SMB2_LEASE_KEY_SIZE); | |
518 | lw->tlink = cifs_get_tlink(open->tlink); | |
519 | queue_work(cifsiod_wq, &lw->lease_break); | |
520 | } | |
521 | ||
522 | cifs_dbg(FYI, "found in the pending open list\n"); | |
59b04c5d | 523 | cifs_dbg(FYI, "lease key match, lease break 0x%x\n", |
933d4b36 PS |
524 | le32_to_cpu(rsp->NewLeaseState)); |
525 | ||
526 | open->oplock = lease_state; | |
527 | } | |
528 | return found; | |
529 | } | |
530 | ||
531 | static bool | |
532 | smb2_is_valid_lease_break(char *buffer) | |
0822f514 PS |
533 | { |
534 | struct smb2_lease_break *rsp = (struct smb2_lease_break *)buffer; | |
535 | struct list_head *tmp, *tmp1, *tmp2; | |
933d4b36 | 536 | struct TCP_Server_Info *server; |
0822f514 PS |
537 | struct cifs_ses *ses; |
538 | struct cifs_tcon *tcon; | |
233839b1 | 539 | struct smb2_lease_break_work *lw; |
233839b1 PS |
540 | |
541 | lw = kmalloc(sizeof(struct smb2_lease_break_work), GFP_KERNEL); | |
f96637be | 542 | if (!lw) |
233839b1 | 543 | return false; |
233839b1 PS |
544 | |
545 | INIT_WORK(&lw->lease_break, cifs_ses_oplock_break); | |
546 | lw->lease_state = rsp->NewLeaseState; | |
0822f514 | 547 | |
f96637be | 548 | cifs_dbg(FYI, "Checking for lease break\n"); |
0822f514 PS |
549 | |
550 | /* look up tcon based on tid & uid */ | |
551 | spin_lock(&cifs_tcp_ses_lock); | |
933d4b36 PS |
552 | list_for_each(tmp, &cifs_tcp_ses_list) { |
553 | server = list_entry(tmp, struct TCP_Server_Info, tcp_ses_list); | |
0822f514 | 554 | |
933d4b36 PS |
555 | list_for_each(tmp1, &server->smb_ses_list) { |
556 | ses = list_entry(tmp1, struct cifs_ses, smb_ses_list); | |
0822f514 | 557 | |
933d4b36 PS |
558 | list_for_each(tmp2, &ses->tcon_list) { |
559 | tcon = list_entry(tmp2, struct cifs_tcon, | |
560 | tcon_list); | |
3afca265 | 561 | spin_lock(&tcon->open_file_lock); |
933d4b36 PS |
562 | cifs_stats_inc( |
563 | &tcon->stats.cifs_stats.num_oplock_brks); | |
564 | if (smb2_tcon_has_lease(tcon, rsp, lw)) { | |
3afca265 | 565 | spin_unlock(&tcon->open_file_lock); |
933d4b36 PS |
566 | spin_unlock(&cifs_tcp_ses_lock); |
567 | return true; | |
233839b1 | 568 | } |
3afca265 | 569 | spin_unlock(&tcon->open_file_lock); |
233839b1 | 570 | } |
0822f514 PS |
571 | } |
572 | } | |
573 | spin_unlock(&cifs_tcp_ses_lock); | |
233839b1 | 574 | kfree(lw); |
f96637be | 575 | cifs_dbg(FYI, "Can not process lease break - no lease matched\n"); |
0822f514 PS |
576 | return false; |
577 | } | |
578 | ||
983c88a4 PS |
579 | bool |
580 | smb2_is_valid_oplock_break(char *buffer, struct TCP_Server_Info *server) | |
581 | { | |
21ad9487 | 582 | struct smb2_oplock_break_rsp *rsp = (struct smb2_oplock_break_rsp *)buffer; |
983c88a4 PS |
583 | struct list_head *tmp, *tmp1, *tmp2; |
584 | struct cifs_ses *ses; | |
585 | struct cifs_tcon *tcon; | |
586 | struct cifsInodeInfo *cinode; | |
587 | struct cifsFileInfo *cfile; | |
588 | ||
f96637be | 589 | cifs_dbg(FYI, "Checking for oplock break\n"); |
983c88a4 | 590 | |
31473fc4 | 591 | if (rsp->hdr.sync_hdr.Command != SMB2_OPLOCK_BREAK) |
983c88a4 PS |
592 | return false; |
593 | ||
12e8a208 | 594 | if (rsp->StructureSize != |
983c88a4 | 595 | smb2_rsp_struct_sizes[SMB2_OPLOCK_BREAK_HE]) { |
0822f514 | 596 | if (le16_to_cpu(rsp->StructureSize) == 44) |
933d4b36 | 597 | return smb2_is_valid_lease_break(buffer); |
0822f514 PS |
598 | else |
599 | return false; | |
983c88a4 PS |
600 | } |
601 | ||
59b04c5d | 602 | cifs_dbg(FYI, "oplock level 0x%x\n", rsp->OplockLevel); |
983c88a4 PS |
603 | |
604 | /* look up tcon based on tid & uid */ | |
605 | spin_lock(&cifs_tcp_ses_lock); | |
606 | list_for_each(tmp, &server->smb_ses_list) { | |
607 | ses = list_entry(tmp, struct cifs_ses, smb_ses_list); | |
608 | list_for_each(tmp1, &ses->tcon_list) { | |
609 | tcon = list_entry(tmp1, struct cifs_tcon, tcon_list); | |
610 | ||
611 | cifs_stats_inc(&tcon->stats.cifs_stats.num_oplock_brks); | |
3afca265 | 612 | spin_lock(&tcon->open_file_lock); |
983c88a4 PS |
613 | list_for_each(tmp2, &tcon->openFileList) { |
614 | cfile = list_entry(tmp2, struct cifsFileInfo, | |
615 | tlist); | |
616 | if (rsp->PersistentFid != | |
617 | cfile->fid.persistent_fid || | |
618 | rsp->VolatileFid != | |
619 | cfile->fid.volatile_fid) | |
620 | continue; | |
621 | ||
f96637be | 622 | cifs_dbg(FYI, "file id match, oplock break\n"); |
2b0143b5 | 623 | cinode = CIFS_I(d_inode(cfile->dentry)); |
3afca265 | 624 | spin_lock(&cfile->file_info_lock); |
18cceb6a | 625 | if (!CIFS_CACHE_WRITE(cinode) && |
983c88a4 PS |
626 | rsp->OplockLevel == SMB2_OPLOCK_LEVEL_NONE) |
627 | cfile->oplock_break_cancelled = true; | |
628 | else | |
629 | cfile->oplock_break_cancelled = false; | |
630 | ||
c11f1df5 SP |
631 | set_bit(CIFS_INODE_PENDING_OPLOCK_BREAK, |
632 | &cinode->flags); | |
633 | ||
634 | /* | |
635 | * Set flag if the server downgrades the oplock | |
636 | * to L2 else clear. | |
637 | */ | |
638 | if (rsp->OplockLevel) | |
639 | set_bit( | |
640 | CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2, | |
641 | &cinode->flags); | |
642 | else | |
643 | clear_bit( | |
644 | CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2, | |
645 | &cinode->flags); | |
3afca265 | 646 | spin_unlock(&cfile->file_info_lock); |
3998e6b8 RV |
647 | queue_work(cifsoplockd_wq, |
648 | &cfile->oplock_break); | |
983c88a4 | 649 | |
3afca265 | 650 | spin_unlock(&tcon->open_file_lock); |
983c88a4 PS |
651 | spin_unlock(&cifs_tcp_ses_lock); |
652 | return true; | |
653 | } | |
3afca265 | 654 | spin_unlock(&tcon->open_file_lock); |
983c88a4 | 655 | spin_unlock(&cifs_tcp_ses_lock); |
f96637be | 656 | cifs_dbg(FYI, "No matching file for oplock break\n"); |
983c88a4 PS |
657 | return true; |
658 | } | |
659 | } | |
660 | spin_unlock(&cifs_tcp_ses_lock); | |
f96637be | 661 | cifs_dbg(FYI, "Can not process oplock break for non-existent connection\n"); |
983c88a4 PS |
662 | return false; |
663 | } | |
38bd4906 SP |
664 | |
665 | void | |
666 | smb2_cancelled_close_fid(struct work_struct *work) | |
667 | { | |
668 | struct close_cancelled_open *cancelled = container_of(work, | |
669 | struct close_cancelled_open, work); | |
670 | ||
671 | cifs_dbg(VFS, "Close unmatched open\n"); | |
672 | ||
673 | SMB2_close(0, cancelled->tcon, cancelled->fid.persistent_fid, | |
674 | cancelled->fid.volatile_fid); | |
675 | cifs_put_tcon(cancelled->tcon); | |
676 | kfree(cancelled); | |
677 | } | |
678 | ||
679 | int | |
680 | smb2_handle_cancelled_mid(char *buffer, struct TCP_Server_Info *server) | |
681 | { | |
682 | struct smb2_sync_hdr *sync_hdr = get_sync_hdr(buffer); | |
683 | struct smb2_create_rsp *rsp = (struct smb2_create_rsp *)buffer; | |
684 | struct cifs_tcon *tcon; | |
685 | struct close_cancelled_open *cancelled; | |
686 | ||
687 | if (sync_hdr->Command != SMB2_CREATE || | |
688 | sync_hdr->Status != STATUS_SUCCESS) | |
689 | return 0; | |
690 | ||
691 | cancelled = kzalloc(sizeof(*cancelled), GFP_KERNEL); | |
692 | if (!cancelled) | |
693 | return -ENOMEM; | |
694 | ||
695 | tcon = smb2_find_smb_tcon(server, sync_hdr->SessionId, | |
696 | sync_hdr->TreeId); | |
697 | if (!tcon) { | |
698 | kfree(cancelled); | |
699 | return -ENOENT; | |
700 | } | |
701 | ||
702 | cancelled->fid.persistent_fid = rsp->PersistentFileId; | |
703 | cancelled->fid.volatile_fid = rsp->VolatileFileId; | |
704 | cancelled->tcon = tcon; | |
705 | INIT_WORK(&cancelled->work, smb2_cancelled_close_fid); | |
706 | queue_work(cifsiod_wq, &cancelled->work); | |
707 | ||
708 | return 0; | |
709 | } | |
8bd68c6e AA |
710 | |
711 | #ifdef CONFIG_CIFS_SMB311 | |
712 | /** | |
713 | * smb311_update_preauth_hash - update @ses hash with the packet data in @iov | |
714 | * | |
715 | * Assumes @iov does not contain the rfc1002 length and iov[0] has the | |
716 | * SMB2 header. | |
717 | */ | |
718 | int | |
719 | smb311_update_preauth_hash(struct cifs_ses *ses, struct kvec *iov, int nvec) | |
720 | { | |
721 | int i, rc; | |
722 | struct sdesc *d; | |
723 | struct smb2_sync_hdr *hdr; | |
724 | ||
725 | if (ses->server->tcpStatus == CifsGood) { | |
726 | /* skip non smb311 connections */ | |
727 | if (ses->server->dialect != SMB311_PROT_ID) | |
728 | return 0; | |
729 | ||
730 | /* skip last sess setup response */ | |
731 | hdr = (struct smb2_sync_hdr *)iov[0].iov_base; | |
732 | if (hdr->Flags & SMB2_FLAGS_SIGNED) | |
733 | return 0; | |
734 | } | |
735 | ||
736 | rc = smb311_crypto_shash_allocate(ses->server); | |
737 | if (rc) | |
738 | return rc; | |
739 | ||
740 | d = ses->server->secmech.sdescsha512; | |
741 | rc = crypto_shash_init(&d->shash); | |
742 | if (rc) { | |
743 | cifs_dbg(VFS, "%s: could not init sha512 shash\n", __func__); | |
744 | return rc; | |
745 | } | |
746 | ||
747 | rc = crypto_shash_update(&d->shash, ses->preauth_sha_hash, | |
748 | SMB2_PREAUTH_HASH_SIZE); | |
749 | if (rc) { | |
750 | cifs_dbg(VFS, "%s: could not update sha512 shash\n", __func__); | |
751 | return rc; | |
752 | } | |
753 | ||
754 | for (i = 0; i < nvec; i++) { | |
755 | rc = crypto_shash_update(&d->shash, | |
756 | iov[i].iov_base, iov[i].iov_len); | |
757 | if (rc) { | |
758 | cifs_dbg(VFS, "%s: could not update sha512 shash\n", | |
759 | __func__); | |
760 | return rc; | |
761 | } | |
762 | } | |
763 | ||
764 | rc = crypto_shash_final(&d->shash, ses->preauth_sha_hash); | |
765 | if (rc) { | |
766 | cifs_dbg(VFS, "%s: could not finalize sha512 shash\n", | |
767 | __func__); | |
768 | return rc; | |
769 | } | |
770 | ||
771 | return 0; | |
772 | } | |
773 | #endif |