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 | |
48 | cERROR(1, "Received Request not response"); | |
49 | } | |
50 | } else { /* bad signature or mid */ | |
51 | if (*(__le32 *)hdr->ProtocolId != SMB2_PROTO_NUMBER) | |
52 | cERROR(1, "Bad protocol string signature header %x", | |
53 | *(unsigned int *) hdr->ProtocolId); | |
54 | if (mid != hdr->MessageId) | |
55 | cERROR(1, "Mids do not match"); | |
56 | } | |
57 | cERROR(1, "Bad SMB detected. The Mid=%llu", hdr->MessageId); | |
58 | return 1; | |
59 | } | |
60 | ||
61 | /* | |
62 | * The following table defines the expected "StructureSize" of SMB2 responses | |
63 | * in order by SMB2 command. This is similar to "wct" in SMB/CIFS responses. | |
64 | * | |
65 | * Note that commands are defined in smb2pdu.h in le16 but the array below is | |
66 | * indexed by command in host byte order | |
67 | */ | |
68 | static const __le16 smb2_rsp_struct_sizes[NUMBER_OF_SMB2_COMMANDS] = { | |
69 | /* SMB2_NEGOTIATE */ __constant_cpu_to_le16(65), | |
70 | /* SMB2_SESSION_SETUP */ __constant_cpu_to_le16(9), | |
71 | /* SMB2_LOGOFF */ __constant_cpu_to_le16(4), | |
72 | /* SMB2_TREE_CONNECT */ __constant_cpu_to_le16(16), | |
73 | /* SMB2_TREE_DISCONNECT */ __constant_cpu_to_le16(4), | |
74 | /* SMB2_CREATE */ __constant_cpu_to_le16(89), | |
75 | /* SMB2_CLOSE */ __constant_cpu_to_le16(60), | |
76 | /* SMB2_FLUSH */ __constant_cpu_to_le16(4), | |
77 | /* SMB2_READ */ __constant_cpu_to_le16(17), | |
78 | /* SMB2_WRITE */ __constant_cpu_to_le16(17), | |
79 | /* SMB2_LOCK */ __constant_cpu_to_le16(4), | |
80 | /* SMB2_IOCTL */ __constant_cpu_to_le16(49), | |
81 | /* BB CHECK this ... not listed in documentation */ | |
82 | /* SMB2_CANCEL */ __constant_cpu_to_le16(0), | |
83 | /* SMB2_ECHO */ __constant_cpu_to_le16(4), | |
84 | /* SMB2_QUERY_DIRECTORY */ __constant_cpu_to_le16(9), | |
85 | /* SMB2_CHANGE_NOTIFY */ __constant_cpu_to_le16(9), | |
86 | /* SMB2_QUERY_INFO */ __constant_cpu_to_le16(9), | |
87 | /* SMB2_SET_INFO */ __constant_cpu_to_le16(2), | |
88 | /* BB FIXME can also be 44 for lease break */ | |
89 | /* SMB2_OPLOCK_BREAK */ __constant_cpu_to_le16(24) | |
90 | }; | |
91 | ||
92 | int | |
93 | smb2_check_message(char *buf, unsigned int length) | |
94 | { | |
95 | struct smb2_hdr *hdr = (struct smb2_hdr *)buf; | |
96 | struct smb2_pdu *pdu = (struct smb2_pdu *)hdr; | |
97 | __u64 mid = hdr->MessageId; | |
98 | __u32 len = get_rfc1002_length(buf); | |
99 | __u32 clc_len; /* calculated length */ | |
100 | int command; | |
101 | ||
102 | /* BB disable following printk later */ | |
103 | cFYI(1, "%s length: 0x%x, smb_buf_length: 0x%x", __func__, length, len); | |
104 | ||
105 | /* | |
106 | * Add function to do table lookup of StructureSize by command | |
107 | * ie Validate the wct via smb2_struct_sizes table above | |
108 | */ | |
109 | ||
110 | if (length < 2 + sizeof(struct smb2_hdr)) { | |
111 | if ((length >= sizeof(struct smb2_hdr)) && (hdr->Status != 0)) { | |
112 | pdu->StructureSize2 = 0; | |
113 | /* | |
114 | * As with SMB/CIFS, on some error cases servers may | |
115 | * not return wct properly | |
116 | */ | |
117 | return 0; | |
118 | } else { | |
119 | cERROR(1, "Length less than SMB header size"); | |
120 | } | |
121 | return 1; | |
122 | } | |
123 | if (len > CIFSMaxBufSize + MAX_SMB2_HDR_SIZE - 4) { | |
124 | cERROR(1, "SMB length greater than maximum, mid=%lld", mid); | |
125 | return 1; | |
126 | } | |
127 | ||
128 | if (check_smb2_hdr(hdr, mid)) | |
129 | return 1; | |
130 | ||
131 | if (hdr->StructureSize != SMB2_HEADER_SIZE) { | |
132 | cERROR(1, "Illegal structure size %d", | |
133 | le16_to_cpu(hdr->StructureSize)); | |
134 | return 1; | |
135 | } | |
136 | ||
137 | command = le16_to_cpu(hdr->Command); | |
138 | if (command >= NUMBER_OF_SMB2_COMMANDS) { | |
139 | cERROR(1, "Illegal SMB2 command %d", command); | |
140 | return 1; | |
141 | } | |
142 | ||
143 | if (smb2_rsp_struct_sizes[command] != pdu->StructureSize2) { | |
144 | if (hdr->Status == 0 || | |
145 | pdu->StructureSize2 != SMB2_ERROR_STRUCTURE_SIZE2) { | |
146 | /* error packets have 9 byte structure size */ | |
147 | cERROR(1, "Illegal response size %u for command %d", | |
148 | le16_to_cpu(pdu->StructureSize2), command); | |
149 | return 1; | |
150 | } | |
151 | } | |
152 | ||
153 | if (4 + len != length) { | |
154 | cERROR(1, "Total length %u RFC1002 length %u mismatch mid %llu", | |
155 | length, 4 + len, mid); | |
156 | return 1; | |
157 | } | |
158 | ||
159 | clc_len = smb2_calc_size(hdr); | |
160 | ||
161 | if (4 + len != clc_len) { | |
162 | cFYI(1, "Calculated size %u length %u mismatch mid %llu", | |
163 | clc_len, 4 + len, mid); | |
164 | if (clc_len == 4 + len + 1) /* BB FIXME (fix samba) */ | |
165 | return 0; /* BB workaround Samba 3 bug SessSetup rsp */ | |
166 | return 1; | |
167 | } | |
168 | return 0; | |
169 | } | |
170 | ||
171 | /* | |
172 | * The size of the variable area depends on the offset and length fields | |
173 | * located in different fields for various SMB2 responses. SMB2 responses | |
174 | * with no variable length info, show an offset of zero for the offset field. | |
175 | */ | |
176 | static const bool has_smb2_data_area[NUMBER_OF_SMB2_COMMANDS] = { | |
177 | /* SMB2_NEGOTIATE */ true, | |
178 | /* SMB2_SESSION_SETUP */ true, | |
179 | /* SMB2_LOGOFF */ false, | |
180 | /* SMB2_TREE_CONNECT */ false, | |
181 | /* SMB2_TREE_DISCONNECT */ false, | |
182 | /* SMB2_CREATE */ true, | |
183 | /* SMB2_CLOSE */ false, | |
184 | /* SMB2_FLUSH */ false, | |
185 | /* SMB2_READ */ true, | |
186 | /* SMB2_WRITE */ false, | |
187 | /* SMB2_LOCK */ false, | |
188 | /* SMB2_IOCTL */ true, | |
189 | /* SMB2_CANCEL */ false, /* BB CHECK this not listed in documentation */ | |
190 | /* SMB2_ECHO */ false, | |
191 | /* SMB2_QUERY_DIRECTORY */ true, | |
192 | /* SMB2_CHANGE_NOTIFY */ true, | |
193 | /* SMB2_QUERY_INFO */ true, | |
194 | /* SMB2_SET_INFO */ false, | |
195 | /* SMB2_OPLOCK_BREAK */ false | |
196 | }; | |
197 | ||
198 | /* | |
199 | * Returns the pointer to the beginning of the data area. Length of the data | |
200 | * area and the offset to it (from the beginning of the smb are also returned. | |
201 | */ | |
ec2e4523 | 202 | char * |
093b2bda PS |
203 | smb2_get_data_area_len(int *off, int *len, struct smb2_hdr *hdr) |
204 | { | |
205 | *off = 0; | |
206 | *len = 0; | |
207 | ||
208 | /* error responses do not have data area */ | |
209 | if (hdr->Status && hdr->Status != STATUS_MORE_PROCESSING_REQUIRED && | |
210 | (((struct smb2_err_rsp *)hdr)->StructureSize) == | |
211 | SMB2_ERROR_STRUCTURE_SIZE2) | |
212 | return NULL; | |
213 | ||
214 | /* | |
215 | * Following commands have data areas so we have to get the location | |
216 | * of the data buffer offset and data buffer length for the particular | |
217 | * command. | |
218 | */ | |
219 | switch (hdr->Command) { | |
220 | case SMB2_NEGOTIATE: | |
ec2e4523 PS |
221 | *off = le16_to_cpu( |
222 | ((struct smb2_negotiate_rsp *)hdr)->SecurityBufferOffset); | |
223 | *len = le16_to_cpu( | |
224 | ((struct smb2_negotiate_rsp *)hdr)->SecurityBufferLength); | |
225 | break; | |
093b2bda | 226 | case SMB2_SESSION_SETUP: |
5478f9ba PS |
227 | *off = le16_to_cpu( |
228 | ((struct smb2_sess_setup_rsp *)hdr)->SecurityBufferOffset); | |
229 | *len = le16_to_cpu( | |
230 | ((struct smb2_sess_setup_rsp *)hdr)->SecurityBufferLength); | |
231 | break; | |
093b2bda | 232 | case SMB2_CREATE: |
2503a0db PS |
233 | *off = le32_to_cpu( |
234 | ((struct smb2_create_rsp *)hdr)->CreateContextsOffset); | |
235 | *len = le32_to_cpu( | |
236 | ((struct smb2_create_rsp *)hdr)->CreateContextsLength); | |
237 | break; | |
093b2bda | 238 | case SMB2_QUERY_INFO: |
be4cb9e3 PS |
239 | *off = le16_to_cpu( |
240 | ((struct smb2_query_info_rsp *)hdr)->OutputBufferOffset); | |
241 | *len = le32_to_cpu( | |
242 | ((struct smb2_query_info_rsp *)hdr)->OutputBufferLength); | |
243 | break; | |
244 | case SMB2_READ: | |
093b2bda PS |
245 | case SMB2_QUERY_DIRECTORY: |
246 | case SMB2_IOCTL: | |
247 | case SMB2_CHANGE_NOTIFY: | |
248 | default: | |
249 | /* BB FIXME for unimplemented cases above */ | |
250 | cERROR(1, "no length check for command"); | |
251 | break; | |
252 | } | |
253 | ||
254 | /* | |
255 | * Invalid length or offset probably means data area is invalid, but | |
256 | * we have little choice but to ignore the data area in this case. | |
257 | */ | |
258 | if (*off > 4096) { | |
259 | cERROR(1, "offset %d too large, data area ignored", *off); | |
260 | *len = 0; | |
261 | *off = 0; | |
262 | } else if (*off < 0) { | |
263 | cERROR(1, "negative offset %d to data invalid ignore data area", | |
264 | *off); | |
265 | *off = 0; | |
266 | *len = 0; | |
267 | } else if (*len < 0) { | |
268 | cERROR(1, "negative data length %d invalid, data area ignored", | |
269 | *len); | |
270 | *len = 0; | |
271 | } else if (*len > 128 * 1024) { | |
272 | cERROR(1, "data area larger than 128K: %d", *len); | |
273 | *len = 0; | |
274 | } | |
275 | ||
276 | /* return pointer to beginning of data area, ie offset from SMB start */ | |
277 | if ((*off != 0) && (*len != 0)) | |
278 | return hdr->ProtocolId + *off; | |
279 | else | |
280 | return NULL; | |
281 | } | |
282 | ||
283 | /* | |
284 | * Calculate the size of the SMB message based on the fixed header | |
285 | * portion, the number of word parameters and the data portion of the message. | |
286 | */ | |
287 | unsigned int | |
288 | smb2_calc_size(struct smb2_hdr *hdr) | |
289 | { | |
290 | struct smb2_pdu *pdu = (struct smb2_pdu *)hdr; | |
291 | int offset; /* the offset from the beginning of SMB to data area */ | |
292 | int data_length; /* the length of the variable length data area */ | |
293 | /* Structure Size has already been checked to make sure it is 64 */ | |
294 | int len = 4 + le16_to_cpu(pdu->hdr.StructureSize); | |
295 | ||
296 | /* | |
297 | * StructureSize2, ie length of fixed parameter area has already | |
298 | * been checked to make sure it is the correct length. | |
299 | */ | |
300 | len += le16_to_cpu(pdu->StructureSize2); | |
301 | ||
302 | if (has_smb2_data_area[le16_to_cpu(hdr->Command)] == false) | |
303 | goto calc_size_exit; | |
304 | ||
305 | smb2_get_data_area_len(&offset, &data_length, hdr); | |
306 | cFYI(1, "SMB2 data length %d offset %d", data_length, offset); | |
307 | ||
308 | if (data_length > 0) { | |
309 | /* | |
310 | * Check to make sure that data area begins after fixed area, | |
311 | * Note that last byte of the fixed area is part of data area | |
312 | * for some commands, typically those with odd StructureSize, | |
313 | * so we must add one to the calculation (and 4 to account for | |
314 | * the size of the RFC1001 hdr. | |
315 | */ | |
316 | if (offset + 4 + 1 < len) { | |
317 | cERROR(1, "data area offset %d overlaps SMB2 header %d", | |
318 | offset + 4 + 1, len); | |
319 | data_length = 0; | |
320 | } else { | |
321 | len = 4 + offset + data_length; | |
322 | } | |
323 | } | |
324 | calc_size_exit: | |
325 | cFYI(1, "SMB2 len %d", len); | |
326 | return len; | |
327 | } | |
2503a0db PS |
328 | |
329 | /* Note: caller must free return buffer */ | |
330 | __le16 * | |
331 | cifs_convert_path_to_utf16(const char *from, struct cifs_sb_info *cifs_sb) | |
332 | { | |
333 | int len; | |
334 | const char *start_of_path; | |
335 | __le16 *to; | |
336 | ||
337 | /* Windows doesn't allow paths beginning with \ */ | |
338 | if (from[0] == '\\') | |
339 | start_of_path = from + 1; | |
340 | else | |
341 | start_of_path = from; | |
342 | to = cifs_strndup_to_utf16(start_of_path, PATH_MAX, &len, | |
343 | cifs_sb->local_nls, | |
344 | cifs_sb->mnt_cifs_flags & | |
345 | CIFS_MOUNT_MAP_SPECIAL_CHR); | |
346 | return to; | |
347 | } |