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