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" | |
31 | ||
32 | static int | |
33 | check_smb2_hdr(struct smb2_hdr *hdr, __u64 mid) | |
34 | { | |
35 | /* | |
36 | * Make sure that this really is an SMB, that it is a response, | |
37 | * and that the message ids match. | |
38 | */ | |
39 | if ((*(__le32 *)hdr->ProtocolId == SMB2_PROTO_NUMBER) && | |
40 | (mid == hdr->MessageId)) { | |
41 | if (hdr->Flags & SMB2_FLAGS_SERVER_TO_REDIR) | |
42 | return 0; | |
43 | else { | |
44 | /* only one valid case where server sends us request */ | |
45 | if (hdr->Command == SMB2_OPLOCK_BREAK) | |
46 | return 0; | |
47 | else | |
f96637be | 48 | cifs_dbg(VFS, "Received Request not response\n"); |
093b2bda PS |
49 | } |
50 | } else { /* bad signature or mid */ | |
51 | if (*(__le32 *)hdr->ProtocolId != SMB2_PROTO_NUMBER) | |
f96637be JP |
52 | cifs_dbg(VFS, "Bad protocol string signature header %x\n", |
53 | *(unsigned int *) hdr->ProtocolId); | |
093b2bda | 54 | if (mid != hdr->MessageId) |
f96637be JP |
55 | cifs_dbg(VFS, "Mids do not match: %llu and %llu\n", |
56 | mid, hdr->MessageId); | |
093b2bda | 57 | } |
f96637be | 58 | cifs_dbg(VFS, "Bad SMB detected. The Mid=%llu\n", hdr->MessageId); |
093b2bda PS |
59 | return 1; |
60 | } | |
61 | ||
62 | /* | |
63 | * The following table defines the expected "StructureSize" of SMB2 responses | |
64 | * in order by SMB2 command. This is similar to "wct" in SMB/CIFS responses. | |
65 | * | |
66 | * Note that commands are defined in smb2pdu.h in le16 but the array below is | |
67 | * indexed by command in host byte order | |
68 | */ | |
69 | static const __le16 smb2_rsp_struct_sizes[NUMBER_OF_SMB2_COMMANDS] = { | |
70 | /* SMB2_NEGOTIATE */ __constant_cpu_to_le16(65), | |
71 | /* SMB2_SESSION_SETUP */ __constant_cpu_to_le16(9), | |
72 | /* SMB2_LOGOFF */ __constant_cpu_to_le16(4), | |
73 | /* SMB2_TREE_CONNECT */ __constant_cpu_to_le16(16), | |
74 | /* SMB2_TREE_DISCONNECT */ __constant_cpu_to_le16(4), | |
75 | /* SMB2_CREATE */ __constant_cpu_to_le16(89), | |
76 | /* SMB2_CLOSE */ __constant_cpu_to_le16(60), | |
77 | /* SMB2_FLUSH */ __constant_cpu_to_le16(4), | |
78 | /* SMB2_READ */ __constant_cpu_to_le16(17), | |
79 | /* SMB2_WRITE */ __constant_cpu_to_le16(17), | |
80 | /* SMB2_LOCK */ __constant_cpu_to_le16(4), | |
81 | /* SMB2_IOCTL */ __constant_cpu_to_le16(49), | |
82 | /* BB CHECK this ... not listed in documentation */ | |
83 | /* SMB2_CANCEL */ __constant_cpu_to_le16(0), | |
84 | /* SMB2_ECHO */ __constant_cpu_to_le16(4), | |
85 | /* SMB2_QUERY_DIRECTORY */ __constant_cpu_to_le16(9), | |
86 | /* SMB2_CHANGE_NOTIFY */ __constant_cpu_to_le16(9), | |
87 | /* SMB2_QUERY_INFO */ __constant_cpu_to_le16(9), | |
88 | /* SMB2_SET_INFO */ __constant_cpu_to_le16(2), | |
89 | /* BB FIXME can also be 44 for lease break */ | |
90 | /* SMB2_OPLOCK_BREAK */ __constant_cpu_to_le16(24) | |
91 | }; | |
92 | ||
93 | int | |
94 | smb2_check_message(char *buf, unsigned int length) | |
95 | { | |
96 | struct smb2_hdr *hdr = (struct smb2_hdr *)buf; | |
97 | struct smb2_pdu *pdu = (struct smb2_pdu *)hdr; | |
98 | __u64 mid = hdr->MessageId; | |
99 | __u32 len = get_rfc1002_length(buf); | |
100 | __u32 clc_len; /* calculated length */ | |
101 | int command; | |
102 | ||
103 | /* BB disable following printk later */ | |
f96637be JP |
104 | cifs_dbg(FYI, "%s length: 0x%x, smb_buf_length: 0x%x\n", |
105 | __func__, length, len); | |
093b2bda PS |
106 | |
107 | /* | |
108 | * Add function to do table lookup of StructureSize by command | |
109 | * ie Validate the wct via smb2_struct_sizes table above | |
110 | */ | |
111 | ||
74112860 | 112 | if (length < sizeof(struct smb2_pdu)) { |
093b2bda PS |
113 | if ((length >= sizeof(struct smb2_hdr)) && (hdr->Status != 0)) { |
114 | pdu->StructureSize2 = 0; | |
115 | /* | |
116 | * As with SMB/CIFS, on some error cases servers may | |
117 | * not return wct properly | |
118 | */ | |
119 | return 0; | |
120 | } else { | |
f96637be | 121 | cifs_dbg(VFS, "Length less than SMB header size\n"); |
093b2bda PS |
122 | } |
123 | return 1; | |
124 | } | |
125 | if (len > CIFSMaxBufSize + MAX_SMB2_HDR_SIZE - 4) { | |
f96637be JP |
126 | cifs_dbg(VFS, "SMB length greater than maximum, mid=%llu\n", |
127 | mid); | |
093b2bda PS |
128 | return 1; |
129 | } | |
130 | ||
131 | if (check_smb2_hdr(hdr, mid)) | |
132 | return 1; | |
133 | ||
74112860 | 134 | if (hdr->StructureSize != SMB2_HEADER_STRUCTURE_SIZE) { |
f96637be JP |
135 | cifs_dbg(VFS, "Illegal structure size %u\n", |
136 | le16_to_cpu(hdr->StructureSize)); | |
093b2bda PS |
137 | return 1; |
138 | } | |
139 | ||
140 | command = le16_to_cpu(hdr->Command); | |
141 | if (command >= NUMBER_OF_SMB2_COMMANDS) { | |
f96637be | 142 | cifs_dbg(VFS, "Illegal SMB2 command %d\n", command); |
093b2bda PS |
143 | return 1; |
144 | } | |
145 | ||
146 | if (smb2_rsp_struct_sizes[command] != pdu->StructureSize2) { | |
983c88a4 PS |
147 | if (command != SMB2_OPLOCK_BREAK_HE && (hdr->Status == 0 || |
148 | pdu->StructureSize2 != SMB2_ERROR_STRUCTURE_SIZE2)) { | |
093b2bda | 149 | /* error packets have 9 byte structure size */ |
f96637be JP |
150 | cifs_dbg(VFS, "Illegal response size %u for command %d\n", |
151 | le16_to_cpu(pdu->StructureSize2), command); | |
093b2bda | 152 | return 1; |
0822f514 PS |
153 | } else if (command == SMB2_OPLOCK_BREAK_HE && (hdr->Status == 0) |
154 | && (le16_to_cpu(pdu->StructureSize2) != 44) | |
155 | && (le16_to_cpu(pdu->StructureSize2) != 36)) { | |
156 | /* special case for SMB2.1 lease break message */ | |
f96637be JP |
157 | cifs_dbg(VFS, "Illegal response size %d for oplock break\n", |
158 | le16_to_cpu(pdu->StructureSize2)); | |
0822f514 | 159 | return 1; |
093b2bda PS |
160 | } |
161 | } | |
162 | ||
163 | if (4 + len != length) { | |
f96637be JP |
164 | cifs_dbg(VFS, "Total length %u RFC1002 length %u mismatch mid %llu\n", |
165 | length, 4 + len, mid); | |
093b2bda PS |
166 | return 1; |
167 | } | |
168 | ||
169 | clc_len = smb2_calc_size(hdr); | |
170 | ||
171 | if (4 + len != clc_len) { | |
f96637be JP |
172 | cifs_dbg(FYI, "Calculated size %u length %u mismatch mid %llu\n", |
173 | clc_len, 4 + len, mid); | |
983c88a4 PS |
174 | /* Windows 7 server returns 24 bytes more */ |
175 | if (clc_len + 20 == len && command == SMB2_OPLOCK_BREAK_HE) | |
176 | return 0; | |
74112860 PS |
177 | /* server can return one byte more */ |
178 | if (clc_len == 4 + len + 1) | |
179 | return 0; | |
093b2bda PS |
180 | return 1; |
181 | } | |
182 | return 0; | |
183 | } | |
184 | ||
185 | /* | |
186 | * The size of the variable area depends on the offset and length fields | |
187 | * located in different fields for various SMB2 responses. SMB2 responses | |
188 | * with no variable length info, show an offset of zero for the offset field. | |
189 | */ | |
190 | static const bool has_smb2_data_area[NUMBER_OF_SMB2_COMMANDS] = { | |
191 | /* SMB2_NEGOTIATE */ true, | |
192 | /* SMB2_SESSION_SETUP */ true, | |
193 | /* SMB2_LOGOFF */ false, | |
194 | /* SMB2_TREE_CONNECT */ false, | |
195 | /* SMB2_TREE_DISCONNECT */ false, | |
196 | /* SMB2_CREATE */ true, | |
197 | /* SMB2_CLOSE */ false, | |
198 | /* SMB2_FLUSH */ false, | |
199 | /* SMB2_READ */ true, | |
200 | /* SMB2_WRITE */ false, | |
201 | /* SMB2_LOCK */ false, | |
202 | /* SMB2_IOCTL */ true, | |
203 | /* SMB2_CANCEL */ false, /* BB CHECK this not listed in documentation */ | |
204 | /* SMB2_ECHO */ false, | |
205 | /* SMB2_QUERY_DIRECTORY */ true, | |
206 | /* SMB2_CHANGE_NOTIFY */ true, | |
207 | /* SMB2_QUERY_INFO */ true, | |
208 | /* SMB2_SET_INFO */ false, | |
209 | /* SMB2_OPLOCK_BREAK */ false | |
210 | }; | |
211 | ||
212 | /* | |
213 | * Returns the pointer to the beginning of the data area. Length of the data | |
214 | * area and the offset to it (from the beginning of the smb are also returned. | |
215 | */ | |
ec2e4523 | 216 | char * |
093b2bda PS |
217 | smb2_get_data_area_len(int *off, int *len, struct smb2_hdr *hdr) |
218 | { | |
219 | *off = 0; | |
220 | *len = 0; | |
221 | ||
222 | /* error responses do not have data area */ | |
223 | if (hdr->Status && hdr->Status != STATUS_MORE_PROCESSING_REQUIRED && | |
224 | (((struct smb2_err_rsp *)hdr)->StructureSize) == | |
225 | SMB2_ERROR_STRUCTURE_SIZE2) | |
226 | return NULL; | |
227 | ||
228 | /* | |
229 | * Following commands have data areas so we have to get the location | |
230 | * of the data buffer offset and data buffer length for the particular | |
231 | * command. | |
232 | */ | |
233 | switch (hdr->Command) { | |
234 | case SMB2_NEGOTIATE: | |
ec2e4523 PS |
235 | *off = le16_to_cpu( |
236 | ((struct smb2_negotiate_rsp *)hdr)->SecurityBufferOffset); | |
237 | *len = le16_to_cpu( | |
238 | ((struct smb2_negotiate_rsp *)hdr)->SecurityBufferLength); | |
239 | break; | |
093b2bda | 240 | case SMB2_SESSION_SETUP: |
5478f9ba PS |
241 | *off = le16_to_cpu( |
242 | ((struct smb2_sess_setup_rsp *)hdr)->SecurityBufferOffset); | |
243 | *len = le16_to_cpu( | |
244 | ((struct smb2_sess_setup_rsp *)hdr)->SecurityBufferLength); | |
245 | break; | |
093b2bda | 246 | case SMB2_CREATE: |
2503a0db PS |
247 | *off = le32_to_cpu( |
248 | ((struct smb2_create_rsp *)hdr)->CreateContextsOffset); | |
249 | *len = le32_to_cpu( | |
250 | ((struct smb2_create_rsp *)hdr)->CreateContextsLength); | |
251 | break; | |
093b2bda | 252 | case SMB2_QUERY_INFO: |
be4cb9e3 PS |
253 | *off = le16_to_cpu( |
254 | ((struct smb2_query_info_rsp *)hdr)->OutputBufferOffset); | |
255 | *len = le32_to_cpu( | |
256 | ((struct smb2_query_info_rsp *)hdr)->OutputBufferLength); | |
257 | break; | |
258 | case SMB2_READ: | |
09a4707e PS |
259 | *off = ((struct smb2_read_rsp *)hdr)->DataOffset; |
260 | *len = le32_to_cpu(((struct smb2_read_rsp *)hdr)->DataLength); | |
261 | break; | |
093b2bda | 262 | case SMB2_QUERY_DIRECTORY: |
d324f08d PS |
263 | *off = le16_to_cpu( |
264 | ((struct smb2_query_directory_rsp *)hdr)->OutputBufferOffset); | |
265 | *len = le32_to_cpu( | |
266 | ((struct smb2_query_directory_rsp *)hdr)->OutputBufferLength); | |
267 | break; | |
093b2bda | 268 | case SMB2_IOCTL: |
4a72dafa SF |
269 | *off = le32_to_cpu( |
270 | ((struct smb2_ioctl_rsp *)hdr)->OutputOffset); | |
271 | *len = le32_to_cpu(((struct smb2_ioctl_rsp *)hdr)->OutputCount); | |
272 | break; | |
093b2bda PS |
273 | case SMB2_CHANGE_NOTIFY: |
274 | default: | |
275 | /* BB FIXME for unimplemented cases above */ | |
f96637be | 276 | cifs_dbg(VFS, "no length check for command\n"); |
093b2bda PS |
277 | break; |
278 | } | |
279 | ||
280 | /* | |
281 | * Invalid length or offset probably means data area is invalid, but | |
282 | * we have little choice but to ignore the data area in this case. | |
283 | */ | |
284 | if (*off > 4096) { | |
f96637be | 285 | cifs_dbg(VFS, "offset %d too large, data area ignored\n", *off); |
093b2bda PS |
286 | *len = 0; |
287 | *off = 0; | |
288 | } else if (*off < 0) { | |
f96637be JP |
289 | cifs_dbg(VFS, "negative offset %d to data invalid ignore data area\n", |
290 | *off); | |
093b2bda PS |
291 | *off = 0; |
292 | *len = 0; | |
293 | } else if (*len < 0) { | |
f96637be JP |
294 | cifs_dbg(VFS, "negative data length %d invalid, data area ignored\n", |
295 | *len); | |
093b2bda PS |
296 | *len = 0; |
297 | } else if (*len > 128 * 1024) { | |
f96637be | 298 | cifs_dbg(VFS, "data area larger than 128K: %d\n", *len); |
093b2bda PS |
299 | *len = 0; |
300 | } | |
301 | ||
302 | /* return pointer to beginning of data area, ie offset from SMB start */ | |
303 | if ((*off != 0) && (*len != 0)) | |
304 | return hdr->ProtocolId + *off; | |
305 | else | |
306 | return NULL; | |
307 | } | |
308 | ||
309 | /* | |
310 | * Calculate the size of the SMB message based on the fixed header | |
311 | * portion, the number of word parameters and the data portion of the message. | |
312 | */ | |
313 | unsigned int | |
d324f08d | 314 | smb2_calc_size(void *buf) |
093b2bda | 315 | { |
d324f08d | 316 | struct smb2_hdr *hdr = (struct smb2_hdr *)buf; |
093b2bda PS |
317 | struct smb2_pdu *pdu = (struct smb2_pdu *)hdr; |
318 | int offset; /* the offset from the beginning of SMB to data area */ | |
319 | int data_length; /* the length of the variable length data area */ | |
320 | /* Structure Size has already been checked to make sure it is 64 */ | |
321 | int len = 4 + le16_to_cpu(pdu->hdr.StructureSize); | |
322 | ||
323 | /* | |
324 | * StructureSize2, ie length of fixed parameter area has already | |
325 | * been checked to make sure it is the correct length. | |
326 | */ | |
327 | len += le16_to_cpu(pdu->StructureSize2); | |
328 | ||
329 | if (has_smb2_data_area[le16_to_cpu(hdr->Command)] == false) | |
330 | goto calc_size_exit; | |
331 | ||
332 | smb2_get_data_area_len(&offset, &data_length, hdr); | |
f96637be | 333 | cifs_dbg(FYI, "SMB2 data length %d offset %d\n", data_length, offset); |
093b2bda PS |
334 | |
335 | if (data_length > 0) { | |
336 | /* | |
337 | * Check to make sure that data area begins after fixed area, | |
338 | * Note that last byte of the fixed area is part of data area | |
339 | * for some commands, typically those with odd StructureSize, | |
340 | * so we must add one to the calculation (and 4 to account for | |
341 | * the size of the RFC1001 hdr. | |
342 | */ | |
343 | if (offset + 4 + 1 < len) { | |
f96637be JP |
344 | cifs_dbg(VFS, "data area offset %d overlaps SMB2 header %d\n", |
345 | offset + 4 + 1, len); | |
093b2bda PS |
346 | data_length = 0; |
347 | } else { | |
348 | len = 4 + offset + data_length; | |
349 | } | |
350 | } | |
351 | calc_size_exit: | |
f96637be | 352 | cifs_dbg(FYI, "SMB2 len %d\n", len); |
093b2bda PS |
353 | return len; |
354 | } | |
2503a0db PS |
355 | |
356 | /* Note: caller must free return buffer */ | |
357 | __le16 * | |
358 | cifs_convert_path_to_utf16(const char *from, struct cifs_sb_info *cifs_sb) | |
359 | { | |
360 | int len; | |
361 | const char *start_of_path; | |
362 | __le16 *to; | |
363 | ||
364 | /* Windows doesn't allow paths beginning with \ */ | |
365 | if (from[0] == '\\') | |
366 | start_of_path = from + 1; | |
367 | else | |
368 | start_of_path = from; | |
369 | to = cifs_strndup_to_utf16(start_of_path, PATH_MAX, &len, | |
370 | cifs_sb->local_nls, | |
371 | cifs_sb->mnt_cifs_flags & | |
372 | CIFS_MOUNT_MAP_SPECIAL_CHR); | |
373 | return to; | |
374 | } | |
983c88a4 | 375 | |
0822f514 PS |
376 | __le32 |
377 | smb2_get_lease_state(struct cifsInodeInfo *cinode) | |
378 | { | |
379 | if (cinode->clientCanCacheAll) | |
380 | return SMB2_LEASE_WRITE_CACHING | SMB2_LEASE_READ_CACHING; | |
381 | else if (cinode->clientCanCacheRead) | |
382 | return SMB2_LEASE_READ_CACHING; | |
383 | return 0; | |
384 | } | |
385 | ||
386 | __u8 smb2_map_lease_to_oplock(__le32 lease_state) | |
387 | { | |
388 | if (lease_state & SMB2_LEASE_WRITE_CACHING) { | |
389 | if (lease_state & SMB2_LEASE_HANDLE_CACHING) | |
390 | return SMB2_OPLOCK_LEVEL_BATCH; | |
391 | else | |
392 | return SMB2_OPLOCK_LEVEL_EXCLUSIVE; | |
393 | } else if (lease_state & SMB2_LEASE_READ_CACHING) | |
394 | return SMB2_OPLOCK_LEVEL_II; | |
395 | return 0; | |
396 | } | |
397 | ||
233839b1 PS |
398 | struct smb2_lease_break_work { |
399 | struct work_struct lease_break; | |
400 | struct tcon_link *tlink; | |
401 | __u8 lease_key[16]; | |
402 | __le32 lease_state; | |
403 | }; | |
404 | ||
405 | static void | |
406 | cifs_ses_oplock_break(struct work_struct *work) | |
407 | { | |
408 | struct smb2_lease_break_work *lw = container_of(work, | |
409 | struct smb2_lease_break_work, lease_break); | |
410 | int rc; | |
411 | ||
412 | rc = SMB2_lease_break(0, tlink_tcon(lw->tlink), lw->lease_key, | |
413 | lw->lease_state); | |
f96637be | 414 | cifs_dbg(FYI, "Lease release rc %d\n", rc); |
233839b1 PS |
415 | cifs_put_tlink(lw->tlink); |
416 | kfree(lw); | |
417 | } | |
418 | ||
0822f514 PS |
419 | static bool |
420 | smb2_is_valid_lease_break(char *buffer, struct TCP_Server_Info *server) | |
421 | { | |
422 | struct smb2_lease_break *rsp = (struct smb2_lease_break *)buffer; | |
423 | struct list_head *tmp, *tmp1, *tmp2; | |
424 | struct cifs_ses *ses; | |
425 | struct cifs_tcon *tcon; | |
426 | struct cifsInodeInfo *cinode; | |
427 | struct cifsFileInfo *cfile; | |
233839b1 PS |
428 | struct cifs_pending_open *open; |
429 | struct smb2_lease_break_work *lw; | |
430 | bool found; | |
12e8a208 SF |
431 | int ack_req = le32_to_cpu(rsp->Flags & |
432 | SMB2_NOTIFY_BREAK_LEASE_FLAG_ACK_REQUIRED); | |
233839b1 PS |
433 | |
434 | lw = kmalloc(sizeof(struct smb2_lease_break_work), GFP_KERNEL); | |
f96637be | 435 | if (!lw) |
233839b1 | 436 | return false; |
233839b1 PS |
437 | |
438 | INIT_WORK(&lw->lease_break, cifs_ses_oplock_break); | |
439 | lw->lease_state = rsp->NewLeaseState; | |
0822f514 | 440 | |
f96637be | 441 | cifs_dbg(FYI, "Checking for lease break\n"); |
0822f514 PS |
442 | |
443 | /* look up tcon based on tid & uid */ | |
444 | spin_lock(&cifs_tcp_ses_lock); | |
445 | list_for_each(tmp, &server->smb_ses_list) { | |
446 | ses = list_entry(tmp, struct cifs_ses, smb_ses_list); | |
233839b1 PS |
447 | |
448 | spin_lock(&cifs_file_list_lock); | |
0822f514 PS |
449 | list_for_each(tmp1, &ses->tcon_list) { |
450 | tcon = list_entry(tmp1, struct cifs_tcon, tcon_list); | |
451 | ||
452 | cifs_stats_inc(&tcon->stats.cifs_stats.num_oplock_brks); | |
0822f514 PS |
453 | list_for_each(tmp2, &tcon->openFileList) { |
454 | cfile = list_entry(tmp2, struct cifsFileInfo, | |
233839b1 | 455 | tlist); |
0822f514 PS |
456 | cinode = CIFS_I(cfile->dentry->d_inode); |
457 | ||
458 | if (memcmp(cinode->lease_key, rsp->LeaseKey, | |
459 | SMB2_LEASE_KEY_SIZE)) | |
460 | continue; | |
461 | ||
f96637be JP |
462 | cifs_dbg(FYI, "found in the open list\n"); |
463 | cifs_dbg(FYI, "lease key match, lease break 0x%d\n", | |
464 | le32_to_cpu(rsp->NewLeaseState)); | |
0822f514 PS |
465 | |
466 | smb2_set_oplock_level(cinode, | |
467 | smb2_map_lease_to_oplock(rsp->NewLeaseState)); | |
468 | ||
233839b1 | 469 | if (ack_req) |
0822f514 PS |
470 | cfile->oplock_break_cancelled = false; |
471 | else | |
472 | cfile->oplock_break_cancelled = true; | |
473 | ||
474 | queue_work(cifsiod_wq, &cfile->oplock_break); | |
475 | ||
476 | spin_unlock(&cifs_file_list_lock); | |
477 | spin_unlock(&cifs_tcp_ses_lock); | |
478 | return true; | |
479 | } | |
233839b1 PS |
480 | |
481 | found = false; | |
482 | list_for_each_entry(open, &tcon->pending_opens, olist) { | |
483 | if (memcmp(open->lease_key, rsp->LeaseKey, | |
484 | SMB2_LEASE_KEY_SIZE)) | |
485 | continue; | |
486 | ||
487 | if (!found && ack_req) { | |
488 | found = true; | |
489 | memcpy(lw->lease_key, open->lease_key, | |
490 | SMB2_LEASE_KEY_SIZE); | |
491 | lw->tlink = cifs_get_tlink(open->tlink); | |
492 | queue_work(cifsiod_wq, | |
493 | &lw->lease_break); | |
494 | } | |
495 | ||
f96637be JP |
496 | cifs_dbg(FYI, "found in the pending open list\n"); |
497 | cifs_dbg(FYI, "lease key match, lease break 0x%d\n", | |
498 | le32_to_cpu(rsp->NewLeaseState)); | |
233839b1 PS |
499 | |
500 | open->oplock = | |
501 | smb2_map_lease_to_oplock(rsp->NewLeaseState); | |
502 | } | |
503 | if (found) { | |
504 | spin_unlock(&cifs_file_list_lock); | |
505 | spin_unlock(&cifs_tcp_ses_lock); | |
506 | return true; | |
507 | } | |
0822f514 | 508 | } |
233839b1 | 509 | spin_unlock(&cifs_file_list_lock); |
0822f514 PS |
510 | } |
511 | spin_unlock(&cifs_tcp_ses_lock); | |
233839b1 | 512 | kfree(lw); |
f96637be | 513 | cifs_dbg(FYI, "Can not process lease break - no lease matched\n"); |
0822f514 PS |
514 | return false; |
515 | } | |
516 | ||
983c88a4 PS |
517 | bool |
518 | smb2_is_valid_oplock_break(char *buffer, struct TCP_Server_Info *server) | |
519 | { | |
520 | struct smb2_oplock_break *rsp = (struct smb2_oplock_break *)buffer; | |
521 | struct list_head *tmp, *tmp1, *tmp2; | |
522 | struct cifs_ses *ses; | |
523 | struct cifs_tcon *tcon; | |
524 | struct cifsInodeInfo *cinode; | |
525 | struct cifsFileInfo *cfile; | |
526 | ||
f96637be | 527 | cifs_dbg(FYI, "Checking for oplock break\n"); |
983c88a4 PS |
528 | |
529 | if (rsp->hdr.Command != SMB2_OPLOCK_BREAK) | |
530 | return false; | |
531 | ||
12e8a208 | 532 | if (rsp->StructureSize != |
983c88a4 | 533 | smb2_rsp_struct_sizes[SMB2_OPLOCK_BREAK_HE]) { |
0822f514 PS |
534 | if (le16_to_cpu(rsp->StructureSize) == 44) |
535 | return smb2_is_valid_lease_break(buffer, server); | |
536 | else | |
537 | return false; | |
983c88a4 PS |
538 | } |
539 | ||
f96637be | 540 | cifs_dbg(FYI, "oplock level 0x%d\n", rsp->OplockLevel); |
983c88a4 PS |
541 | |
542 | /* look up tcon based on tid & uid */ | |
543 | spin_lock(&cifs_tcp_ses_lock); | |
544 | list_for_each(tmp, &server->smb_ses_list) { | |
545 | ses = list_entry(tmp, struct cifs_ses, smb_ses_list); | |
546 | list_for_each(tmp1, &ses->tcon_list) { | |
547 | tcon = list_entry(tmp1, struct cifs_tcon, tcon_list); | |
548 | ||
549 | cifs_stats_inc(&tcon->stats.cifs_stats.num_oplock_brks); | |
550 | spin_lock(&cifs_file_list_lock); | |
551 | list_for_each(tmp2, &tcon->openFileList) { | |
552 | cfile = list_entry(tmp2, struct cifsFileInfo, | |
553 | tlist); | |
554 | if (rsp->PersistentFid != | |
555 | cfile->fid.persistent_fid || | |
556 | rsp->VolatileFid != | |
557 | cfile->fid.volatile_fid) | |
558 | continue; | |
559 | ||
f96637be | 560 | cifs_dbg(FYI, "file id match, oplock break\n"); |
983c88a4 PS |
561 | cinode = CIFS_I(cfile->dentry->d_inode); |
562 | ||
563 | if (!cinode->clientCanCacheAll && | |
564 | rsp->OplockLevel == SMB2_OPLOCK_LEVEL_NONE) | |
565 | cfile->oplock_break_cancelled = true; | |
566 | else | |
567 | cfile->oplock_break_cancelled = false; | |
568 | ||
569 | smb2_set_oplock_level(cinode, | |
570 | rsp->OplockLevel ? SMB2_OPLOCK_LEVEL_II : 0); | |
571 | ||
572 | queue_work(cifsiod_wq, &cfile->oplock_break); | |
573 | ||
574 | spin_unlock(&cifs_file_list_lock); | |
575 | spin_unlock(&cifs_tcp_ses_lock); | |
576 | return true; | |
577 | } | |
578 | spin_unlock(&cifs_file_list_lock); | |
579 | spin_unlock(&cifs_tcp_ses_lock); | |
f96637be | 580 | cifs_dbg(FYI, "No matching file for oplock break\n"); |
983c88a4 PS |
581 | return true; |
582 | } | |
583 | } | |
584 | spin_unlock(&cifs_tcp_ses_lock); | |
f96637be | 585 | cifs_dbg(FYI, "Can not process oplock break for non-existent connection\n"); |
983c88a4 PS |
586 | return false; |
587 | } |