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